fonction en passant comme paramètre de constructeur de constructeur de classe de base lors de l'initialisation

Question

#include <iostream> 
#include<cstdio> 
#include<typeinfo> 

using std::cout; 
using std::endl; 

class foo; 
class bar 
{ 
    public: 
     bar() 
     { 
     } 
     bar(void (*getNextValue)(void)):memberFunctionPointer(getNextValue) 
     { 
     } 
     void calltoderivedslass() 
     { 
      // *memberFunctionPointer(); 
      ((bar*)this)->bar::memberFunctionPointer; 
     } 
     void (foo::*memberFunctionPointer)(); 
}; 

class foo : public bar 
{ 
    public: 
     foo():bar(static_cast<foo::*memberFunctionPointer>(&foo::hello)) 
     { 
     } 
     void hello() 
     { 
      printf("Hello \n\n"); 
     } 
}; 
void byebye() 
{ 
    cout << "bye" << endl; 
} 
int main() 
{ 
    foo testfoo; 
    //((testfoo).*(testfoo.memberFunctionPointer))(); 
    return 0; 
} 

erreur:

classname.cpp: In constructor "bar::bar(void (*)())": 
classname.cpp:15:68: error: cannot convert "void (*)()" to "void (foo::*)()" in initialization 
classname.cpp: In constructor "foo::foo()": 
classname.cpp:29:25: error: expected type-specifier 
classname.cpp:29:25: error: expected ">" 
classname.cpp:29:25: error: expected "(" 
classname.cpp:29:30: error: expected unqualified-id before "*" token 
classname.cpp:31:2: error: expected "{" at end of input 

attentes:

Je souhaite initialiser le pointeur de fonction de classe de base pour l'initialiser pointe vers la classe dérivée fonction de membre. Je veux initialiser cela en créant un objet de classe dérivée. A partir de la classe de base, je veux appeler la fonction de classe dérivée en utilisant le pointeur de fonction acquis.

Merci d'avance pour tous.

Answer 1

Votre constructeur de bar est faux.

Le constructeur bar(void (*getNextValue)(void)) ne vous attendez pas à un pointeur de fonction membre d'une fonction de foo et donc l'initialisation bar::memberFunctionPointer est impossible avec le type de getNextValue.

Vous devez modifier le paramètre dans le constructeur à void (foo::*getNextValue)(void) pour cela à compiler.

Pourtant, la conception globale ne semble pas vraiment juste pour moi ... Je pense que la réponse de @wasthishelpful est plus utile ;-)

Answer 2

On dirait des méthodes virtuelles pour moi:

class bar 
{ 
    public: 
     bar() 
     { 
     } 
     void calltoderivedslass() 
     { 
      this->hello(); 
     } 
     virtual void hello() = 0; 
}; 

class foo : public bar 
{ 
    public: 
     foo() 
     { 
     } 
     void hello() override 
     { 
      printf("Hello \n\n"); 
     } 
}; 

---

Une autre façon peut-être d'utiliser le motif de modèle Chose curieuse Récurrent (CRTP) pour réaliser le polymorphisme statique:

template<typename T> 
class bar 
{ 
    public: 
     bar() 
     { 
     } 
     void calltoderivedslass() 
     { 
      static_cast<T*>(this)->hello(); 
     } 
}; 

class foo : public bar<foo> 
{ 
    public: 
     foo() 
     { 
     } 
     void hello() 
     { 
      printf("Hello \n\n"); 
     } 
}; 

---

Si vous voulez vraiment conserver des pointeurs sur les fonctions membres, vous pouvez considérer std::function lié à this:

class bar 
{ 
    public: 
     bar() 
     { 
     } 
     template<typename F> 
     bar(F&& getNextValue):memberFunctionPointer(std::forward<F>(getNextValue)) 
     { 
     } 
     void calltoderivedslass() 
     { 
      this->memberFunctionPointer(); 
     } 
     std::function<void()> memberFunctionPointer; 
}; 

class foo : public bar 
{ 
    public: 
     foo():bar(std::bind(&foo::hello, this)) 
     { 
     } 
     void hello() 
     { 
      printf("Hello \n\n"); 
     } 
}; 

Avec une utilisation prolongée Je devine:

void byebye() 
{ 
    cout << "bye" << endl; 
} 
int main() 
{ 
    bar testbar(byebye); 
    testbar.calltoderivedslass(); // not a derived class, but it works 
    return 0; 
}