Operadores de Puntero-a- Miembro: . * y - >*
expression .* expression
expression –>* expression
Comentarios
Los operadores de puntero a miembro. * y – >*, devuelven el valor de un miembro de clase concreto para el objeto especificado en el lado izquierdo de la expresión.El lado derecho debe especificar un miembro de clase.El ejemplo siguiente se muestra cómo utilizar 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;
}
Output
m_func1
m_func1
1
2
En el ejemplo anterior, se utiliza un puntero a un miembro, pmfn, para invocar la función m_func1miembro.Otro puntero a miembro, pmd, se utiliza para tener acceso al miembro de m_num .
el operador binario. * combina el primer operando, que debe ser un objeto de tipo de clase, con el segundo operando, que debe ser un tipo de puntero a miembro.
El operador binario – >* combina el primer operando, que debe ser un puntero a un objeto de tipo de clase, con el segundo operando, que debe ser un tipo de puntero a miembro.
en contener de la expresión. el operador *, el primer operando debe ser del tipo de clase, y es de accesible, el puntero al miembro especificado en el segundo operando o tipo accesible inequívocamente derivado y accesible a esa clase.
En una expresión que contiene – el operador de >*, el primer operando debe ser de tipo “puntero al tipo de clase” del tipo especificado en el segundo operando, o debe ser de un tipo inequívocamente derivado de esa clase.
Ejemplo
Considere las clases y el fragmento siguientes program:
// 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. * o – los operadores de puntero a miembro de >* son un objeto o una función del tipo especificado en la declaración de puntero a 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.El 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 se puede utilizar como operando al operador de llamada de función.