Pointers to Functions and Callbacks

Pointers to Functions

• Functions are stored in memory like variables.
• Pointers can point to functions.
• Special pointer types exist for functions, which specify parameter and return types.

Callbacks

• Pointers implement callbacks via one function calling another with a pointer argument.
• The first function calls the second function in some fashion beyond control.
• The second function, written by the user, is the callback function.
• Callbacks are commonly used in Event-Driven Programming
• Examples include mouse clicks, stopwatch timers, and network communication.
• Callbacks allow the user to control what happens, but the system decides when it happens.

Declaration of Pointers to Functions

• Function pointers are declared using the following syntax: return-type (*variable-name)(parameters);
• Example int (*ptr)(float x, int y);
• Parameter names are optional in the declaration.
• A function pointer declaration looks like a function but declares a variable.
• ptr holds the memory address of a function that takes a float and an int and returns an int.

Assignment of Pointers to Functions

• The address-of operator (&) works on functions as well as variables
• &myFunction is the memory address where the function's machine code is stored.
• Function pointers are initialized as follows:
  • int (*ptr)(float, int);
  • ptr = &myFunction;
• Declaration and initialisation can be combined in one line.
• int (*ptr)(float, int) = &myFunction;

Usage of Pointers to Functions

• Function pointers, like other pointers, are values, and can be copied and assigned.
• Dereferencing a function pointer gives you the function
• *ptr is equivalent to func.
• (*ptr)(...) is equivalent to func(...)
• A pointer can be taken and the function it points to called
• Function pointers can point to any function with matching parameters and return types.

Typedef

• typedef can be placed before any declaration, converting it into a type declaration, creating an alias.
• This name can then be used in place of the type it was declared as.
• Typedefs are normally used in header files.
• Example: typedef int INTEGER; and INTEGER num = 15;

Typedef - Pointer Example

• typedef void* MagicData;
• MagicData becomes equivalent to void*.
• The new name can serve as documentation and indicate something specific about the data.
• It can also serve as a primitive form of information hiding
• Other code does not need to know what MagicData really is.

Typedef - Pointers to Functions

• typedef can simplify pointers to functions by needing only one convoluted declaration in a header file:
• typedef int (*MyType)(float, int)
• MyType is shorthand for int (*)(float, int)
• int (*ptr)(float, int) = &myFunction; is equivalent to MyType ptr = &myFunction;
• Pointers to functions can be returned by other functions.
• MyType function2(char a, double b)
• return &myFunction;
• Without typedef, the syntax for this would be strange.

Functions as Data Types

• Pointers to functions allow you to treat functions as data types, which may look unusual.
• The declarations follow all the same rules as other declarations
• In the function declaration int myFunction(float, int); the type is int...(float,int)
• The name and type are split, with the name in the middle, the return type to the left, and the parameters to the right.

Pointers to Functions - Declarations

• If you want a pointer to int...(float,int) (a function with those parameters and return type)
• The * goes to the left of the name.
• The name goes in the middle since the function type is split to either side.

Pointers to Functions - Declarations almost correct example

• int* myPointer(float,int); is almost right, with the name surrounded by the type.
• However, it declares a function that returns a pointer, not a pointer to a function, due to precedence.
• The parameter list precedence is higher than *.
• If there's (...) immediately to the right, you have a function.

Pointers to Functions - Correct Declarations

• Brackets override operator precedence.
• int (*myPointer)(float,int); is correct.
• It declares a variable that is a pointer to a function that:
• imports a float and an int
• returns an int.

Returning Pointers to Functions

• Functions can return any data type, including pointers to other functions.
• For the declaration to look like the return type goes on the left.
• Pointers to functions have separate parts of the declaration on the left and right.
• Two parameter lists are needed, one for the function being declared, and another for the function it returns.
• Remember all the other rules when returning pointers to functions.

Steps for Returning Pointers to Functions

• Write the function without a return type myFunction(char a, double b)
• Add a * on the left, as it returns a pointer, per Rule 2
• *myFunction(char a, double b)
• Add brackets as per rule 4 to keep it that way
• (*myFunction(char a, double b))
• Add the second parameter list, turning the function into a function pointer by Rule 3
• (*myFunction(char a, double b))(float,int)
• Add the return type per the same convention:
• int (*myFunction(char a, double b))(float,int)
• Compare this the the earlier myPointer example:
• int (*myPointer)(float,int)
• int (*myFunction(char a, double b))(float,int)
• myPointer is a pointer to a function, and myFunction returns a pointer to a function
• The brackets after the name make the difference between a variable and a function as per rule 3.

Returning pointers to functions - example

• simpleFunction takes a float and an int, and returns 10
• int simpleFunction (float x, int y)
  • return 10;
• myFunction takes a char and a double, and returns a simpleFunction pointer
• int (*myFunction(char a, double b))(float,int)
  • return &simpleFunction
• declare a function pointer myPointer, and set result to point to myFunction where the arguments are ('A', 2.5)
• int (*myPointer) (float,int);
• int result;
• myPointer = myFunction('A', 2.5);
• declare a result that dereferences pointer to myPointer, where the arguments are (7.0, 3).
• result = (*myPointer) (7.0, 3);