Wie Übergeben eines Funktionszeigers, der auf Konstruktor verweist?

Arbeite ich an der Umsetzung eines reflection-Mechanismus in C++.
Alle Objekte in meinem code sind eine Unterklasse von Object(mein eigener, generischer Typ), die eine statische member-datum von Typ-Klasse.

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 ein statisches Mitglied einer Klasse datum, ich möchte in der Lage sein zu initialisieren 'erstellen' mit einem Zeiger dem Konstruktor der Unterklasse.

InformationsquelleAutor der Frage Kareem | 2009-06-05

c++constructor function-pointers reflection

Kann man die Adresse eines Konstruktors (C++98-Standard 12.1/12-Konstruktoren - "12.1-12-Konstruktoren - "Die Adresse ein Konstruktor darf nicht eingenommen werden") ist.

Ihre beste Wette ist, um eine factory-Funktion/Methode, die schafft das Object auf und übergeben die Adresse der Fabrik:

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;
}

InformationsquelleAutor der Antwort Michael Burr

2

Hmm, seltsam. create ist eine member-variable, d.h. nur in der Klasse Instanzen, aber die Absicht, es zu schaffen scheint eine Instanz in den ersten Platz.

Kann man die Adresse von einem Konstruktor, aber Sie können erstellen Sie statische factory-Methoden der eigenen und nehmen Sie die-Adresse des.

InformationsquelleAutor der Antwort laalto
1

Sie nicht verwenden können regelmäßige Funktionszeigern auf Methoden, verwenden Sie die Methode, die Zeiger, die bizarre syntax:
```
void (MyClass::*method_ptr)(int x, int y);
method_ptr = &MyClass::MyMethod;
```
Dies gibt Ihnen eine Methode, die Zeiger, MyClass, die Methode MyMethod. Jedoch ist dies nicht eine echte Zeiger, dass es nicht eine absolute Speicheradresse, es ist im Prinzip ein offset (komplizierter, als dass aufgrund der virtuellen Vererbung, aber das Zeug ist die Umsetzung-spezifisch) in einer Klasse. So verwenden Sie die Methode, die Zeiger, die Sie haben, zu liefern Sie mit einer Klasse wie folgt:
```
MyClass myclass;
myclass.*method_ptr(x, y);
```
oder
```
MyClass *myclass = new MyClass;
myclass->*method_ptr(x, y);
```
Natürlich klar sein sollte, an dieser Stelle, dass Sie nicht verwenden können, eine Methode, die Zeiger verweisen auf ein Objekte-Konstruktor. Um zu verwenden, eine Methode, die Zeiger müssen Sie eine Instanz der Klasse Konstruktor wurde bereits genannt! Also in deinem Fall Michaels-Objekt Factory Vorschlag ist wahrscheinlich der beste Weg, es zu tun.

InformationsquelleAutor der Antwort Niki Yoshiuchi
0

Qt benutzt, können Sie einen Konstruktor mit Qt-reflection-Mechanismen (QMetaObject) geben Sie einen Konstruktor wie Q_INVOKABLE (nichts mehr zu tun, als dass).
```
class MyClass : public QObject {
   Q_OBJECT
public:
   Q_INVOKABLE MyClass(int foo);
   MyClass *cloningMySelf() {
     return metaObject()->newInstance(Q_ARG(int, 42));
   }
};
```
Ich bin nicht sicher, dass Sie einbetten möchten Qt nur für dieses feature 😉 aber vielleicht möchten Sie einen Blick zu haben auf die Art und Weise es das tut.

http://doc.qt.io/qt-5/metaobjects.html#meta-object-system

InformationsquelleAutor der Antwort Jim
0

Lambda-Stil:
```
[](){return new YourClass();}
```
InformationsquelleAutor der Antwort lama12345
0

Begegnete ich das gleiche problem. Meine Lösung war, eine Vorlage-Funktion, die als Konstruktor bezeichnet wird.
```
template<class T> MyClass* create()
{
    return new T;
}
```
Als eine Funktion Zeiger ist einfach:
```
MyClass* (*createMyClass)(void) = create<MyClass>;
```
Und um eine Instanz von MyClass:
```
MyClass* myClass = createMyClass();
```
InformationsquelleAutor der Antwort Andrew Wansink

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.