Pointer-to-Member of Pointer

The ->* operator is the C++ pointer-to-member operator used to access a class member (either a data member or a member function) through a pointer to an object, utilizing a pointer-to-member variable. It binds the abstract offset or resolution mechanism of a class member to a concrete object instance located at a specific memory address.

Syntax

object_pointer->*pointer_to_member

Operand Requirements

• Left Operand (object_pointer): Must be a pointer to an object of class type T (i.e., T*), or a type derived from T.
• Right Operand (pointer_to_member): Must be a pointer-to-member of class T or a base class B of T. Its type is expressed as U T::* (or U B::* if pointing to a member of a base class), where U is the underlying type of the data or function.

Evaluation and Return Type

The behavior and resulting type of the ->* expression depend strictly on the nature of the right operand:

1. Pointer to Data Member: If the right operand points to a data member of type U, the ->* expression evaluates to an lvalue of type U.
   • CV-Qualification Propagation: The resulting lvalue acquires the union of the const and volatile (cv) qualifiers from both the object pointer’s target type and the pointer-to-member’s type. For example, if object_pointer is of type const T* and points to a member of type U, the resulting expression is a const U lvalue.
   • The mutable Exception: If the data member is explicitly declared mutable in the class definition, the resulting lvalue does not acquire the const qualifier from the object pointer and remains modifiable, even if accessed through a const T*.
2. Pointer to Member Function: If the right operand points to a member function, the expression evaluates to a prvalue whose type is the exact function type specified by the pointer-to-member. While it possesses a standard type, the C++ standard strictly limits its usage to being the left operand of the function call operator (). It cannot be assigned to a variable, cast, or evaluated in isolation.

Syntax Visualization

class TargetClass {
public:
    int data_member;
    mutable int mutable_member;
    void function_member(int value) {} // Defined to prevent linker errors
};

int main() {
    // 1. Instantiate an object and a pointer to it
    TargetClass obj;
    TargetClass* obj_ptr = &obj;

    // 2. Define pointers to the members
    int TargetClass::* ptr_to_data = &TargetClass::data_member;
    int TargetClass::* ptr_to_mutable = &TargetClass::mutable_member;
    void (TargetClass::* ptr_to_func)(int) = &TargetClass::function_member;

    // 3. Apply the ->* operator
    obj_ptr->*ptr_to_data = 42;          // Resolves to an lvalue of 'data_member'
    (obj_ptr->*ptr_to_func)(100);        // Resolves and invokes 'function_member'

    // 4. CV-qualification propagation and the mutable exception
    const TargetClass* const_obj_ptr = &obj;
    
    // The following line causes a compilation error because the 
    // resulting lvalue is 'const int', inheriting 'const' from const_obj_ptr:
    // const_obj_ptr->*ptr_to_data = 99; 

    // The following line succeeds because the member is declared 'mutable':
    const_obj_ptr->*ptr_to_mutable = 99; 

    return 0;
}

Technical Characteristics

• Operator Precedence: The ->* operator has lower precedence than the function call operator (). Consequently, when invoking a member function via ->*, the entire pointer-to-member expression must be enclosed in parentheses: (object_ptr->*func_ptr)(args). Omitting the parentheses results in a compilation error because the compiler will attempt to apply () to the pointer-to-member itself.
• Internal Mechanics: A pointer-to-member is not a standard memory address. For data members, it is typically implemented as a byte offset from the base address of the object. For member functions, it may contain a direct function address or an index into a virtual method table (vtable). The ->* operator performs the necessary pointer arithmetic or vtable lookup at runtime to resolve the exact memory location.
• Overloadability: Unlike its counterpart .* (which operates on object references/values), the ->* operator can be overloaded. However, it is notoriously difficult and rarely done in practice. Standard smart pointers (like std::unique_ptr and std::shared_ptr) do not overload operator->*. Returning a valid, callable result for member functions requires the overloaded operator to return a complex proxy object that subsequently overloads operator().

Master C++ with Deep Grasping Methodology!

Learn More