Memberzeiger-Operatoren: .* and ->*

Artikel
02/26/2013

expression .* expression
expression –>* expression

Hinweise

Die Member Zeiger-zu Operatoren. * und >*, geben Sie den Wert eines bestimmten Klassenmembers für das Objekt zurück, das auf der linken Seite des Ausdrucks angegeben wird.Die rechte Seite muss einen Member der Klasse angeben.Im folgenden Beispiel wird veranschaulicht, wie diese Operatoren verwendet:

// 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;
}

Output

m_func1
m_func1
1
2

Im vorherigen Beispiel wird ein Zeiger auf einen Member, pmfn, die Memberfunktion m_func1aufzurufen.Ein weiterer Zeiger auf einen Member, pmd, wird das m_num-Member zuzugreifen.

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

Der binäre Operator – >* den ersten Operanden, der kombiniert einen Zeiger auf ein Objekt des Klassentyps mit dem zweiten Operanden sein muss, der ein Zeiger-zu Member Typ sein muss.

In einem Ausdruck enthalten. Operator *, der erste Operand muss den Klassentyp, und ist mit der in den zugegriffen werden, Memberzeiger übereinstimmen, der im zweiten Operanden oder einem barrierefreien Typ angegeben wird, der eindeutig von dieser Klasse abgeleitet und möglich ist.

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

Beispiel

Berücksichtigen Sie die folgenden Klassen und das Programm fragment:

// 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. * oder eine >*-Zeiger-zu Member Operatoren ist ein Objekt oder eine Funktion des Typs, der in der Deklaration des Zeigers auf den Member angegeben wird.Wie im vorherigen Beispiel, ist das Ergebnis des Ausdrucks ADerived.*pmfnFunc1() ein Zeiger auf eine Funktion, die " void " zurückgibt.Dieses Ergebnis ist ein l-Wert, wenn der zweite Operand ein l-Wert handelt.

Hinweis
Wenn das Ergebnis ein Member der Zeiger-zu Operatoren eine Funktion ist, kann das Ergebnis nur als Operand für den Aufrufoperator verwendet werden.

Siehe auch

Referenz

C++-Operatoren

Operatorrangfolge und Assoziativität

Freigeben über