Operadores de puntero a miembro: .* y ->*

Sintaxis

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

Observaciones

Los operadores .* de puntero a miembro y ->* devuelven el valor de un miembro de clase específico para el objeto especificado en el lado izquierdo de la expresión. El lado derecho debe especificar un miembro de la clase . En el ejemplo siguiente se muestra cómo usar estos operadores:

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

Salida

m_func1
m_func1
1
2

En el ejemplo anterior, se usa un puntero a un miembro , pmfnpara invocar la función m_func1miembro . Otro puntero a un miembro, pmd, se usa para acceder al m_num miembro.

El operador .* binario combina su primer operando, que debe ser un objeto de tipo de clase, con su segundo operando, que debe ser un tipo de puntero a miembro.

El operador ->* binario combina su primer operando, que debe ser un puntero a un objeto de tipo de clase, con su segundo operando, que debe ser un tipo de puntero a miembro.

En una expresión que contiene el .* operador , el primer operando debe ser del tipo de clase de , y ser accesible para , el puntero al miembro especificado en el segundo operando o de un tipo accesible derivado de y accesible a esa clase.

En una expresión que contiene el ->* operador , el primer operando debe ser del tipo "puntero al tipo de clase" del tipo especificado en el segundo operando, o debe ser de un tipo derivado inequívocamente de esa clase.

Ejemplo

Tenga en cuenta las siguientes clases y fragmentos de programa:

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

El resultado de los .* operadores de puntero a miembro o ->* es un objeto o función del tipo especificado en la declaración del puntero al miembro. Por lo tanto, en el ejemplo anterior, el resultado de la expresión ADerived.*pmfnFunc1() es un puntero a una función que devuelve void. Este resultado es un valor l si el segundo operando es un valor l.

Nota:

Si el resultado de uno de los operadores de puntero a miembro es una función, el resultado solo se puede usar como operando para el operador de llamada de función.

Consulte también

Operadores integrados de C++, precedencia y asociatividad