Why Callbacks Are Just Function Variables: A Simple C Example

Understanding Callbacks as Function Variables

In fact, a callback function is not fundamentally different from an ordinary function; it is simply a function treated as a variable that can be passed around.

Normal function call

Consider a regular function call where A invokes func directly.

void A() {
    // ...
    func();
    // ...
}

void func() {
    // implementation
}

If you package A as a library for worldwide use, other developers may want to execute their own code at a specific point inside A. A naive approach would be to add a large series of if‑else statements for each user:

void A() {
    // ...
    // specific point
    if (ZhangSan) {
        funcA();
    } else if (LiSi) {
        funcB();
    }
    // ...
}

With millions of users, this would lead to millions of conditional branches, which is impractical.

Better approach: pass a function as a parameter

Instead, treat the function as a variable and let callers supply their own function to be executed at the desired point.

void A(void (*f)()) {
    // ...
    f(); // invoke the passed‑in function
    // ...
}

Now each developer can call A and provide a custom function, eliminating the need for countless if‑else blocks and reducing code size dramatically.

The term “callback function” is simply a confusing label for this function‑as‑variable technique. Understanding callbacks as function variables clarifies their purpose and shows how they improve modularity and reusability.

This explanation provides the basic principle of callbacks and demonstrates why they are essentially just function variables.