Detailed explanation of member access operators and pointer-to-member operators in C++

Member access operators:. and ->

grammar

      postfix-expression
      . name
postfix-expression –> name
Remark
Member access operators . and -> are used to refer to members of structures, unions, and classes. A member access expression has the value and type of the selected member.
There are two forms of member access expressions:
In the first form, postfix-expression represents the value of a structure, class, or union type, and name name names the members of the specified structure, union, or class. The value of the operation is the value of name and is an lvalue (if postfix-expression is an lvalue).
In the second form, postfix-expression represents a pointer to a structure, union, or class, and name name names a member of the specified structure, union, or class. This value is the value of name and is an lvalue. The –> operator dereferences the pointer. Therefore, the expressions e–>member and (*e).member (where e represents a pointer) produce the same result (except in cases where the overload operators -> or * are present).
The following example demonstrates two forms of member access operators.

// expre_Selection_Operator.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

struct Date {
  Date(int i, int j, int k) : day(i), month(j), year(k){}
  int month;
  int day;
  int year;
};

int main() {
  Date mydate(1,1,1900);
   = 2;  
  cout <<  << "/" << 
     << "/" <<  << endl;

  Date *mydate2 = new Date(1,1,2000);
  mydate2->month = 2;
  cout << mydate2->month << "/" << mydate2->day
     << "/" << mydate2->year << endl;
  delete mydate2;
}

In this case, the two values ​​are:

2/1/1900
2/1/2000

Pointer to member operators: .* and ->*

 
grammar

      expression .* expression
expression –>* expression
Remark
Pointer operators (.* and –>*) to members return the value of a specific class member of the object specified on the left side of the expression. The right side must specify a member of the class. The following example demonstrates how to use these operators:

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

The results are:

1
2

In the previous example, the pointer to a member pmfn is used to call the member function m_func1. Another pointer to a member pmd is used to access the m_num member.
The binary operator .* combines its first operand (must be an object of class type) with its second operand (must be a pointer type to a member).
Binary operator ->* combines its first operand (must be a pointer to an object of class type) with its second operand (must be a pointer to a member).
In an expression containing the .* operator, the first operand must be of a class type and accessible, while a pointer to a member specified in the second operand or a pointer to a member of the accessible type is explicitly derived from the class and accessible to the class.
In an expression containing the ->* operator, the first operand must be a "pointer to the class type" of the type specified in the second operand or a type explicitly derived from that class.
Consider the following classes and program segments:

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

The result of pointer operators .* or –>* to a member is an object or function of the type specified in the declaration of a pointer to a member. Therefore, in the previous example, the result of the expression ADerived.*pmfnFunc1() is a pointer to the function returning void. If the second operand is an lvalue, this result is an lvalue.
System_CAPS_note Note
If the result of a pointer operator to a member is a function, the result can only be used as the operand of the function call operator.