Warum erfordert die Verwendung eines Mitgliedsfunktionszeigerwerts die Klassennamenqualifizierung auch innerhalb der Klasse?

Question

Wenn ich einen Mitgliedsfunktionszeiger an eine Klasse innerhalb einer der Mitgliedsfunktionen dieser Klasse zurückgebe, muss ich noch die Klasse angeben. Ich kann die Adresse nicht einfach nehmen. Zum Beispiel this code works fine:

class Foo { 
public: 
    void func(int param) { cout << param << endl; } 
    void (Foo::*getPointer())(int) { return &Foo::func; } 
}; 

Aber wenn in getPointer Ich versuche einfach tun: return &func ich diesen Fehler:

prog.cpp: In member function ' void (Foo::* Foo::getPointer())(int) ':
prog.cpp:8:43: error: ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to member function. Say ' &Foo::func ' [-fpermissive]
void (Foo::*getPointer())(int) { return &func; }

Warum ich die Klasse angeben muß, wenn das ist der Kontext, den ich in bin?

Answer 1

Pointers und Zeiger auf Mitglieder sind unterschiedliche Typen, können wir das aus dem Abschnitt des Entwurfs C++ Standard siehe Abschnitt 3.9.2 [basic.compound], die eine Verbindung Typ für Zeiger sowie Zeiger auf nicht-statische Klassenelement und Hinweise:

Static class members are objects or functions, and pointers to them are ordinary pointers to objects or functions

Dieses Problem dabei ist ich denke, auch in this quote in an answer from Johannes vom Annotated C++ Reference Manual(ARM) beschrieben:

Note that the address-of operator must be explicitly used to get a pointer to member; there is no implicit conversion ... Had there been, we would have an ambiguity in the context of a member function ... For example,

void B::f() { 
    int B::* p = &B::i; // ok 
    p = B::i;   // error: B::i is an int 
    p = &i;   // error: '&i'means '&this->i' 
         // which is an 'int*' 

    int *q = &i;  // ok 
    q = B::i;   // error: 'B::i is an int 
    q = &B::i;  // error: '&B::i' is an 'int B::*' 
} 

insbesondere diese l ines:

int B::* p = &B::i; // OK 

und:

p = &i; // error: '&i'means '&this->i' which is an 'int*' 

die Differenz zwischen den qualifizierten und den nicht qualifizierten Namen zu demonstrieren.

Answer 2

(... es gab eine falsche Antwort ...)

Es in folgendem Zusammenhang mehr seltsam aussieht:

class Foo { 
public: 
    virtual void func(int param) { cout << param << endl; } 
    void call(int x) { Foo::func(x); } 
    void (Foo::*getPointer())(int) { return &Foo::func; } 
}; 

class Bar : public Foo { 
public: 
    void func(int param) override { cout << "Hello world!" << endl; } 
}; 


int main() { 

    Foo *a = new Bar(); 
    auto p = a->getPointer(); 
    (a->*p)(4); 
    a->call(4); 

    return 0; 
} 

Der Ausgang ist

Hello world
4

Aufruf Foo::func ist Ein Anruf von func in Foo Klasse beim Anruf &Foo::func ist ein virtueller Anruf.