Function pointers are a lot like regular pointers. They differ in that they point to executable instructions instead of data. A function pointer should specify the signature of the function.

We can declare a function pointer by:

uint8_t (*min)(uint8_t, uint8_t);

We can assign a function pointer to point to an actual function by:

uint8_t minimum(uint8_t num1, uint8_t num2) { return num1 < num2 ? num1 : num2; } min = &minimum;

Now that the function pointer has been assigned, we can use it to call `minimum`

using either of the following ways:

uint8_t answer = min(3, 8); uint8_t answer = (*min)(3, 8);

The second line more accurately describes the operation; however, the first method is also legal (and means the same thing).

If you ever needed to pass a function pointer, and you didn't know how to do it, the following example would probably get you on the right track:

/** * Determines the smaller of the two arguments * @param num1 first number * @param num2 second number * @return The smaller of the two arguments, or either one if they are equal */ uint8_t minimum(uint8_t num1, uint8_t num2); /** * Applies the specified operation to elements in the passed array. * @param operation Operation to be performed on the data in the array * @param data Array of data to be processed * @param length Number of elements in the array * @return Result of applying the operation to all of the elements in the array */ uint16_t processArray(uint8_t (*operation)(uint8_t, uint8_t), uint8_t *data, uint8_t length); int main() { uint8_t nums[] = {4, 3, 8, 7, 13}; uint16_t result = processArray(&minimum, nums, 5); } uint16_t processArray(uint8_t *data, uint8_t length, uint8_t (*operation)(uint8_t, uint8_t)) { uint16_t answer = data[0]; uint8_t i=1; while(i<length) { answer = operation(answer, data[i]); } return answer; }

Suppose I had a few other functions that accepted two `uint8_t`

arguments and returned a `uint8_t`

value. Say,

`maximum`

— returns the maximum of two numbers.`add`

— returns the sum of two numbers.`multiply`

— returns the product of two numbers.

Then I could use the same `processArray`

function to produce completely different results. Observer causually (because it's that easy):

/** * Determines the smaller of the two arguments * @param num1 first number * @param num2 second number * @return The smaller of the two arguments, or either one if they are equal */ uint8_t minimum(uint8_t num1, uint8_t num2); /** * Determines the larger of the two arguments * @param num1 first number * @param num2 second number * @return The larger of the two arguments, or either one if they are equal */ uint8_t maximum(uint8_t num1, uint8_t num2); /** * Determines the sum of the two arguments * @param num1 first number * @param num2 second number * @return The sum of the two arguments */ uint8_t add(uint8_t num1, uint8_t num2); /** * Determines the product of the two arguments * @param num1 first number * @param num2 second number * @return The product of the two arguments */ uint8_t multiply(uint8_t num1, uint8_t num2); /** * Applies the specified operation to elements in the passed array. * @param operation Operation to be performed on the data in the array * @param data Array of data to be processed * @param length Number of elements in the array * @return Result of applying the operation to all of the elements in the array */ uint16_t processArray(uint8_t (*operation)(uint8_t, uint8_t), uint8_t *data, uint8_t length); int main() { uint8_t nums[] = {4, 3, 8, 7, 13}; uint16_t min = processArray(&minimum, nums, 5); uint16_t max = processArray(&maximum, nums, 5); uint16_t sum = processArray(&add, nums, 5); uint16_t product = processArray(&multiply, nums, 5); } uint8_t maximum(uint8_t num1, uint8_t num2) { return num1 > num2 ? num1 : num2; } uint8_t add(uint8_t num1, uint8_t num2) { return num1 + num2; } uint8_t multiply(uint8_t num1, uint8_t num2) { return num1 * num2; }