Aufruf von C ++ - Klassenmethoden über einen Funktionszeiger

Wie erhalte ich einen Funktionszeiger für eine Klassenelementfunktion und rufe diese Elementfunktion später mit einem bestimmten Objekt auf? Ich würde gerne schreiben:

class Dog : Animal
{
    Dog ();
    void bark ();
}

…
Dog* pDog = new Dog ();
BarkFunction pBark = &Dog::bark;
(*pBark) (pDog);
…

Wenn möglich, möchte ich den Konstruktor auch über einen Zeiger aufrufen:

NewAnimalFunction pNew = &Dog::Dog;
Animal* pAnimal = (*pNew)();    

Ist dies möglich und wenn ja, wie wird dies bevorzugt?

Lesen Sie dies für Details:

// 1 define a function pointer and initialize to NULL

int (TMyClass::*pt2ConstMember)(float, char, char) const = NULL;

// C++

class TMyClass
{
public:
   int DoIt(float a, char b, char c){ cout << "TMyClass::DoIt"<< endl; return a+b+c;};
   int DoMore(float a, char b, char c) const
         { cout << "TMyClass::DoMore" << endl; return a-b+c; };

   /* more of TMyClass */
};
pt2ConstMember = &TMyClass::DoIt; // note: <pt2Member> may also legally point to &DoMore

// Calling Function using Function Pointer

(*this.*pt2ConstMember)(12, 'a', 'b');

Wie erhalte ich einen Funktionszeiger für eine Klassenelementfunktion und rufe diese Elementfunktion später mit einem bestimmten Objekt auf?

Es ist am einfachsten, mit einem zu beginnen typedef. Für eine Mitgliedsfunktion fügen Sie den Klassennamen in die Typdeklaration ein:

typedef void(Dog::*BarkFunction)(void);

Um die Methode aufzurufen, verwenden Sie den ->*Operator:

(pDog->*pBark)();

Wenn möglich, möchte ich den Konstruktor auch über einen Zeiger aufrufen. Ist dies möglich und wenn ja, wie wird dies bevorzugt?

Ich glaube nicht, dass Sie mit solchen Konstruktoren arbeiten können - ctors und dtors sind etwas Besonderes. Der normale Weg, um so etwas zu erreichen, wäre die Verwendung einer Factory-Methode, die im Grunde nur eine statische Funktion ist, die den Konstruktor für Sie aufruft. Ein Beispiel finden Sie im folgenden Code.

Ich habe Ihren Code so geändert, dass er im Grunde das tut, was Sie beschreiben. Es gibt einige Einschränkungen unten.

#include <iostream>

class Animal
{
public:

    typedef Animal*(*NewAnimalFunction)(void);

    virtual void makeNoise()
    {
        std::cout << "M00f!" << std::endl;
    }
};

class Dog : public Animal
{
public:

    typedef void(Dog::*BarkFunction)(void);

    typedef Dog*(*NewDogFunction)(void);

    Dog () {}

    static Dog* newDog()
    {
        return new Dog;
    }

    virtual void makeNoise ()
    {
        std::cout << "Woof!" << std::endl;
    }
};

int main(int argc, char* argv[])
{
    // Call member function via method pointer
    Dog* pDog = new Dog ();
    Dog::BarkFunction pBark = &Dog::makeNoise;

    (pDog->*pBark)();

    // Construct instance via factory method
    Dog::NewDogFunction pNew = &Dog::newDog;

    Animal* pAnimal = (*pNew)();

    pAnimal->makeNoise();

    return 0;
}

Obwohl Sie dank der Magie des Polymorphismus normalerweise ein Dog*anstelle eines Animal*Dankes verwenden können, folgt der Typ eines Funktionszeigers nicht den Suchregeln der Klassenhierarchie. Ein Animal-Methodenzeiger ist also nicht mit einem Dog-Methodenzeiger kompatibel. Mit anderen Worten, Sie können Dog* (*)()einer Variablen vom Typ keine zuweisen Animal* (*)().

Die statische newDogMethode ist ein einfaches Beispiel für eine Factory, die einfach neue Instanzen erstellt und zurückgibt. Als statische Funktion hat sie eine reguläre Funktion typedef(ohne Klassenqualifikation).

Nachdem ich das oben Gesagte beantwortet habe, frage ich mich, ob es keinen besseren Weg gibt, um das zu erreichen, was Sie brauchen. Es gibt einige spezifische Szenarien, in denen Sie so etwas tun würden, aber möglicherweise finden Sie andere Muster, die für Ihr Problem besser geeignet sind. Wenn Sie allgemeiner beschreiben, was Sie erreichen möchten, kann sich der Hive-Mind als noch nützlicher erweisen!

In Bezug auf das oben Gesagte werden Sie die Boost-Bindungsbibliothek und andere verwandte Module zweifellos sehr nützlich finden.

Ich glaube nicht, dass hier jemand erklärt hat, dass ein Problem darin besteht, dass Sie " Mitgliedszeiger " anstelle von normalen Funktionszeigern benötigen .

Elementzeiger auf Funktionen sind nicht einfach Funktionszeiger. In Bezug auf die Implementierung kann der Compiler keine einfache Funktionsadresse verwenden, da Sie die aufzurufende Adresse im Allgemeinen erst kennen, wenn Sie wissen, für welches Objekt eine Dereferenzierung erforderlich ist (denken Sie an virtuelle Funktionen). thisNatürlich müssen Sie auch das Objekt kennen, um den impliziten Parameter bereitzustellen .

Nachdem ich gesagt habe, dass Sie sie brauchen, werde ich jetzt sagen, dass Sie sie wirklich vermeiden müssen. Im Ernst, Mitgliederzeiger sind ein Schmerz. Es ist viel vernünftiger, objektorientierte Entwurfsmuster zu betrachten, die das gleiche Ziel erreichen, oder ein boost::functionoder was auch immer wie oben erwähnt zu verwenden - vorausgesetzt, Sie können diese Wahl treffen, das heißt.

Wenn Sie diesen Funktionszeiger für vorhandenen Code bereitstellen, sodass Sie wirklich einen einfachen Funktionszeiger benötigen , sollten Sie eine Funktion als statisches Mitglied der Klasse schreiben. Eine statische Elementfunktion versteht das nicht this, daher müssen Sie das Objekt als expliziten Parameter übergeben. Es gab einmal eine nicht allzu ungewöhnliche Redewendung in dieser Richtung für die Arbeit mit altem C-Code, der Funktionszeiger benötigt

class myclass
{
  public:
    virtual void myrealmethod () = 0;

    static void myfunction (myclass *p);
}

void myclass::myfunction (myclass *p)
{
  p->myrealmethod ();
}

Da myfunctiones sich eigentlich nur um eine normale Funktion handelt (abgesehen von Umfangsproblemen), kann ein Funktionszeiger auf normale C-Weise gefunden werden.

BEARBEITEN - Diese Art von Methode wird als "Klassenmethode" oder "statische Elementfunktion" bezeichnet. Der Hauptunterschied zu einer Nichtmitgliedsfunktion besteht darin, dass Sie den Bereich mithilfe des ::Bereichsauflösungsoperators angeben müssen, wenn Sie von außerhalb der Klasse darauf verweisen . Um beispielsweise den Funktionszeiger abzurufen, verwenden Sie &myclass::myfunctionund rufen Sie ihn auf myclass::myfunction (arg);.

Diese Art von Dingen ist ziemlich häufig, wenn die alten Win32-APIs verwendet werden, die ursprünglich eher für C als für C ++ entwickelt wurden. In diesem Fall ist der Parameter natürlich normalerweise LPARAM oder ähnlich und kein Zeiger, und es ist ein gewisses Casting erforderlich.

typedef void (Dog::*memfun)();
memfun doSomething = &Dog::bark;
....
(pDog->*doSomething)(); // if pDog is a pointer
// (pDog.*doSomething)(); // if pDog is a reference

Minimal lauffähiges Beispiel

main.cpp

#include <cassert>

class C {
    public:
        int i;
        C(int i) : i(i) {}
        int m(int j) { return this->i + j; }
};

int main() {
    // Get a method pointer.
    int (C::*p)(int) = &C::m;

    // Create a test object.
    C c(1);
    C *cp = &c;

    // Operator .*
    assert((c.*p)(2) == 3);

    // Operator ->*
    assert((cp->*p)(2) == 3);
}

Kompilieren und ausführen:

g++ -ggdb3 -O0 -std=c++11 -Wall -Wextra -pedantic -o main.out main.cpp
./main.out

Getestet in Ubuntu 18.04.

Sie können die Reihenfolge der Klammern nicht ändern oder weglassen. Folgendes funktioniert nicht:

c.*p(2)
c.*(p)(2)

GCC 9.2 würde fehlschlagen mit:

main.cpp: In function ‘int main()’:
main.cpp:19:18: error: must use ‘.*’ or ‘->*’ to call pointer-to-member function in ‘p (...)’, e.g. ‘(... ->* p) (...)’
   19 |     assert(c.*p(2) == 3);
      |

C ++ 11 Standard

.*und ->*sind einzelne Operatoren, die zu diesem Zweck in C ++ eingeführt wurden und in C nicht vorhanden sind.

C ++ 11 N3337 Standardentwurf :

• 2.13 "Operatoren und Interpunktionszeichen" enthält eine Liste aller Operatoren, die .*und enthält ->*.
• 5.5 "Zeiger-zu-Mitglied-Operatoren" erklärt, was sie tun

Ich bin hierher gekommen, um zu lernen, wie man aus einer Methode einen Funktionszeiger (keinen Methodenzeiger) erstellt, aber keine der Antworten hier bietet eine Lösung. Folgendes habe ich mir ausgedacht:

template <class T> struct MethodHelper;
template <class C, class Ret, class... Args> struct MethodHelper<Ret (C::*)(Args...)> {
    using T = Ret (C::*)(Args...);
    template <T m> static Ret call(C* object, Args... args) {
        return (object->*m)(args...);
    }
};

#define METHOD_FP(m) MethodHelper<decltype(m)>::call<m>

Für Ihr Beispiel würden Sie jetzt Folgendes tun:

Dog dog;
using BarkFunction = void (*)(Dog*);
BarkFunction bark = METHOD_FP(&Dog::bark);
(*bark)(&dog); // or simply bark(&dog)

Bearbeiten:
Mit C ++ 17 gibt es eine noch bessere Lösung:

template <auto m> struct MethodHelper;
template <class C, class Ret, class... Args, Ret (C::*m)(Args...)> struct MethodHelper<m> {
    static Ret call(C* object, Args... args) {
        return (object->*m)(args...);
    }
};

die direkt ohne das Makro verwendet werden kann:

Dog dog;
using BarkFunction = void (*)(Dog*);
BarkFunction bark = MethodHelper<&Dog::bark>::call;
(*bark)(&dog); // or simply bark(&dog)

Für Methoden mit Modifikatoren wie constbenötigen Sie möglicherweise weitere Spezialisierungen wie:

template <class C, class Ret, class... Args, Ret (C::*m)(Args...) const> struct MethodHelper<m> {
    static Ret call(const C* object, Args... args) {
        return (object->*m)(args...);
    }
};

Der Grund, warum Sie keine Funktionszeiger zum Aufrufen von Elementfunktionen verwenden können, ist, dass gewöhnliche Funktionszeiger normalerweise nur die Speicheradresse der Funktion sind.

Um eine Mitgliedsfunktion aufzurufen, müssen Sie zwei Dinge wissen:

• Welche Mitgliedsfunktion soll aufgerufen werden?
• Welche Instanz soll verwendet werden (deren Mitgliedsfunktion)

Gewöhnliche Funktionszeiger können nicht beide speichern. C ++ - Elementfunktionszeiger werden zum Speichern von a) verwendet. Aus diesem Grund müssen Sie die Instanz beim Aufrufen eines Elementfunktionszeigers explizit angeben.

Ein Funktionszeiger auf ein Klassenmitglied ist ein Problem, das für die Verwendung der boost :: -Funktion wirklich geeignet ist. Kleines Beispiel:

#include <boost/function.hpp>
#include <iostream>

class Dog 
{
public:
   Dog (int i) : tmp(i) {}
   void bark ()
   {
      std::cout << "woof: " << tmp << std::endl;
   }
private:
   int tmp;
};



int main()
{
   Dog* pDog1 = new Dog (1);
   Dog* pDog2 = new Dog (2);

   //BarkFunction pBark = &Dog::bark;
   boost::function<void (Dog*)> f1 = &Dog::bark;

   f1(pDog1);
   f1(pDog2);
}

Um ein neues Objekt zu erstellen, können Sie entweder die oben erwähnte Platzierung new verwenden oder Ihre Klasse eine clone () -Methode implementieren lassen, die eine Kopie des Objekts erstellt. Sie können diese Klonmethode dann wie oben erläutert mit einem Elementfunktionszeiger aufrufen, um neue Instanzen des Objekts zu erstellen. Der Vorteil des Klons besteht darin, dass Sie manchmal mit einem Zeiger auf eine Basisklasse arbeiten, bei der Sie den Typ des Objekts nicht kennen. In diesem Fall kann eine clone () -Methode einfacher zu verwenden sein. Mit clone () können Sie außerdem den Status des Objekts kopieren, wenn Sie dies wünschen.

Ich habe das mit std :: function und std :: bind gemacht.

Ich habe diese EventManager-Klasse geschrieben, die einen Vektor von Handlern in einer ungeordneten_Map speichert, die Ereignistypen (die nur const unsigned int sind, ich habe eine große Anzahl von Namespace-Bereichen) einem Vektor von Handlern für diesen Ereignistyp zuordnet.

In meiner EventManagerTests-Klasse habe ich einen Ereignishandler wie folgt eingerichtet:

auto delegate = std::bind(&EventManagerTests::OnKeyDown, this, std::placeholders::_1);
event_manager.AddEventListener(kEventKeyDown, delegate);

Hier ist die AddEventListener-Funktion:

std::vector<EventHandler>::iterator EventManager::AddEventListener(EventType _event_type, EventHandler _handler)
{
    if (listeners_.count(_event_type) == 0) 
    {
        listeners_.emplace(_event_type, new std::vector<EventHandler>());
    }
    std::vector<EventHandler>::iterator it = listeners_[_event_type]->end();
    listeners_[_event_type]->push_back(_handler);       
    return it;
}

Hier ist die EventHandler-Typdefinition:

typedef std::function<void(Event *)> EventHandler;

Dann mache ich in EventManagerTests :: RaiseEvent Folgendes:

Engine::KeyDownEvent event(39);
event_manager.RaiseEvent(1, (Engine::Event*) & event);

Hier ist der Code für EventManager :: RaiseEvent:

void EventManager::RaiseEvent(EventType _event_type, Event * _event)
{
    if (listeners_.count(_event_type) > 0)
    {
        std::vector<EventHandler> * vec = listeners_[_event_type];
        std::for_each(
            begin(*vec), 
            end(*vec), 
            [_event](EventHandler handler) mutable 
            {
                (handler)(_event);
            }
        );
    }
}

Das funktioniert. Ich erhalte den Aufruf in EventManagerTests :: OnKeyDown. Ich muss die Vektoren löschen, die Zeit zum Aufräumen haben, aber wenn ich das mache, gibt es keine Lecks. Das Auslösen eines Ereignisses dauert auf meinem Computer ungefähr 5 Mikrosekunden, was ungefähr 2008 entspricht. Nicht gerade superschnell, aber. Fair genug, solange ich das weiß und es nicht in extrem heißem Code verwende.

Ich möchte es beschleunigen, indem ich meine eigene std :: function und std :: bind rolle und vielleicht ein Array von Arrays anstelle einer ungeordneten Karte von Vektoren verwende, aber ich habe nicht ganz herausgefunden, wie eine Mitgliedsfunktion gespeichert werden soll Zeiger und rufen Sie es aus Code auf, der nichts über die aufgerufene Klasse weiß. Wimpern Antwort sieht sehr interessant aus ..