//Für eine Art Komponenten-Konzept ala COM (+ abstrakte Schnittstellen über DLL Grenzen mit anderen CRTs)
//Um meine Architektur noch "benutzungssicherer" zu machen versuche ich gerade:
//1. zu verhindern das meine Klassen direkt auf dem Stack oder Heap erzeugbar sind
//2. zur Kompilierzeit zu prüfen ob die Klasse auch diesen Anforderungen entspricht
//3. einen Weg zu finden wie das "Konzept" z.B. über Ableitung leichter auf viele Klassen angwendet werden kann
#include <type_traits>
class ClassA
{
private:
// keine Stack-Konstruction mehr moeglich
ClassA();
ClassA(int a) {}
ClassA(int a, float b) {}
// keine direkte Heap-Konstruction mehr moeglich
void* operator new(std::size_t size){ return ::operator new(size); }
// kein Heap delete mehr moeglich
void operator delete(void* object) { ::operator delete(object); }
//die Array-Varianten fehlen noch...
public: // Das "Interface" für meine Factory
// mein "new" aka verstecktes new+ctor nutzen
static ClassA* New(int a) { return new ClassA(a); }
static ClassA* New(int a, float b) { return new ClassA(a, b); }
// mein "delete"
void Delete() /*override*/ { delete this; }
};
int main()
{
// 1. scheint damit erfüllt
//ClassA t(); // kompiliert nicht - OK
//ClassA t(1,2.0); // kompiliert nicht - OK
//ClassA* t = new ClassA(); // kompiliert nicht - OK
//ClassA* t = new ClassA(1,2.0); // kompiliert nicht - OK
// 2. so kann ich glaube ich erkennen ob die Klasse "konstruierbar" ist (meine Factory<ClassA, ClassB, ...> Template prüft das bisher so
// aber ich habe keine Idee wie ich prüfen kann ob sie auch nicht new- oder deletable ist?
static_assert(!std::is_constructible_v<ClassA>, "Is still constructible!!!");
// zu 3. habe ich absolut gar keine Idee ausser alles in jeder Klasse ausimplementieren :(
return 0;
}