Pointers may also be declared to point to functions.  It is interesting to note that function names are constant pointers
to the function itself.  You can declare a pointer variable that points to a function.  The function can then be invoked
by using that pointer.  This allows programs to dynamically decide which functions to invoke based upon user input. 
When using function pointers, you must be clear about the type of object pointed to - so watch your data types and
return types!.  A pointer to a function must point to a function of the appropriate return type and signature.  Example: long (* funcPtr) (int);

In the example above, "funcPtr" is declared to be a pointer that points to a function that takes an int parameter and returns a long. Parentheses are necessary around "*funcPtr" because the parentheses around "int" bind tighter and have a higher precedence than the indirection operator "*".  Without the first set of parenthesis, the previous statement would declare a function, rather than a pointer to a function, that takes and integer and returns a pointer to a long.  Declaration of a function pointer always includes the return type and parentheses, indicating the type of parameters.

Four functions are declared in this example with same return type and signature, returning void and taking 2 references to integers.  Next, "AFunctionPointer" is declared to be pointer to a function that returns void and takes 2 integer reference parameters.  Any of previous functions can be pointed to by AFunctionPointer, since they all take two int references and return void.  Remember that they must agree in both their argument types and return type in order for the function pointer to work properly. 

The user is offered the choice about which functions to invoke, and "AFunctionPointer" is assigned accordingly to a function.  This has the effect of invoking the function that AFunctionPointer points to the next time we use this pointer as a function call.  In the PrintVal function, the current value of two int's is printed, the currently assigned function is invoked, and then the values are printed again.  In this case, we are dealing with memory addresses rather than values, so pointers to functions do not need to be dereferenced.  If "AFunctionPointer" is a pointer to a function, taking an integer and returning a variable of type long, and you then assign AFunctionPointer to a matching function, you can invoke it 2 ways:

AFunctionPointer(x); -          shorthand version, not dereferenced
(*AFunctionPointer)(x); -   long version, dereferenced.

Arrays of pointers to functions - You can declare arrays of pointers to functions for returning specific value types and signatures: 

Passing pointers of functions to other functions - Pointers to functions can be passed to other functions that take action:

The expression, void PrintVals(void (*)(int&, int&),int&, int&; , may save the program when it is a required construct, but this should be used infrequently.  Also, the expression void (*)(int&, int&) is cumbersome.  We can use typedef to simplify this:

lIn the example above, typedef is used to declare FUNC to be a function that returns void and takes two parameters which are both integer references. The object, "FunctionPointer" is then declared to be of type FUNC.

Pointers to member functions - Unlike pointers to functions, pointers to member functions REQUIRE an object of the class on which to invoke them.  There must be an instance.  Use same syntax as a pointer to a function, but INCLUDE the class name and the scoping operator (::).  For example:  if FunctionPointer points to a member function of the class Shape which takes two integers and returns void, we would write the expression: void (Shape::*FunctionPointer) (int, int);  Example:

In this example, new sub classes of the base class, Mammal, are created on free store and assigned to ptr.  The class member method chosen and assigned to FunctionPointer is invoked by the object created.  The "ptr" accesses the object and "FunctionPointer" accesses the function.  Even though this points to the Mammal function, the methods were declared virtual and so have been overridden in every derived class.  In this way, they simpy "do the right thing".  There is NO need to call delete on the function pointer "FunctionPointer" because it is a pointer to code, not to an object on the free store.  However, we do need to call delete on "ptr", since it points to actual Mammal objects created on the heap using "new".

Arrays of pointers to member functions - pointers to member functions can be stored in an array: 

Output:
(0)Quit (1)Speak (2)Move (3)Eat (4)Growl (5)Whimper (6)Roll Over (7)Play Dead: 1
Woof!
(0)Quit (1)Speak (2)Move (3)Eat (4)Growl (5)Whimper (6)Roll Over (7)Play Dead: 4
Grrr
(0)Quit (1)Speak (2)Move (3)Eat (4)Growl (5)Whimper (6)Roll Over (7)Play Dead: 7
Is this the end of Little Ceasar?
(0)Quit (1)Speak (2)Move (3)Eat (4)Growl (5)Whimper (6)Roll Over (7)Play Dead: 0

In this example, the Dog class is created with 7 member functions sharing the same return type and signature.  The typedef declares PDF to be a pointer to a member function of Dog class, that takes no parameters and returns no values, and that is const (in agreement with the signature of the 7 member functions of Dog).  We then create an array of pointers to Dog class functions, "DogFunctions", to hold the seven member functions and to be initialized with their addresses.  The user prompted to pick a method.  Unless "Quit" is selected, a new Dog object is created on heap and the correct method is invoked in the array. 

Analyze this: (pDog->*DogFunctions[Method - 1])(); (good for a table built from member functions).

©2004 C. Germany