Pointer to Function

A function pointer is a variable that stores the memory address of a function. Just like a regular pointer stores the address of a variable, a function pointer stores the address of a function, allowing you to call that function indirectly.

Functions, like variables, have memory addresses. A function pointer lets you store and use these addresses to call functions dynamically.

---

##

The syntax for declaring a function pointer is:

int (*operation)(int, int);


// Assign function address
operation = add;


// Call function through pointer
int result = operation(5, 3);  // Calls add(5, 3)

---

##

1.

Every function has a memory address where its code is stored

2.

A function pointer stores this address

3.

When you call through the pointer, the program jumps to that address and executes the function

4.

You can change which function the pointer points to at runtime

Function: add()        Function: subtract()
Address: 0x1000       Address: 0x2000
    |                      |
    |                      |
    v                      v
[operation pointer] → Can point to either

---

##

###

Function pointers are commonly used for callbacks - functions that are called by other functions to perform specific tasks.

###

Arrays of function pointers create efficient lookup tables for selecting functions based on input.

###

Function pointers enable implementing the Strategy design pattern, allowing algorithms to be selected at runtime.

void bubbleSort(int arr[], int n) { /* ... */ }
void quickSort(int arr[], int n) { /* ... */ }

void sortArray(int arr[], int n, void (*strategy)(int[], int)) {
    strategy(arr, n);  // Use selected strategy
}

###

Function pointers are essential for event-driven programming where different functions handle different events.

void (*eventHandlers[])(Event) = {
    handleClick,
    handleKeyPress,
    handleMouseMove
};

eventHandlers[eventType](event);

---

##

###

Function pointer syntax can be complex. Using typedef makes it more readable:

\\\`cpp

typedef int (*MathOperation)(int, int);

// Now use it like a regular type

MathOperation op1 = add;

MathOperation op2 = subtract;

\\\`

\\\`cpp

MathOperation op = add;

\\\`

###

Functions can return function pointers:

\\\`cpp

int (*getOperation(char op))(int, int) {

switch(op) {

}

}

int (*op)(int, int) = getOperation('+');

int result = op(10, 5);

\\\`

###

Function pointers work seamlessly with STL algorithms:

\\\`cpp

vector<int> numbers = {5, 2, 8, 1, 9};

bool (*compare)(int, int) = [](int a, int b) { return a > b; };

sort(numbers.begin(), numbers.end(), compare);

\\\`

---

##

###

| Feature | Function Pointers | Functors |

|---------|------------------|----------|

| State | No | Yes (can have member variables) |

| Inline | Rarely | Often |

| Overhead | Low | Very Low |

| Flexibility | Medium | High |

###

| Feature | Function Pointers | Lambdas |

|---------|------------------|---------|

| Syntax | Complex | Simple |

| Capture | No | Yes |

| Inline | Rarely | Often |

| Type | Explicit | Auto-deduced |

-

Legacy code, C compatibility, simple callbacks

-

Modern C++, need capture, inline optimization

-

Need state, complex operations, performance-critical

---

##

Before calling through a function pointer, verify it's not null

\\\`cpp

if (operation != nullptr) {

result = operation(a, b);

}

\\\`

Make function pointer types more readable

\\\`cpp

typedef int (*Op)(int, int);

\\\`

Function pointer signature must match the function exactly

\\\`cpp

int (*op)(int, int) = add;

// Wrong - signature mismatch

// int (*op)(int) = add; // Error!

\\\`

Always initialize function pointers to avoid undefined behavior

\\\`cpp

int (*op)(int, int) = nullptr; // Safe initialization

\\\`

Clearly document when function pointers are used as callbacks

---

##

int *operation(int, int) is a function, not a pointer

Function signature must match exactly

Always check for null before calling

Using &function is optional but function alone works

Return type and parameters must match exactly

---

##

-

Function pointers have minimal overhead (one indirect jump)

-

Compilers can optimize function pointer calls in some cases

-

Function pointer calls may have cache misses

-

Functions called through pointers usually cannot be inlined

For performance-critical code, consider using templates or functors instead of function pointers.

---

##

###

int (*operations[])(int, int) = {add, subtract, multiply, divide};
int result = operations[userChoice](num1, num2);

###

typedef void (*PluginFunction)();
PluginFunction plugins[] = {plugin1, plugin2, plugin3};
for (auto plugin : plugins) {
    plugin();  // Execute each plugin
}

###

typedef void (*StateFunction)();
StateFunction currentState = initialState;
currentState();  // Execute current state
currentState = nextState;  // Transition

---

##

While function pointers are still useful, modern C++ offers alternatives:

1.

More flexible, can store any callable

   std::function<int(int, int)> op = add;
   

2.

Inline function definitions

   auto op = [](int a, int b) { return a + b; };
   

3.

Compile-time polymorphism

   template<typename Func>
   void useFunction(Func f) { f(); }
   

---

##

Function pointers are a powerful feature that enables:

Understanding function pointers is essential for advanced C++ programming and opens up many possibilities for writing flexible, reusable code.