Learn C - C Function Pointer

Declaring a Pointer to a Function

The following code shows how to declare a pointer to a function.

int (*pfunction) (int);

The code above declares a variable that is a pointer to a function.

This statement just defines the pointer variable.

The name of the pointer is pfunction, and it points to functions with one parameter of type int and an int return type.

Calling a Function Through a Function Pointer

Suppose you define a function that has the following prototype:

int sum(int a, int b);

This function has two parameters of type int and returns type int. We can define a function pointer for it as follows.

int (*pfun)(int, int) = sum;

This declares a function pointer with the name pfun.

It can store addresses of functions with two parameters of type int and a return value of type int.

The statement also initializes pfun with the address of the function sum().

You can call sum() through the function pointer like this:

int result = pfun(4, 5);

This statement calls the sum() function through the pfun pointer with argument values of 4 and 5.

We can use the function pointer name just like a function name.

Suppose you define another function that has the following prototype:

int divide(int a, int b);

You can store the address of divide() in pfun with the following statement:

pfun = divide;

With pfun containing the address of divide(), you can call divide() through the pointer:

result = pfun(5, 12);

The following code has three functions with the same parameter and return types and uses a pointer to a function to call each of them.


    #include <stdio.h> 
//from  w ww . ja  v  a 2 s  . co m
    // Function prototypes 
    int sum(int, int); 
    int product(int, int); 
    int difference(int, int); 

    int main(void) { 
      int a = 10;                         
      int b = 5;                          
      int result = 0;                     
      int (*pfun)(int, int);              // Function pointer declaration 
      
      pfun = sum;                         // Points to function sum() 
      result = pfun(a, b);                // Call sum() through pointer 
      printf("pfun = sum             result = %2d\n", result); 
      
      pfun = product;                     // Points to function product() 
      result = pfun(a, b);                // Call product() through pointer 
      printf("pfun = product         result = %2d\n", result); 
      pfun = difference;                  // Points to function difference() 
      result = pfun(a, b);                // Call difference() through pointer 
      printf("pfun = difference      result = %2d\n", result); 
      return 0; 
    } 

    int sum(int x, int y) { 
      return x + y; 
    } 
      
    int product(int x, int y) 
    { 
      return x * y; 
    } 
      
    int difference(int x, int y) 
    { 
      return x - y; 
    }

The code above generates the following result.

Arrays of Pointers to Functions

You can create an array of pointers to functions.

To declare an array of function pointers, put the array dimension after the function pointer array name.

int (*pfunctions[10]) (int);

This declares an array, pfunctions, with ten elements.

Each element in this array can store the address of a function with a return type of int and a parameter of type int.

The following code shows how to use an array of pointers to functions.


     #include <stdio.h> 
      //from w  w w  . j  av a 2 s .com
     // Function prototypes 
     int sum(int, int); 
     int product(int, int); 
     int difference(int, int); 
      
     int main(void) { 
          int a = 10;   
          int b = 5;    
          int result = 0;
          int (*pfun[3])(int, int);           // Function pointer array declaration 
    
          // Initialize pointers 
          pfun[0] = sum; 
          pfun[1] = product; 
          pfun[2] = difference; 
          
          // Execute each function pointed to 
          for(int i = 0 ; i < 3 ; ++i) { 
            result = pfun[i](a, b);           // Call the function through a pointer 
            printf("result = %2d\n", result); 
          } 
          
          // Call all three functions through pointers in an expression 
          result = pfun[1](pfun[0](a, b), pfun[2](a, b)); 
          printf("The product of the sum and the difference = %2d\n", result); 
          return 0; 
     } 
    int sum(int x, int y) { 
      return x + y; 
    } 
      
    int product(int x, int y) 
    { 
      return x * y; 
    } 
      
    int difference(int x, int y) 
    { 
      return x - y; 
    }

The code above generates the following result.

Pointers to Functions As Arguments

You can use a pointer to a function as an argument to a function.

In this way we can call different function depending on which function is pointed by the pointer.


    #include <stdio.h> 
      /*from  w ww  . j  av a  2  s  .c om*/
    // Function prototypes 
    int sum(int,int); 
    int product(int,int); 
    int difference(int,int); 
    int any_function(int(*pfun)(int, int), int x, int y); 
      
    int main(void) { 
      int a = 10;  
      int b = 5;   
      int result = 0;
      int (*pf)(int, int) = sum;          // Pointer to function 
      
      // Passing a pointer to a function 
      result = any_function(pf, a, b); 
      
      printf("result = %2d\n", result ); 
      
      // Passing the address of a function 
      result = any_function(product,a, b); 
      
      printf("result = %2d\n", result ); 
      
      printf("result = %2d\n", any_function(difference, a, b)); 
      return 0; 
    } 
    // Definition of a function to call a function 
    int any_function(int(*pfun)(int, int), int x, int y) { 
      return pfun(x, y); 
    } 
    int sum(int x, int y) { 
      return x + y; 
    } 
    int product(int x, int y) { 
      return x * y; 
    } 
    int difference(int x, int y) { 
      return x - y; 
    }

The code above generates the following result.