Callback

In computer programming, a callback is executable code that is passed as an argument to other code. It allows a lower-level software layer to call a subroutine (or function) defined in a higher-level layer.

A callback is often back on the level of the original caller.

Use

Callbacks have a wide variety of uses. For example, imagine a function that reads a configuration file and associates values with options. If the options are identified by a hash, then writing the function so that it takes a callback makes it more flexible: the user of it can use whatever hashing algorithm he wishes and the function will continue to work, since it uses the callback to turn option names into hashes; thus, callbacks allow the user of a function to fine-tune it at runtime.

Another use is in error signaling. A Unix program, for example, might not want to terminate immediately when it receives SIGTERM; to make sure things get taken care of, it would register the cleanup function as a callback.

Callbacks may also be used to control whether a function acts or not: Xlib allows custom predicates to be specified to determine whether a program wishes to handle an event.

Example

The following code in C demonstrates the use of callbacks for the specific case of dealing with a POSIX-style signal (in this case SIGUSR1).

#include <stdio.h>
#include <signal.h>
 
void sig(int signum)
{
        printf("Received signal number %d!\n", signum);
}
 
int main(int argc, char *argv[])
{
        signal(SIGUSR1,&sig);
 
        while(1);
 
        return 0;
}

The while loop will keep this example from doing anything interesting, but it will give you plenty of time to send a signal to this process. (If you're on a unix-like system, try a "kill -USR1 <pid>" to the process ID associated with this sample program. No matter how or when you send it, the callback should respond.)

Implementation

The form of a callback varies among programming languages.

• C and C++ allow function pointers as arguments to other functions.
• Several programming languages (though especially functional programming languages such as Scheme or ML) allow closures, a generalization of function pointers, as arguments to other functions.
• In object-oriented programming languages, a call can accept an object that implements some abstract interface, without specifying in detail how the object should do so. The programmer who implements that object may use the interface's methods exclusively for application-specific code. Such objects are effectively a bundle of callbacks, plus the data they need to manipulate. They are useful in implementing various design patterns such as Visitor, Observer, and Strategy.
• C++ allows objects to provide their own implementation of the function call operation. The Standard Template Library accepts these objects (called functors), as well as function pointers, as parameters to various polymorphic algorithms
• .NET Framework provides a type-safe encapsulating reference, a 'delegate', to manage function pointers. These can be used for callback operations.
• Perl supports subroutine references.^[1][2]
• Some systems have built-in programming languages to support extension and adaptation. These languages provide callbacks without the need for separate software development tools.

See also

• Signals and slots
• Event-driven programming
• libsigc++, a callback library for C++
• Implicit invocation
• User exit
• Inversion of control

External links

• Style Case Study #2: Generic Callbacks
• C++ Callback Solution
• Basic Instincts: Implementing Callback Notifications Using Delegates
• Implement Script Callback Framework in ASP.NET
• Implement callback routines in Java

References