3. C++ Memberfunktionspointer ausserhalb einer Klasse aufrufen

C++ Memberfunktionspointer ausserhalb einer Klasse aufrufen

  • W

    ich habe hier eine Klasse:

    class A
    {
    public:

    A()
    {
    g=&A::f;
    }

    int f(){ printf( "f\n");}

    int (A::*g)( void);

    int h(){ (this->*A::g)();} // ok
    int i(){ ((*this).*g)();} // ok
    };

    Die Memberfunktionen h und i können gerufen werden und rufen ihrererseits g auf, welches ein Funktionspointer auf f ist. Ich möchte jetzt aber den Funktionspointer g ausserhalb der Klasse A aufrufen,
    so wie ich es bis jetzt nur in der Klasse A in den Memberfunktionen
    h und i kann. Weiss einer, wie das möglich ist?

    Danke im Voraus.

    weedy.

    0
  • C
     

    // Ein Objekt wird gebraucht:
A foo;
// Einfach anstelle this das Objekt nehmen:
(foo.*g)();
((&foo)->*g)();

    [ Dieser Beitrag wurde am 18.05.2003 um 21:23 Uhr von cd9000 editiert. ]

    0
  • W

    // g++-3.2 liefert:

    A foo;

    (foo.*g)(); // g' undeclared (first use this function) ((&foo)->*g)(); //g' undeclared (first use this function)

    (foo.g)(); // pointer to member function called, but not in class scope
    ((&foo)->A::g)(); // member A::g' is non-static but referenced as a static member (foo.\*A::g)(); // \A::g' cannot be used as a member pointer, since it is of type `int (A::*A::)()'

    Fragen über Fragen,

    weedy.

    0
  • M

    (foo.*(foo.g))();

    0
  • W

    Vielen Dank. Das haut mich jetzt echt vom Hocker. Gibt es irgendwo
    eine logische Erklärung dazu? Das könnte immerhin dazu führen, dass
    man noch mehr davon versteht, und wer will das nicht :-).

    weedy.

    0
  • M

    Du willst eine Memberfunktion von foo über einen Funktionszeiger aufrufen. Nennen wir den Zeiger erst mal allgemein p:

    (foo.*p)();

    Der Zeiger ist aber ein nichtstatischer Member von foo, nämlich foo.g. Also Klammern drum, und das für p eingesetzt:

    (foo.*(foo.g))();

    Das erste foo brauchst du also, weil du einen Memberfunktionszeiger aufrufen willst. Das zweite foo brauchst du, weil der Zeiger selbst ein Member von foo ist. Wäre g (der Zeiger, nicht die Funktion) statisch, hätte das funktioniert:

    (foo.*(A::g))();

    [ Dieser Beitrag wurde am 19.05.2003 um 09:28 Uhr von MFK editiert. ]

    0
  • W

    Das ist absolut einleuchtend, Danke für die Mühe.

    Aber eine Frage habe ich noch dazu.
    Ich rufe innerhalb der Klasse den Funktionspointer ihne Beanstandungen
    so auf: (this->*A::g)();
    Nun will ich ausschliesslich deine Variante verwenden, der besseren
    Lesbarkeit wegen. Dazu funktioniert auch der folgende Test:

    A &foo= this; // 1
    (foo.    (foo.g))(); // 2

    soweit sogut. Jetzt will ich 1 in 2 einsetzen und erhalte je nach Geschmacksrichtung:

    (*this).*((*this).g))();

    oder

    (this->*this->g)();

    und beides will nicht funktionieren.

    was habe ich nun wieder falsch gemacht?

    weedy.

    0
  • M

    Original erstellt von weedy:
    *(*this).*((this).g))();

    Da fehlt vorn eine öffnende runde Klammer.

    *(this->this->g)();

    Das sollte eigentlich funktionieren.

    Aber einfacher wäre:

    (this->*g)();

    0
  • W

    Jetzt gehts:

    (*this.*(*this).g)();
    (this->*this->g)();

    Die Ausdrücke mussten vor den
    Parameterklammern geklammert werden.
    Und die eine öffnende Klammer fehlte natürlich.

    im übrigen geht auch

    (foo.*foo.g)();

    Dass der folgende Ausdruck nicht geht, ist mir aber nach wie vor unverständlich (innerhalb der Klasse):

    (*this.*A::g)();

    denn die gehen ja:

    (this->*A::g)();}

    ((*this).*g)();}
    (this->*g)();}

    weedy.

    0
Anmelden zum Antworten