Just like every variable in a program has an address, every function in a program too has an address. The name of the function can be used to obtain the address of a function. This address can be stored in a special type of variable which are pointers to functions. We had seen that even though all addresses are similar, there exist different types of address variables to store the addresses of different data types. For example, an int * variable stores the address of an int type variable and a long * variable stores the address of a long type variable. In a similar fashion, we will need different types of pointers to functions depending on the different types of functions.
C allows variables and functions accessed through pointers! We can then do things like, for example, pass a function as an argument to another function. A pointer to a function has the following statement:
A pointer to a function may be declared as below.
type ( *ientifier_for _pointer ) ( types_of_parameters_of_function);
The first word type in the above declaration refers to the type of data that the function returns. Then the parentheses contain the indirection operator (*) followed by the name or identifier of pointer. The next pair of parentheses contains the types of the parameters of the function. The names of parameters may not be given in the declaration of a prototype. The names of parameters are required when the function is being defined. Let pFunction be the name of pointer to a double function and has a parameter of type int. The pointer to such a function may be declared as below.
double (*pFunction ) (int)
In the above declarations, *pFunction has been enclosed in parentheses because otherwise there would be only one parentheses that encloses the parameter and which will have higher precedence than(*) operator. Thus, an expression such as double * pFunction (int) ; would mean that function pFunction takes an int arguments and returns a pointer to a double number. Therefore, it is necessary to enclose* pFunction in parentheses.
You should note that the above declaration of pointer is not tied to any particular function. The declaration of pFunction is declaration for pointer to any function that is of type double and has an int as its parameter. It will be pointer to a particular function only after it has been so initialized with address of that function.
Like an array the name of a function is also a constant pointer to the function. Therefore, a pointer to a function may be initialized by the name of the function. Let Function1, and Function2 be any two functions which are of type double and take an int as parameter. Thus, their prototypes may be written in the following manner:
double Function1 (int);
double Function2 (int);
Now we may initialize the pointer pFunction as below.
pFunction = Function1;
With this initialization, the pointer points to Function1. Also, we may as well assign the following value to pFunction:
pFunction = Function2;
After the above assignment, the pointer pFunction now points to Function2.
A function may be called by dereferencing its pointer. Thus, let n be an integer. We may call the function Function2 (after the above assignment) as given below.
int n =10;
(*pFunction)(n); II calling the Function2
Since the pointer identifier pFunction and function name both carry the address of function, the dereference operator is in fact not necessary when calling a function. The function may as well be called by pointer identifier (name) itself as shown below.
pFunction (n) is a call to the function whose address is currently held by pFunction.
Program illustrates the use of pointers to functions. The user has a choice of three functions and choice is facilitated by the pointer and a switch statement.
void PrintString (char * str, int (* func) (const char *));
char String  = "C Programming";
int (*p) (const char *); /* Statement pointer to function Function pointed and whole and receives as parameter a constant string */
p = puts; /* P The pointer changes to point to the function puts which has the following prototype: int puts (const char *) */
PrintString (String, p); /* The pointer is passed as parameter to PrintString */
void PrintString (char * str, int (* func) (const char *))
(* func) (str); /* Call the function through the function pointer */
func (str); /* Also valid way of making the call to function puts through pointer to function func */
See who made the assignment puts a p simply using:
p = puts;
From this we conclude that the name of a function (without the parentheses) is in fact the address of that function! Notice, too, the two alternative ways of calling a function through a pointer. In the above program, we made this call by:
(* func) (str);
These forms are equivalent to each other.
In addition, the program, the PrintString () function uses any function func to print the string on the screen. The programmer can then provide not only the string but also the function that will be used to print it. In main () we see how we can allocate the pointer to p functions, the address of the puts () function C.
In short, to declare a pointer to function, we can assign to this pointer the address of a function and can also call the function pointed through it. We can not do some things we did with "normal" pointers, for example, increment or decrement a pointer to function.