Callback Functions

Callback Function

A callback function is a function that is passed as an argument to another function.

The receiving function can then call it back (run it) whenever it needs to.

This is a powerful way to make your code flexible and reusable - you can decide which function should run, without changing the main logic.

In C, callback functions are usually implemented using function pointers.

Simple Callback Example

Here's a basic example that shows how one function can "call back" another:

Example

void sayHello() {
  printf("Hello from the callback!\n");
}

void runCallback(void (*callback)()) {
  printf("Before calling the callback...\n");
  callback();
  printf("After calling the callback.\n");
}

int main() {
  runCallback(sayHello);
  return 0;
}

In this example:

• sayHello() is a normal function that prints a message.
• runCallback() receives a function pointer as a parameter.
• When runCallback(sayHello) runs, it calls sayHello() inside itself.

Note: The word "callback" comes from the fact that one function "calls back" another that was given to it earlier.

Callback with Parameters

You can also pass functions that take parameters - just make sure the function pointer type matches:

Example

void addNumbers(int a, int b) {
  printf("The sum is: %d\n", a + b);
}

void calculate(void (*callback)(int, int), int x, int y) {
  callback(x, y);
}

int main() {
  calculate(addNumbers, 5, 3);
  return 0;
}

Here, calculate() receives a function and two numbers, then calls the function (in this case, addNumbers()) with those numbers as arguments.

Multiple Callbacks

You can use callbacks to let a function behave differently depending on which function you pass in. This is common in sorting, filtering, and event-handling code.

Example

void greetMorning() { printf("Good morning!\n"); }
void greetEvening() { printf("Good evening!\n"); }

void greet(void (*callback)()) {
  callback();
}

int main() {
  greet(greetMorning);
  greet(greetEvening);
  return 0;
}

Depending on which function is passed, the program produces different output - without changing greet() itself.

Real-World Example: Using Callbacks in qsort()

Many C standard library functions use callbacks. For example, the qsort() function in <stdlib.h> uses a callback to compare elements while sorting.

You provide the comparison function, and qsort() calls it as needed. This will sort the elements:

Example

#include <stdio.h>
#include <stdlib.h>

int compare(const void *a, const void *b) {
  return (*(int*)a - *(int*)b);
}

int main() {
  int numbers[] = { 5, 2, 9, 1, 7 };
  int size = sizeof(numbers) / sizeof(numbers[0]);

  qsort(numbers, size, sizeof(int), compare);

  for (int i = 0; i < size; i++) {
    printf("%d ", numbers[i]);
  }
  return 0;
}

Here, compare() is the callback function used by qsort() to decide how to order the numbers.

Summary

• A callback function is a function passed as an argument to another function.
• It allows one function to call another without knowing its name in advance.
• Callbacks make code more flexible and reusable.
• They are used in the C Standard Library (like qsort()).