Opérateurs pointeur vers membre : .* et ->*

Syntaxe

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

Notes

Les opérateurs .* pointeur à membre et ->* retournent la valeur d’un membre de classe spécifique pour l’objet spécifié sur le côté gauche de l’expression. Le côté droit doit spécifier un membre de la classe. L'exemple ci-dessous illustre l'utilisation de ces opérateurs :

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

Sortie

m_func1
m_func1
1
2

Dans l'exemple précédent, un pointeur vers un membre, pmfn, est utilisé pour appeler la fonction membre m_func1. Un autre pointeur vers un membre, pmd, est utilisé pour accéder au membre m_num.

L’opérateur .* binaire combine son premier opérande, qui doit être un objet de type de classe, avec son deuxième opérande, qui doit être un type pointeur vers membre.

L’opérateur ->* binaire combine son premier opérande, qui doit être un pointeur vers un objet de type de classe, avec son deuxième opérande, qui doit être un type pointeur vers membre.

Dans une expression contenant l’opérateur .* , le premier opérande doit être du type de classe et être accessible, le pointeur vers le membre spécifié dans le deuxième opérande ou d’un type accessible sans ambiguïté dérivé et accessible à cette classe.

Dans une expression contenant l’opérateur ->* , le premier opérande doit être de type « pointeur vers le type de classe » du type spécifié dans le deuxième opérande, ou il doit être d’un type dérivé sans ambiguïté de cette classe.

Exemple

Considérez les classes et le fragment de programme suivants :

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

Le résultat des .* opérateurs ou ->* des opérateurs pointeur à membre est un objet ou une fonction du type spécifié dans la déclaration du pointeur vers le membre. Ainsi, dans l’exemple précédent, le résultat de l’expression ADerived.*pmfnFunc1() est un pointeur vers une fonction qui retourne void. Ce résultat est une l-value si le second opérande est une l-value.

Remarque

Si le résultat d’un des opérateurs de pointeur vers membre est une fonction, le résultat peut être utilisé uniquement comme opérande pour l’opérateur d’appel de fonction.

Voir aussi

Opérateurs intégrés C++, priorité et associativité