C Function Pointers

Function Pointer

A function pointer is like a normal pointer, but instead of pointing to a variable, it points to a function.

This means it stores the address of a function, allowing you to call that function using the pointer.

Function pointers let you decide which function to run while the program is running, or when you want to pass a function as an argument to another function.

Think of it like saving a phone number - the pointer knows where the function lives in memory, so you can "call" it later.

Declaring a Function Pointer

The general syntax for declaring a function pointer is:

returnType (*pointerName)(parameterType1, parameterType2, ...);

For example:

int (*ptr)(int, int);

This means ptr is a pointer to a function that takes two int values and returns an int.

Assigning a Function to a Pointer

You can assign a function to a pointer in two ways:

ptr = add;
ptr = &add;

Both are the same, because the function's name already represents its address in memory.

Calling a Function Through a Pointer

Once the pointer is assigned, you can call the function in two ways:

ptr(5, 3);
(*ptr)(5, 3);

Both are valid and do the same thing.

Function Pointer Example

Now that you know how to declare and assign a function pointer, let's see a complete example:

Example

int add(int a, int b) {
  return a + b;
}

int main() {
  int (*ptr)(int, int) = add;
  int result = ptr(5, 3);
  printf("Result: %d", result);
  return 0;
}

Here:

• ptr is a pointer to the function add().
• ptr(5, 3) calls the function using the pointer.

This works exactly the same as calling add(5, 3).

Note: A function name itself points to the start of its code in memory. That means a function name already acts like a pointer! Declaring a function pointer just gives you a variable that can hold that address - so you can change it or pass it around.

Passing a Function as an Argument

Function pointers can be passed to other functions - this is called a callback.

It allows a function to call another function that you provide as input.

Example

void greetMorning() { printf("Good morning!\n"); }
void greetEvening() { printf("Good evening!\n"); }

void greet(void (*func)()) {
  func();
}

int main() {
  greet(greetMorning);
  greet(greetEvening);
  return 0;
}

Here, greet() takes another function as a parameter and calls it. This is commonly used in event-driven programs or libraries that need user-provided callback functions.

Function Pointer Array

You can also store several function pointers in an array, so you can choose which function to run while the program is running.

This example runs three different functions using an array of function pointers:

Example

void add() { printf("Add\n"); }
void subtract() { printf("Subtract\n"); }
void multiply() { printf("Multiply\n"); }

int main() {
  void (*operations[3])() = { add, subtract, multiply };
  for (int i = 0; i < 3; i++) {
    operations[i]();
  }
  return 0;
}

This is often used for simple menus, command lists, or calculators - anywhere you want to call different functions based on user input.

Example

void add(int a, int b) { printf("Result: %d\n", a + b); }
void subtract(int a, int b) { printf("Result: %d\n", a - b); }
void multiply(int a, int b) { printf("Result: %d\n", a * b); }

int main() {
  int choice, x = 10, y = 5;

  void (*operations[3])(int, int) = { add, subtract, multiply };

  printf("x = %d, y = %d\n\n", x, y);
  printf("Choose an operation:\n");
  printf("0: Add\n1: Subtract\n2: Multiply\n");
  scanf("%d", &choice);

  if (choice >= 0 && choice < 3) {
    operations[choice](x, y);
  } else {
    printf("Invalid choice!\n");
  }

  return 0;
}

In this program:

• All three math functions (add(), subtract(), and multiply()) are stored in an array.
• The user picks which one to run by entering a number.
• The correct function is then called using the pointer array.

This is a simple example of how function pointer arrays make programs more flexible and reusable.

Function Pointer vs Normal Function

Summary

• A function pointer stores the address of a function.
• You can declare, assign, and call functions through it.
• It allows passing functions as arguments to other functions.
• Useful for callbacks, menus, and flexible program design.