Wie kann man einen Funktionszeiger übergeben, der auf einen Konstruktor zeigt?

Question

Ich arbeite an der Implementierung eines Reflexionsmechanismus in C++. Alle Objekte in meinem Code sind eine Unterklasse von Object (mein eigener generischer Typ), die ein statisches Mitgliedsdatenelement vom Typ Class enthalten.

class Class{
public:
   Class(const std::string &n, Object *(*c)());
protected:
   std::string name;     // Name for subclass
   Object *(*create)();  // Pointer to creation function for subclass
};

Für jede Unterklasse von Object mit einem statischen Class-Member-Datum möchte ich in der Lage sein, 'create' mit einem Zeiger auf den Konstruktor dieser Unterklasse zu initialisieren.

Answer 1

Die Adresse eines Konstruktors kann nicht übernommen werden (C++98 Standard 12.1/12 Konstruktoren - "12.1-12 Konstruktoren - "Die Adresse eines Konstruktors darf nicht übernommen werden.")

Am besten ist es, wenn Sie eine Fabrikfunktion/Methode haben, die die Object und geben Sie die Adresse der Fabrik an:

class Object;

class Class{
public:
   Class(const std::string &n, Object *(*c)()) : name(n), create(c) {};
protected:
   std::string name;     // Name for subclass
   Object *(*create)();  // Pointer to creation function for subclass
};

class Object {};

Object* ObjectFactory()
{
    return new Object;
}

int main(int argc, char**argv)
{
    Class foo( "myFoo", ObjectFactory);

    return 0;
}

Answer 2

Ich bin auf das gleiche Problem gestoßen. Meine Lösung war eine Vorlagenfunktion, die den Konstruktor aufrief.

template<class T> MyClass* create()
{
    return new T;
}

Die Verwendung als Funktionszeiger ist einfach:

MyClass* (*createMyClass)(void) = create<MyClass>;

Und um eine Instanz von MyClass zu erhalten:

MyClass* myClass = createMyClass();

Answer 3

Lambda-Stil:

[](){return new YourClass();}

Answer 4

Mit variadischen Vorlagen können Sie einen Wrapper erstellen, der den Konstruktor in einen Funktor verwandelt.

#include <utility>

template <typename T>
struct BindConstructor{
    template<typename... Args>
    T operator()(Args&&...args)const{
        return T(std::forward<Args>(args)...);
    }
};

struct Foo {
    Foo(int a, int b):a(a),b(b){}
    int a;
    int b;
};

template <typename Fn>
auto Bar(Fn f){
    return f(10,20);
}

int main(){
    Foo foo = Bar(BindConstructor<Foo>());
}

https://godbolt.org/z/5W383McTc

Answer 5

Hmm, seltsam. create ist eine Mitgliedsvariable, d.h. sie ist nur in Klasseninstanzen verfügbar, aber die Absicht scheint zu sein, überhaupt eine Instanz zu erstellen.

Sie können die Adresse eines Konstruktors nicht übernehmen, aber Sie können eigene statische Fabrikmethoden erstellen und die Adresse dieser Methoden übernehmen.