Operatori puntatore a membro: .* e ->*

Sintassi

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

Osservazioni:

Gli operatori .* puntatore a membro e ->* restituiscono il valore di un membro di classe specifico per l'oggetto specificato sul lato sinistro dell'espressione. Nella parte destra deve essere specificato un membro della classe. Nell'esempio seguente viene illustrato come utilizzare tali operatori.

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

Nell'esempio precedente un puntatore a un membro, pmfn, viene utilizzato per richiamare la funzione membro m_func1. Un altro puntatore a un membro, pmd, viene utilizzato per accedere al membro m_num.

L'operatore .* binario combina il primo operando, che deve essere un oggetto di tipo classe, con il secondo operando, che deve essere un tipo puntatore a membro.

L'operatore ->* binario combina il primo operando, che deve essere un puntatore a un oggetto di tipo classe, con il secondo operando, che deve essere un tipo puntatore a membro.

In un'espressione contenente l'operatore .* , il primo operando deve essere del tipo di classe e essere accessibile a , il puntatore al membro specificato nel secondo operando o di un tipo accessibile in modo non ambiguo derivato da e accessibile a tale classe.

In un'espressione contenente l'operatore ->* , il primo operando deve essere del tipo "puntatore al tipo di classe" del tipo specificato nel secondo operando oppure deve essere di un tipo derivato in modo non ambiguo da tale classe.

Esempio

Considerare le classi e il frammento di programma seguenti:

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

Il risultato degli .* operatori da puntatore a membro o ->* è un oggetto o una funzione del tipo specificato nella dichiarazione del puntatore al membro. Nell'esempio precedente, quindi, il risultato dell'espressione ADerived.*pmfnFunc1() è un puntatore a una funzione che restituisce void. Questo risultato è un valore l-value se il secondo operando è un valore di questo tipo.

Nota

Se il risultato di uno degli operatori puntatore a membro è una funzione, il risultato può essere utilizzato solo come operando dell'operatore di chiamata di funzione.

Vedi anche

Operatori, precedenza e associatività predefiniti C++