Zeiger-zu-Member-Operatoren: .* und ->*

Syntax

pm-expression:
  cast-expression
  pm-expression .* cast-expression
  pm-expression ->* cast-expression

Hinweise

Die Zeiger-zu-Member-Operatoren .* und ->* geben den Wert eines bestimmten Klassenelements für das auf der linken Seite des Ausdrucks angegebene Objekt zurück. Die rechte Seite muss einen Klassenmember angeben. Im folgenden Beispiel wird die Verwendung dieser Operatoren dargestellt:

// expre_Expressions_with_Pointer_Member_Operators.cpp
// compile with: /EHsc
#include <iostream>

using namespace std;

class Testpm {
public:
   void m_func1() { cout << "m_func1\n"; }
   int m_num;
};

// Define derived types pmfn and pmd.
// These types are pointers to members m_func1() and
// m_num, respectively.
void (Testpm::*pmfn)() = &Testpm::m_func1;
int Testpm::*pmd = &Testpm::m_num;

int main() {
   Testpm ATestpm;
   Testpm *pTestpm = new Testpm;

// Access the member function
   (ATestpm.*pmfn)();
   (pTestpm->*pmfn)();   // Parentheses required since * binds
                        // less tightly than the function call.

// Access the member data
   ATestpm.*pmd = 1;
   pTestpm->*pmd = 2;

   cout  << ATestpm.*pmd << endl
         << pTestpm->*pmd << endl;
   delete pTestpm;
}

Ausgabe

m_func1
m_func1
1
2

Im vorherigen Beispiel wird ein Zeiger auf einen Member, pmfn verwendet, um die Memberfunktion m_func1 aufzurufen. Mit einem weiteren Zeiger auf einen Member, pmd, erfolgt der Zugriff auf den m_num-Member.

Der binäre Operator .* kombiniert den ersten Operanden, der ein Objekt vom Klassentyp sein muss, mit dem zweiten Operanden, der ein Zeiger-zu-Member-Typ sein muss.

Der binäre Operator ->* kombiniert seinen ersten Operanden, der ein Zeiger auf ein Objekt vom Klassentyp sein muss, mit dem zweiten Operanden, der ein Zeiger-zu-Member-Typ sein muss.

In einem Ausdruck, der den .* Operator enthält, muss der erste Operand der Klassentyp sein und darauf zugreifen können, der Zeiger auf Member, der im zweiten Operanden oder einem barrierefreien Typ eindeutig von dieser Klasse abgeleitet und für diese Klasse zugänglich ist.

In einem Ausdruck, der den ->* Operator enthält, muss der erste Operand vom Typ "Zeiger auf den Klassentyp" des typs sein, der im zweiten Operanden angegeben ist, oder es muss von einem Typ eindeutig von dieser Klasse abgeleitet sein.

Beispiel

Berücksichtigen Sie die folgenden Klassen und das Programmfragment:

// expre_Expressions_with_Pointer_Member_Operators2.cpp
// C2440 expected
class BaseClass {
public:
   BaseClass(); // Base class constructor.
   void Func1();
};

// Declare a pointer to member function Func1.
void (BaseClass::*pmfnFunc1)() = &BaseClass::Func1;

class Derived : public BaseClass {
public:
   Derived();  // Derived class constructor.
   void Func2();
};

// Declare a pointer to member function Func2.
void (Derived::*pmfnFunc2)() = &Derived::Func2;

int main() {
   BaseClass ABase;
   Derived ADerived;

   (ABase.*pmfnFunc1)();   // OK: defined for BaseClass.
   (ABase.*pmfnFunc2)();   // Error: cannot use base class to
                           // access pointers to members of
                           // derived classes.

   (ADerived.*pmfnFunc1)();   // OK: Derived is unambiguously
                              // derived from BaseClass.
   (ADerived.*pmfnFunc2)();   // OK: defined for Derived.
}

Das Ergebnis der .* Operatoren oder ->* Zeiger-zu-Member-Operatoren ist ein Objekt oder eine Funktion des Typs, der in der Deklaration des Zeigers auf Member angegeben ist. Im vorherigen Beispiel ist das Ergebnis des Ausdrucks ADerived.*pmfnFunc1() also ein Zeiger auf eine Funktion, die zurückgegeben wird void. Dieses Ergebnis ist ein L-Wert, wenn der zweite Operand ein L-Wert ist.

Hinweis

Wenn das Ergebnis eines der Zeiger-auf-Member-Operatoren eine Funktion ist, kann das Ergebnis nur als Operand für den Funktionsaufrufoperator verwendet werden.

Siehe auch

Integrierte C++-Operatoren, Rangfolge und Zuordnung