Revision : Function Pointers

Introduction

We have learned that the name of an array is really the address in memory of the first element of the array. Similarly, the name of a function is really the starting address in memory of the code that performs the function’s task. Pointers to functions can be passed to functions, returned from functions, stored in arrays and also assigned to other function pointers.

Basic Concept

Example:

  1. #include <conio.h>
  2. #include <iostream.h>
  3. int sum(int i,int j)
  4. {
  5. return i+j;
  6. }
  7. int minus(int i,int j)
  8. {
  9. return i-j;
  10. }
  11. void sayhello()
  12. {
  13. cout < "hello" <endl;
  14. }
  15. void main()
  16. {
  17. void (*q)() = sayHello;
  18. (*q)(); //output: hello
  19. q(); //also valid, output: hello
  20. int (*p)(int,int) = sum;
  21. int s = (*p)(5,6);
  22. cout < s < endl; //output: 11
  23. int t = p(4,2); //also valid
  24. cout < t < endl; //output: 6
  25. p = minus; //re-assigned
  26. cout < (*p)(5,3) < endl; //output: 2
  27. p = sayHello; //invalid, different type
  28. q = sum; //invalid, different type
  29. getch();
  30. }

From the above example we can see that:

Here sayHello, sum and minus in line 21, 25 and 31 respectively are addresses and can be viewed as constant pointer to the code that performs the task, therefore this address can be assigned to pointer of compatible type, that is function pointers

In the above program we have declared two function pointers p and q.

q is declared by:

void (*q)() = sayHello;

This is the simplest form for a function pointer, the asterix ‘*’ indicates that q is a pointer. The parenthesis (brackets) enclosing *q is a must (otherwsie void *q() becomes function q returning void*). The () after (*q) means the type of functions pointed by q takes no parameter. The ‘void’ means that the type of functions pointed do not return anything.

Here q has been initialized to take the address of function sayHello.

In invoke the function pointed by q, we first dereference the pointer with the asterix ‘*’ and then use it just like any other functions. This is shown below:

(*q)();

Since a function name is the address of the code and the function pointer q is also the address of the code, we could also invoke the function this way just like any other functions:

q(); //also valid

However, this is NOT recommended since the user of the program may think that there is actually such a function by this name.

The above example also declared another function pointer, which is:

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

Here the declaration says that the function pointed by p takes 2 int parameters and returns int. We invoke the function pointed by p in either ways below:

s = (*p)(5,6);

t = p(5,6); //also valid

Note that you can only assign function pointer to be pointed to function with the similar signature (i.e. parameters and returned values). Therefore line 34 and 35 in the example above would produce compile time errors.

Array of Function Pointers

Example:

  1. #include <iostream.h>
  1. #include <conio.h>
  2. #include <math.h>
  3. #define CUBE 0
  4. #define CYLINDER 1
  5. #define SPHERE 2
  6. struct Thing
  7. {
  8. int id;
  9. float data1,data2,data3;
  10. };
  11. float cubeVolume(struct Thing cube)
  12. {
  13. cout < "Calculating volume of cube" < endl;
  14. return cube.data1*cube.data2*cube.data3;
  15. }
  16. float cylinderVolume(struct Thing cyl)
  17. {
  18. cout < "Calculating volume of cylinder" < endl;
  19. return M_PI*cyl.data1*cyl.data1*cyl.data2;
  20. }
  21. float sphereVolume(struct Thing sph)
  22. {
  23. cout < "Calculating volume of sphere" < endl;
  24. return M_PI*sph.data1*sph.data1*sph.data1*4/3.0;
  25. }
  26. void main()
  27. {
  28. float (*fun[3])(struct Thing)
  29. = { cubeVolume,cylinderVolume,sphereVolume };
  30. char *name[] = { "Cube","Cylinder","Sphere" };
  31. struct Thing t[5];
  32. t[0].id = CUBE;
  33. t[0].data1 = 5.0; //width
  34. t[0].data2 = 2.0; //length
  35. t[0].data3 = 3.0; //height
  36. t[1].id = SPHERE;
  37. t[1].data1 = 4.0; //radius
  38. t[2].id = CYLINDER;
  39. t[2].data1 = 2.0; //radius
  40. t[2].data2 = 6.0; //length
  41. t[3].id = CUBE;
  42. t[3].data1 = 2.0;
  43. t[3].data2 = 6.0;
  44. t[3].data3 = 5.0;
  45. t[4].id = SPHERE;
  46. t[4].data1 = 6.0;
  47. int i;
  48. float v,sumv=0;
  49. int thingid;
  50. for (i=0;i<5;i++)
  51. {
  52. thingid = t[i].id;
  53. v = (*fun[thingid])(t[i]);
  54. //or: v = fun[thingid](t[i]);
  55. cout < "The volume of " < name[thingid]
  56. < " is " < v < endl;
  57. sumv += v;
  58. }
  59. cout < "Total volume is " < sumv < endl;
  60. getch();
  61. }

The above example declared an array of function pointers and initialized them with the different function addresses (line 35 and 36). Note that the size of the array is written immediately after the name of the array. In this example, the functions pointed by the function pointers take in a struct Thing and return float.

To invoke the function, the array subscript also appears immediately after the name of the array. This is shown in line 67 and alternatively line 68 is also valid.

The above example shows that function pointer can be a very good tool to help us to write compact programs which are much easier to debug and maintain. Without function pointer, line 67 would have to be written with many lines using the switch keyword as below:

switch (thingid)

{

case CUBE: v = cubeVolume(t[i]);

break;

case SPHERE: v = sphereVolume(t[i]);

break;

case CYLINDER: v = cylinderVolume(t[i]);

break;

}

If we have many more types of Thing, then this would be very problematic.