> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# C++ 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
```cpp theme={"dark"}
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
```cpp theme={"dark"}
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()`.
Tired of Poor C++ Skills? Fix That With Deep Grasping!
Learn More
