Vermeiden Sie den Klassenbereich, um eine Elementfunktion als Funktionszeiger zu übergeben

Question

Ich werde meine Frage mit dem folgenden Beispielcode beschreiben.

Ich habe Klasse B wie folgt definiert:

class B 
{ 
    public: 
     inline B(){} 
     inline B(int(*f)(int)) :myfunc{ f }{} 
     void setfunction(int (*f)(int x)) { myfunc = f; } 
     void print(int number) { std::cout << myfunc(number) << std::endl; } 
    private: 
     int(*myfunc)(int); 
}; 

ich dann Klasse A wie folgt definieren:

class A 
{ 
    public: 
    A(int myint) :a{ myint }{ b.setfunction(g); } 
    int g(int) { return a; } 
    void print() { b.print(a); } 

    private: 
    B b; 
    int a; 
    }; 

Für mich ist das Problem scheint zu sein, dass die Elementfunktion g die Signatur int A::g(int) anstatt int g(int).

Gibt es eine Standardmethode, um die oben genannten Arbeiten auszuführen? Ich denke, das ist eine ziemlich allgemeine Konfiguration, da wir eine Klasse (Klasse B) haben, die eine Art von Memberfunktionen enthält, die einige Operationen ausführen, und wir haben eine Klasse (Klasse A), die eine bestimmte Memberfunktion der Klasse verwenden muss B - so ist mein Entwurf falsch, und wenn ja, was ist der beste Weg, diese Idee auszudrücken?

Answer 1

können Sie verwenden std :: function:

class B 
{ 
public: 
    inline B() {} 
    inline B(std::function<int(int)> f) : myfunc{ f } {} 
    void setfunction(std::function<int(int)> f) { myfunc = f; } 
    void print(int number) { std::cout << myfunc(number) << std::endl; } 
private: 
    std::function<int(int)> myfunc; 
}; 

class A 
{ 
public: 
    A(int myint) :a{ myint } { 
    b.setfunction([this](int a) { 
     return g(a); 
    } 
    ); 
    } 
    int g(int) { return a; } 
    void print() { b.print(a); } 

private: 
    B b; 
    int a; 
}; 

Answer 2

Verwenden std::function und std::bind

class B 
{ 
    public: 
     inline B(int(*f)(int)) :myfunc{ f }{} 
     void setfunction(std::function<int(int)> f) { myfunc = f; } 
     void print(int number) { std::cout << myfunc(number) << std::endl; } 
    private: 
     std::function<int(int)> myfunc; 
}; 

// ... 
A a; 
B b(std::bind(&A::g, &a)); 

Beachten Sie auch, dass Sie die Funktion Zeiger auf einen Standardwert initialisieren sollen (höchstwahrscheinlich null) und prüfen, ob es bei der Anwendung, sonst ist es Wert nicht definiert ist.

Answer 3

Sie könnten die Klasse B verallgemeinern. Statt einen Zeiger zu halten (int(*)(int)), was Sie wirklich wollen, ist jede Sache, die ich mit einer int aufrufen kann und wieder eine int bekommen. C++ 11 eingeführt, um eine Art löschte Funktion Einwand genau diesem Grund: std::function<int(int)>:

class B 
{ 
    using F = std::function<int(int)> 
public: 
    B(){} 
    B(F f) : myfunc(std::move(f)) { } 
    void setfunction(F f) { myfunc = std::move(f); } 
    void print(int number) { std::cout << myfunc(number) << std::endl; } 
private: 
    F myfunc; 
}; 

Und dann können Sie nur eine allgemeine aufrufbar in B von A bieten:

A(int myint) 
: b([this](int a){ return g(a); }) 
, a{ myint } 
{ } 

Answer 4

Sie könnten std::bind verwenden, um die Memberfunktion A::g zu binden.

class B 
{ 
    public: 
     inline B(){} 
     inline B(std::function<int(int)> f) :myfunc{ f }{} 
     void setfunction(std::function<int(int)> f) { myfunc = f; } 
     void print(int number) { std::cout << myfunc(number) << std::endl; } 
    private: 
     std::function<int(int)> myfunc; 
}; 
class A 
{ 
    public: 
     A(int myint) :a{ myint } { 
      b.setfunction(std::bind(&A::g, this, std::placeholders::_1)); 
     } 
     int g(int) { return a; } 
     void print() { b.print(a); } 

    private: 
     B b; 
     int a; 
}; 

Hinweis benötigen Sie den Typen des Funktor von Funktionszeigern auf std::function zu ändern, die mit std::bind anwendbar ist.

LIVE