Operadores de ponteiro para membro:. * e - > *

Artigo
02/25/2013

expression .* expression
expression –>* expression

Comentários

Os operadores de ponteiro para membro. * e – > *, retornar o valor de um membro de classe específica para o objeto especificado no lado esquerdo da expressão.O lado direito deve especificar um membro da classe.O exemplo a seguir mostra como usar esses 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;
}

Saída

m_func1
m_func1
1
2

No exemplo anterior, um ponteiro para um membro, pmfn, é usado para chamar a função de membro m_func1.Outro ponteiro para um membro, pmd, é usado para acessar o m_num membro.

O operador binário. * combina o primeiro operando, que deve ser um objeto do tipo de classe, com seu segundo operando, deve ser um tipo de ponteiro para membro.

O operador binário – > * combina o primeiro operando, que deve ser um ponteiro para um objeto do tipo de classe, com seu segundo operando, deve ser um tipo de ponteiro para membro.

Em uma expressão contendo a. * operador, o primeiro operando deve ser do tipo de classe e ser acessível para o ponteiro para o membro especificado no segundo operando ou de um tipo acessível de forma não ambígua derivado e acessível a essa classe.

Em uma expressão contendo a – > * o primeiro operando do operador, deve ser do tipo "ponteiro para o tipo de classe" do tipo especificado no segundo operando, ou ela deve ser de um tipo de forma não ambígua derivada dessa classe.

Exemplo

Considere o fragmento de classes e o programa a seguir:

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

O resultado da. * ou – > * operadores de ponteiro para membro é um objeto ou função do tipo especificado na declaração do ponteiro para o membro.No exemplo anterior, o resultado da expressão ADerived.*pmfnFunc1() é um ponteiro para uma função que retorna void.Esse resultado é um l-value, se o segundo operando for um l-value.

Observação
Se o resultado de um dos operadores ponteiro membros é uma função, o resultado pode ser usado apenas como um operando do operador de chamada de função.

Consulte também

Referência

Operadores do C++

Precedência e associatividade de operadores

Compartilhar via