Comment passer un pointeur de fonction qui pointe du constructeur?

Je suis en train de travailler sur la mise en œuvre d'un mécanisme de réflexion en C++.
Tous les objets à l'intérieur de mon code sont une sous-classe de l'Objet(de mon propre type générique) qui contiennent un membre statique de référence de type de Classe.

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

Pour toute sous-classe de l'Objet avec un membre de Classe statique donnée, je veux être capable d'initialiser 'créer' avec un pointeur vers le constructeur de cette sous-classe.

  • Bien que cela soit 6 ans après les faits, vous devriez donner beaucoup de pensée de savoir si vous voulez vraiment mettre en place votre propre réflexion mechanisn. D'abord songer à régler pour le moment de la compilation de "réflexion" à l'aide de modèles, type_traits et la SFINAE principe; ensuite, essayez l'une de l'existant en C++ réflexion bibliothèques; et c'est alors seulement que je considère avoir un aller à moi-même.
InformationsquelleAutor Kareem | 2009-06-05
  1. 58

    Vous ne pouvez pas prendre l'adresse d'un constructeur de C++98 Standard 12.1/12 Constructeurs - "12.1-12 Constructeurs - "L'adresse d'un constructeur ne doit pas être pris.")

    Votre meilleur pari est d'avoir une usine de fonction/méthode qui crée le Object et passer l'adresse de l'usine:

    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;
}
    • En faire un modèle fera il retourne en fait "Classe": template<typename T> Objet* ObjectFactory() { return T; } .... La classe foo("myFoo", &ObjectFactory<Class>);
    InformationsquelleAutor Michael Burr
  2. 3

    J'ai rencontré ce même problème. Ma solution a été d'un modèle de fonction qui appelle le constructeur. 

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

    Pour l'utiliser comme un pointeur de fonction est simple:

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

    Et pour obtenir une instance de Maclasse:

    MyClass* myClass = createMyClass();
    InformationsquelleAutor Andrew Wansink
  3. 2

    Hmm, bizarre. create est une variable de membre c'est à dire uniquement disponible dans les instances de classe, mais l'intention de ce qui semble être la création d'une instance en premier lieu.

    Vous ne pouvez pas prendre l'adresse d'un constructeur, mais vous pouvez créer statique méthodes de fabrique de votre propre et de prendre l'adresse de celui-ci.

    • laalto, Quand j'construction de l'objet de Classe je passe un nom et une fonction de création. Mon but est d'avoir une liste de Classes dont je peux consulter de n'importe où dans mon projet. Un pointeur vers une fonction membre statique serait de travailler.
    • Et d'ajouter un autre indirection mauvais pour la performance.
    InformationsquelleAutor laalto
  4. 2

    Lambda style:

    [](){return new YourClass();}
    • Veuillez envisager d'ajouter plus d'explication/contexte de ce que fait la réponse la plus utile pour les futurs lecteurs.
    • Certainement, mentionner que c'est une C++11 et, plus tard, de la fonctionnalité.
    InformationsquelleAutor lama12345
  5. 1

    Vous ne pouvez pas utiliser les pointeurs de fonction sur les méthodes, vous devez utiliser la méthode des pointeurs, qui ont bizarre syntaxe:

    void (MyClass::*method_ptr)(int x, int y);
method_ptr = &MyClass::MyMethod;

    Cela vous donne une méthode pointeur MyClass de la méthode - MyMethod. Cependant, ce n'est pas un vrai pointeur en ce qu'il n'est pas un absolu adresse de mémoire, il s'agit essentiellement d'un décalage (plus compliqué que cela, en raison de l'héritage virtuel, mais ce genre de choses est la mise en œuvre spécifique) dans une classe. Donc pour utiliser la méthode de pointeur, vous devez fournir une classe, comme ceci:

    MyClass myclass;
myclass.*method_ptr(x, y);

    ou

    MyClass *myclass = new MyClass;
myclass->*method_ptr(x, y);

    Bien sûr, il devrait être évident que vous ne pouvez pas utiliser une méthode pointeur sur un objet le constructeur. Afin d'utiliser une méthode de pointeur, vous devez avoir une instance de la classe du constructeur a déjà été appelé! Si dans votre cas, Michael Objet d'Usine suggestion est probablement la meilleure façon de le faire.

    • Ce n'est pas correct. &MyClass::MyMethod vous donne l'adresse en mémoire de la réelle le code exécutable de MyMethod. Les méthodes ont un implicite premier argument, le pointeur this. Vous ne fournissez pas une méthode à une classe, vous fournir avec un objet (une instance d'une classe, par exemple un ce pointeur). Aller chercher le thiscall convention d'appel.
    • Je dois ajouter qu'il y a plus de magie impliquées dans l'obtention de l'emplacement du code à appeler si la méthode est virtuelle, mais l'existence de méthodes, en aucune façon, dépend de l'existence d'une instance de la classe.
    • Ah, vous avez raison. Sur le plan conceptuel, il fait peu de différence à l'OP, soit un pointeur de méthode ne fonctionnera pas à moins qu'une instance de la classe existe. J'ai corrigé mon post pour en tenir compte.
    InformationsquelleAutor Niki Yoshiuchi
  6. -1

    À l'aide de Qt, vous pouvez appeler un constructeur avec Qt réflexion mécanismes (QMetaObject) si vous déclarez le constructeur comme Q_INVOKABLE (rien de plus à faire que cela).

    class MyClass : public QObject {
   Q_OBJECT
public:
   Q_INVOKABLE MyClass(int foo);
   MyClass *cloningMySelf() {
     return metaObject()->newInstance(Q_ARG(int, 42));
   }
};

    Je ne suis pas sûr que vous souhaitez intégrer Qt juste pour cette fonction 😉 mais peut-être que vous aimeriez avoir un regard sur la façon dont il le fait.

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

    InformationsquelleAutor Jim