> ## 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 Function A pointer to a member function is a strongly-typed construct that refers to a non-static member function within a specific class. Unlike standard C-style function pointers, a pointer to a member function is rarely a simple memory address. Depending on the Application Binary Interface (ABI), virtual functions, and inheritance models (such as multiple or virtual inheritance), it is frequently implemented as a complex data structure—often referred to as a "fat pointer"—that stores vtable offsets, `this` pointer adjustments, or thunk addresses. It cannot be dereferenced and executed on its own; it strictly requires an instantiated object of the class to be invoked, as it relies on the implicit `this` pointer to access the object's state. ## Declaration Syntax The declaration must specify the return type, the class scope, the pointer name, and the parameter types. If the target function is `const`, the pointer must also be declared with the `const` qualifier. ```cpp theme={"dark"} ReturnType (ClassName::*pointerName)(ParameterTypes) [const]; ``` ## Assignment Syntax When assigning a member function to the pointer, the address-of operator (`&`) is mandatory, and the function name must be fully qualified using the scope resolution operator (`::`). ```cpp theme={"dark"} pointerName = &ClassName::FunctionName; ``` ## Invocation Syntax C++ provides traditional operators and a modern standard library utility to invoke a function through a member function pointer. **1. Modern Invocation (`std::invoke`)** Introduced in C++17, `std::invoke` (from the `` header) is the modern, standard way to invoke pointers to member functions. It abstracts away the cumbersome traditional operators and their strict precedence rules, providing a uniform syntax. ```cpp theme={"dark"} #include std::invoke(pointerName, objectOrPointer, arguments...); ``` **2. Traditional Invocation (`.*` and `->*`)** Historically, C++ provides two specific pointer-to-member operators: * `.*` : Used when invoking via an object instance or reference. * `->*` : Used when invoking via a pointer to an object. *Crucial Precedence Rule:* The function call operator `()` has higher precedence than the pointer-to-member operators (`.*` and `->*`). Therefore, the object and the pointer-to-member expression must be strictly enclosed in parentheses. ```cpp theme={"dark"} // Invocation via object instance (object.*pointerName)(arguments); // Invocation via object pointer (objectPtr->*pointerName)(arguments); ``` ## Comprehensive Code Example The following example demonstrates the mechanics of declaring, assigning, and invoking pointers to both mutable and `const` member functions using both traditional and modern syntax. ```cpp theme={"dark"} #include #include class MathOperations { public: int multiply(int a, int b) { return a * b; } int add(int a, int b) const { return a + b; } }; int main() { // 1. Declaration and assignment of a non-const member function pointer int (MathOperations::*mutPtr)(int, int) = &MathOperations::multiply; // 2. Declaration and assignment of a const member function pointer int (MathOperations::*constPtr)(int, int) const = &MathOperations::add; MathOperations mathObj; MathOperations* mathObjPtr = &mathObj; // 3. Modern invocation using std::invoke (C++17) int result1 = std::invoke(mutPtr, mathObj, 5, 4); // Calls multiply: 20 int result2 = std::invoke(constPtr, mathObjPtr, 5, 4); // Calls add: 9 // 4. Traditional invocation using the .* operator (object instance) int result3 = (mathObj.*mutPtr)(5, 4); // Calls multiply: 20 // 5. Traditional invocation using the ->* operator (object pointer) int result4 = (mathObjPtr->*constPtr)(5, 4); // Calls add: 9 return 0; } ``` ## Technical Constraints and Behavior * **Static Member Functions:** You cannot use pointer-to-member syntax for `static` member functions. Because static members lack a `this` pointer, they decay into standard C-style function pointers (e.g., `ReturnType (*ptr)(Args)`). * **Virtual Functions:** Pointers to member functions respect polymorphism. If the pointer points to a `virtual` member function, the call is resolved dynamically at runtime based on the dynamic type of the object used to invoke it. The pointer structure handles the vtable lookup automatically. * **Type Aliasing:** Because the raw syntax is notoriously verbose, it is standard practice to use `using` or `typedef` to create type aliases for member function pointers. ```cpp theme={"dark"} // Type alias using modern C++ syntax using MathOpPtr = int (MathOperations::*)(int, int); // Usage MathOpPtr ptr = &MathOperations::multiply; ```

Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More