Is the only use of function pointers to implement callbacks?

I have come across the fact that function pointers can be us开发者_运维知识库ed to implement callbacks. Is there any other usage of function pointers? Is there any other situation that function pointers proved to be useful?

How about sorting? Pass in a function pointer to compare any two elements.

How about filtering? Pass in a function pointer to decide whether an input element should be contained in the output of a filter.

How about transformations? Pass in a function pointer to convert an input element to an output element.

These are all collection-based uses, but they're very useful. (The broad equivalent of function pointers in .NET is delegates, and they're the basis of LINQ, which allows very simple querying, transformations, grouping etc.)

Anywhere you want to be able to abstract out the idea of "a single piece of behaviour", writing a generic function which doesn't need to know the details of that behaviour, a function pointer could be useful.

In addition to what Jon wrote, function pointers in C can be used to implement OO programming style (e.g. polymorphism).

Function pointers (or their typed and more advanced equivalents) are a helpful feature when implementing inversion of control related patterns. All examples mentioned are applications of IoC principle (the sorting algorithm does not control the used predicate, the call to an object method is delayed until run-time etc)

Regards,

Paul

A function pointer is used in any situation where the function to be called is determined at runtime rather than compile-time. This includes callbacks, but may also be used as a switch-case alternative for example, and to adapt the behaviour of a function by passing a function pointer that defines that behaviour - this is how the standard library qsort() function works for example, enabling it to sort any kind of object.

I have used them in particular to implement a command line parser that evaluates C expressions entered as strings at run-time, and can include function calls. This uses a symbol table to lookup the pointer to the function so it can be called on demand from the operator.

All you might ever wish to know on the subject can be found at The Function Pointer Tutorials

In the end function pointers are just one of those rarely used tools you keep in your bag. If you understand them, when the situation arises where it may provide a solution, you will hopefully recognise it.

It is the only way you can implement Higher Order Functions in C.

As others have mentioned, I've found that one of the most significant uses of function pointers (other than for callbacks) is to enable the construction of generic data structures.

Say you want to construct a hashmap with arbitrary keys and values. One way to do that is declare both void *key and void *value and then pass in two function pointers during the initialization phase: int (*hashcode)(void*) and int (*equals)(void*, void*).

This gives you the ability to build a hashmap that can take basically anything that you can write the above two functions for. In my case, the key was a fixed size character buffer and the value was a pointer to a struct.

It is also used in the following

• Making jump tables(like vector tables or ISR)
• making the function abstract
• Developing Finite State Machines (as state, action and triggered even can easily be implemented using the function pointers, the design also seems to be easy and more readable in that)
• Event Driven Framework(GUI - gtk is an example)

Other than callbacks (great for abstraction), function pointers can be used to implement polymorphism in C. This is done extensively in the Linux kernel, and common C libraries such as glibc, GTK+ and GLib.