Cfrgtkky

I am looking into an callback example in:
https://en.wikipedia.org/wiki/Callback_(computer_programming)

#include <stdio.h>

#include <stdlib.h>



/* The calling function takes a single callback as a parameter. */

void PrintTwoNumbers(int (*numberSource)(void)) {

    int val1 = numberSource();

    int val2 = numberSource();

    printf("%d and %dn", val1, val2);

}



/* A possible callback */

int overNineThousand(void) {

    return (rand()%1000) + 9001;

}



/* Another possible callback. */

int meaningOfLife(void) {

    return 42;

}



/* Here we call PrintTwoNumbers() with three different callbacks. */

int main(void) {

    PrintTwoNumbers(&rand);

    PrintTwoNumbers(&overNineThousand);

    PrintTwoNumbers(&meaningOfLife);

    return 0;

}

I understand all the functions. However, I am wondering except reducing a line, what's the advantage of doing:

PrintTwoNumbers(&overNineThousand);

rather than just using them like regular functions:

int a = overNineThousand();

PrintTwoNumbers(a);

Thanks!

This is a trivial example of what's known as a Higher Order Function.

In this particular example, it isn't very useful. You're right that it would be easier to just pass the data directly.

It's a technique that allows for the generalization of functions though, and is very helpful in reducing code duplication when used properly.

A typical example is the map function that transforms a list:

var arr = [1, 2, 3];

var newArr = arr.map(x => x + 1); // Pass a function that adds one to each element



print(newArr); // Prints [2, 3, 4]

Without higher order functions, you would have to write the same looping code that comprises map every time you want to transform a list. What if I wanted to add 2 to each element somewhere else? Or multiple each by 5? By passing a function, you can tell it how you want it to transform each item, without worrying about the iteration.

As noted in the comments, another example would be sorting functions. They allow you to pass a function that determines sort order. Without that ability, you would need to write a new sorting function for each different sort order and element type.

Sorry I couldn't answer this in C. I understand what's going on in the code you've posted, but I don't know C, so I couldn't give good example code that uses HOFs.

If the question is just computing one element, then yes, a callback is not very useful.

Now if we consider that the function may need to call the callback several times in a (non-)deterministic way, then a callback is required.

Typically, one of the most common callback in C is qsort where the callback is mandatory.

There are at least two situations in which callbacks are useful:

• Functions in which a task is performed repeatedly on some data. The example given in the comments is good: a comparison function passed into a sort function as a callback is a good example of a useful callback.


• Enumeration functions. This is when you ask a library for a list of objects and you want to act on each one. You would pass a callback to the enumeration function. Example: EnumWindows.