Function pointers point to executable code at a particular piece of memory. Dereferencing the function pointer allows the code in the memory block to be executed. Main benefit of function pointers is that they provide a straightforward mechanism for choosing a function to execute at runtime.

Important points about Function Pointer

  • Unlike normal pointers, a function pointer points to code, not data. A function pointer stores the start address of executable code.
  • Function name can also be used to get functions address. Also address operator (&) can also be used.
  • A function pointer can be passed as an argument and can also be returned from a function.


Following illustrates the syntax of declaring a function pointer:

<returnType> (*<functionName>) (functionArguments);

Syntax of declaring a function pointer is similar to the syntax of declaring a function. Only difference is that instead of using the function name, use a pointer name inside the parentheses (). In the above syntax

  • returnType is the return type of the function pointer. It can be any valid type such as int, float, char, or void.
  • Name of function pointer is inside parentheses.
  • functionArguments specify all parameters of the function with their corresponding types. Function pointer only can refer to a function with the same signature.
void (*pf)(int);

In above example *pf is the pointer to a function. void is the return type of that function, and int is the argument type of that function.

Defining Function Type

It is convenient to use a typedef to define the function type. For example

typedef void (*functionPtr)(int);

Above defined a type functionPtr. Variables of this type point to function that take an int as a parameter and don’t return anything. It can be use to declare variable of type functionPtr as shown below

functionPtr fPtr;


Below example shows usage of function pointer. Function op takes three argument, last argument is function pointer.

#include <iostream>

typedef double (*functionPtr)(double, double);

double add(double val1, double val2) {
  return val1 + val2;

double substract(double val1, double val2) {
  return val1 - val2;

double op(double val1, double val2, functionPtr f) {
  return (*f)(val1, val2);

int main() {

  double a = 5.0;
  double b = 10.0;

  std::cout << "Add: " << op(a, b, add) << std::endl;
  std::cout << "Substract: " << op(a, b, substract) << std::endl;

  return 0;

functionPtr specify returns double and takes two double values. op dereferences the function pointer in order to execute the correct function – add or substract.

Below shows usage of function pointer.

// Define a function pointer and initialize to NULL
// pt2Function is a pointer to a function which returns an int and takes a float and two char
int (*pt2Function)(float, char, char) = NULL;

int DoMore(float a, char b, char c) {
  return a - b + c;

// Assign an address to a Function Pointer
pt2Function = &DoMore;

// Calling a Function using a Function Pointer
int result1 = pt2Function(12, 'a', 'b');
int result2 = (*pt2Function) (12, 'a', 'b');

// Pass a Function Pointer as an Argument.
void PassPtr(int (*pt2Function)(float, char, char))
  // call using function pointer
  int result = (*pt2Function)(12, 'a', 'b');

// Declare function pointer type
typedef float(*pt2Function)(float, float);

float Plus(float a, float b) {
  return a + b;

float Minus(float a, float b) {
  return a - b;

// Function takes a char and returns a function pointer which is defined with the typedef above.
pt2Function GetPtr2(const char opCode)
  if (opCode == '+') {
    return &Plus;
  else {
    return &Minus;

// Arrays of Function Pointers
typedef int (*pt2Function)(float, char, char);

void Array_Of_Function_Pointers()
  // Define arrays and set each element to NULL
  pt2Function funcArr[10] = { NULL };

  // Assign the function's address
  funcArr[0] = funcArr[1] = &DoMore;


Function pointer