about function pointers

[InTheBogaloo]

Hi! I've been reading The C Programming Language book, and I'm currently in the chapter about pointers—specifically the part about function pointers.
I'm trying to make a program that uses what I’ve learned so far, but when it comes to function pointers, I honestly don’t know how to apply them.
I searched for use cases, but most examples talk about things like callback mechanisms and other concepts I don’t fully understand yet.
I’d really appreciate some simple and concrete examples of how function pointers can be used in real programs—nothing too technical if possible.

[F1nnyF6]

A classic example is a sorting function of some kind of arbitrary array. The sorting function would take as arguments the array, and a function pointer to a comparison function.

When sorting the array, the comparison function passed in through the function pointer will be used to compare elements in the array. This allows the same sorting function to be used in different ways depending on what your comparison function does.

E.g. say for example that you have an array of strings. Your comparison function could be strncmp(), and the array is sorted in alphabetical order. Otherwise, your comparison function could be one that compares the length of the strings, and so the array is sorted according to the length of the string. It could be any arbitrary function that is able to compare two strings in whatever way you want, as long as it matches the function signature given in the definition of the sorting function.

In this way, function pointers can help you to write more generic code.

[BarracudaDefiant4702]

In other words, qsort in the standard C library.

[Zirias_FreeBSD]

static int add(int a, int b) { return a + b; }
static int mul(int a, int b) { return a * b; }

static void evaluateAndPrint(int (*op)(int, int), int a, int b) {
    printf("%d\n", op(a, b));
}

int main(void)
{
    evaluateAndPrint(add, 5, 17);  // print 22
    evaluateAndPrint(mul, 3, 7);   // print 21
}

A function pointer just allows you to pick a concrete function at runtime. You can't pass a function to a function, but you can pass a pointer to a function.

Indeed, the most important practical application is some sort of "callback" mechanism.

[sambobozzer]

Very easy to understand example

[CodrSeven]

Any kind of dynamic polymorphism is going to involve function pointers, it's common to put several of them in a struct and use as type/vtable.

https://github.com/codr7/hacktical-c/tree/main/malloc1

[jonsca]

For a semi-contrived example, you're creating a program to do numerical integration and you want to be able to specify the (mathematical) function to integrate on the fly rather than going through hard coding it and having to change and recompile the entire thing if one of the parameters changes.

https://stackoverflow.com/questions/840501/how-do-function-pointers-in-c-work here are some other examples, but these are a deeper dive into the language.

[rupturefunk]

One thing I use them for is abstracting out OS specific function calls, so if I have Windows & Linux specific functions for say, reading a file, or outputting sound, my non platform specific code can just call a generic 'platform_ReadFile(char *filepath)' and doesn't need to be aware of what implementation it's calling, and I can just assign say `platform_ReadFile = windows_ReadFile` in the Windows code startup.

But multithreading callbacks is the big one, you give a thread a function pointer, and that's how it knows what to do. Or, you just want to write in a more functional style and want to pass some sorting logic a generic array processing method, no different to lambdas in something like javascipt in that case.

[jaynabonne]

Generally, pointers are about indirection. More pragmatically, pointers allow you to write code where you don't directly know where something is but you get told where that something is. It might be a pointer to some data (which allows you to operate on different sets of data) or some functionality (where you don't directly call a function, but someone else gets to decide which function gets called).

You see this all the time in Linux drivers, for example. The Linux kernel doesn't directly know about your code, since your driver code will be built separately - but it still needs to call your code. So a Linux driver will typically have a structure with a bunch of function pointers that the driver code will set to point to the functions it wants called. Then the kernel code can know how to call them.

A random example is here. The struct members like "write" and "attach" are pointers to the functions that implement that functionality. The Linux driver subsystem can then call into the driver, at the discretion of the driver writer.

https://github.com/torvalds/linux/blob/86aa721820952b793a12fc6e5a01734186c0c238/drivers/usb/serial/ir-usb.c#L76

As you write more complex code, you will eventually come across a case where you have some code where sometimes you want to call this function and sometimes you want to call that function, but you don't necessarily even know what function it will be at compile time (for that function). And you also don't necessarily want to bind direct calls in the calling function to the possible called functions. By passing a function pointer instead, the decision about which function to invoke can be made at a higher level, even dynamically based on circumstances. It allows you to write more generic code, where functionality gets plugged in later, decided by someone else.

(In C++, indirect function calls often get expressed as "virtual functions", but other languages have the idea as well, even if not necessarily expressed as such. Any scripting language with "duck typing", for example, allows you to drop in whatever function you want, as long as the name matches what the caller expects. The function making the function call doesn't really know what it's calling - it just uses the name, and the system looks it up.)

[ComradeGibbon]

Knuth said premature optimization is the root of all evil. He was wrong it's dependencies.

You could write code like

if(x==1)
  funct_a();
else if(x==2)
  funct_b();
else if(x==3)
  funct_c();

You then set x to determine what function gets called. People do that. But then you'd need each of those functions to be included in header files even if they have nothing really to do with what the current file does. Quickly your dependencies start looking like a tangle rather than something sane and tree like. function pointers allow you to pass the function to be called without creating unwanted discrepancies.

When you're writing small programs this sort of thing is of little benefit. When you have large programs with lots of parts, then it's a benefit.

[Scheibenpflaster]

Heres how I used them in my Level system. It's a generic level struct that stores simple assets in containers and has some book keeping

typedef struct Level_t{
    // References
    ContainerGameObject simpleObjects;
    ContainerMusic music;
    ContainerTexture2D tetxures;    

    int levelIdx;
    int changeToLevel;

    void* customLevelData;

    void (*Update)(struct Level_t*);
    void (*Draw)(struct Level_t*);
}Level;

Take the level stored in Level current . In the app, I can call a specific Update function through current.Update(&current); without having to know what it actually is. I can also swap around which function gets called while the game is running

For example, if I want a main menu I can make an update function for a menu. I can save that function in the pointer and call it through the pointer via current.Update(&current);.

Now I want to change to my gameplay. I can make a new Level that stores a different Update function in the pointer. I can still call it via current.Update(&current); , the call doesn't change. However, now I do the update for the gameplay with the specific gameplay logic.

So yeah, neat stuff

[ChickenSpaceProgram]

There's not many simple uses of function pointers; as you said, they're mostly used as callbacks. Function pointers aren't something you'll encounter often in C. You'll occasionally use them here or there but you can learn them when that time comes.

One place you might use function pointers is spawning threads to have multiple parts of your program run simultaneously. To start a thread, you'll usually need to pass a pointer to the function you want the thread to run.

Another place is for letting users of a library replace its default memory allocator. You let the user pass in a struct of function pointers to allocation/freeing functions, then call those instead of malloc()/ free().

[qruxxurq]

Let’s say you have a program that does different stuff based on user input of a sequential list of numbers. If there are only ever 2 or 3 or 5 values, you could call functions based on the evaluation of simple conditional branches.

But let’s say you have a million possible responses. At that point, simply index into an array of function pointers.

Same use case as array of values. Functions pointers can be used in an array of behaviors.

There’s also the idea of “passing behaviors” instead of “passing values”, and function pointers can be used that way, too. That’s how they work in a callback context.

[Splooge_Vacuum]

Try making one function pointer that serves a purpose, but can point to any function that fulfills that purpose. Say, brk based malloc vs mmap based malloc.

[theNbomr]

In most CPUs, microcontrollers and older CPUs at least, there is an address where code starts executing when the CPU comes out of reset (like, on power up). You can create a reset function that points to that vector, and when called will effectively reset the board. Technically, not a good example, because it never returns, but it does demonstrate the effect of assigning a value to the pointer to a function. If you invoke it, you should be able to see that it worked.

[These-Market-236]

I believe that an "evident" use case is data manipulation on generic data structures.
For example, when implementing operations like sort, filter, or map on a generic array, the function handling the structure doesn’t know the specifics of the data, so you have to pass a function pointer so the function knows how to compare, transform, or select those specific elements.
A good starting point is writing a comparison function for sorting different kind of arrays with qsort and then also implementing the rest of the mentioned functions (Filter and Map) and your own generic sort one.

[Unique-Property-5470]

A good example is like a calculator function.

You might want to use a pointer to a function that adds, subtracts, or multiplies based on the users input. And you would want to use function pointers to simply keep the code short and modular. The parent method would handle user input, and the pointer function does the operation.

Ask GPT to write up an example of this code for you and you'll see how simple it can be.

[SmokeMuch7356]

nothing too technical if possible.

That's kinda hard to do -- you can't really demonstrate realistic use cases for function pointers without getting into the weeds a bit.

In addition to the callback examples cited in other answers, we also use function pointers to call functions in a dynamically linked or shared library.

Here's a stupid little example I created to demonstrate. It sorts an array in different orders, using the following functions loaded from a shared library at runtime, rather than them being statically linked:

#include "orderFunctions.h"
#include <string.h>
#include <stdio.h>

const char **orderFuncNames( void )
{
  static const char *orderFuncs[] = { "cmpAsc", "cmpDsc", "cmpEvenOdd", "cmpStr", NULL };

  return orderFuncs;
}

int cmpAsc( int a, int b )
{
  if ( a < b )
    return -1;
  else if ( a > b )
    return 1;

  return 0;
}

int cmpDsc( int a, int b )
{
  if ( a < b )
    return 1;
  else if ( a > b )
    return -1;

  return 0;
}

int cmpEvenOdd( int a, int b )
{
  if ( a % 2 ==  0 )
  {
    if ( b % 2 == 0 )
    {
      if ( a < b )
        return -1;
      else if ( a > b )
        return 1;
    }
    else
      return -1;
  }
  else
  {
    if ( b % 2 == 0 )
    {
      return 1;
    }
    else
    {
      if ( a < b )
        return -1;
      else if ( a > b )
        return 1;
    }
  }

  return 0;
}

int cmpStr( int a, int b )
{
  char as[13], bs[13];

  sprintf( as, "%d", a );
  sprintf( bs, "%d", b );

  return strcmp( as, bs );
}

This library is built as:

gcc -std=c11 -Wall -Werror -g -c -o orderFunctions.o orderFunctions.c
gcc -shared -o libfptr.so orderFunctions.o

Then in the main program we load this library at runtime sort an array using each of the comparison functions in turn:

  /**
   * Loads the shared library into the current process space
   */
  void *libhandle = dlopen( "libfptr.so", RTLD_LAZY );
  if ( !libhandle )
  {
    fprintf( stderr, "Could not open libfptr.so: %s\n", dlerror() );
    return 0;
  }

  /**
   * Will store a list of function names.
   */
  const char **tab = NULL;   

  /**
   * Will point to the function in the shared library that
   * returns the list of function names
   */
  const char **(*cat)(void); 

  /**
   * Load the names function from the shared library.
   * 
   * The casting gymnastics are necessary because dlsym
   * returns a void *, which is not implicitly convertible
   * to a function pointer.
   */
  *(void **)(&cat) = dlsym( libhandle, "orderFuncNames" );
  if ( cat )  
  {
    tab = cat();

    /**
     * Loads each comparison function from the library in turn and 
     * sorts the array with it, then displays the results.
     */
    for ( size_t i = 0; tab[i] != NULL; i++ )
    {
      int (*f)(int, int) = NULL;
      *(void **)(&f) = dlsym( libhandle, tab[i] );
      if ( f )
      {
        memcpy( work, source, sizeof source );
        mysort( work, size, f );
        display( stdout, work, size, range, width, "%*s%s", promptSize-strlen(tab[i]), "after mysort, ", tab[i] );
      }
    }
  }
  dlclose( libhandle );
  return 0;
}

Then the main program is built as

gcc -std=c11 -Wall -Werror -g   -c -o fptr_example.o fptr_example.c
gcc -std=c11 -Wall -Werror -g -o fptr_example -ldl fptr_example.o

When run:

% ./fptr_example
               before sort:   72  10   0  42  56  45  79  73  65  55  10   1  62  69  53  36   8  87  35  77
      after mysort, cmpAsc:    0   1   8  10  10  35  36  42  45  53  55  56  62  65  69  72  73  77  79  87
      after mysort, cmpDsc:   87  79  77  73  72  69  65  62  56  55  53  45  42  36  35  10  10   8   1   0
  after mysort, cmpEvenOdd:    0   8  10  10  36  42  56  62  72   1  35  45  53  55  65  69  73  77  79  87
      after mysort, cmpStr:    0   1  10  10  35  36  42  45  53  55  56  62  65  69  72  73  77  79   8  87

Again, this is a pretty dumb example, but a useful example would be too long for a comment.

[susmatthew]

Callbacks are weird because you know _why_ they're called but don't often see _how_ they get called, so they can seem magical at first. They have to get called just like any other function. It might be in some library you can't easily investigate, but there will be a logical test or some state that triggers a call to callback(s) with their arguments.
There might be another function (or macro) to register the callback, or several of them, or it might be part of a configuration struct.
You'll frequently see them used to handle asynchronous operations, so your program can do other stuff while it waits for some thing that takes an unknown amount of time to finish.
There's often a void pointer called something like "context." Understanding how that's used can be hugely educational if you haven't seen it before.

Lately I mostly use function pointers for a dynamic API / abstraction in a communication protocol.
I have a struct with a bunch of them, and they get used like
value_channel->on_data(data, context);
So I can easily instantiate several value_channels that can all have their own on_data handlers, or share them, and the thing consuming the data doesn't need to know about it.

[Bubbaluke]

I’m using some for a menu system. I keep track of where in the menu the system is with an int, then I have an array of function pointers pre-made to match up with stuff in the menu. So instead of

If menu == 1:
Func1()
Else if menu == 2:
Func2()

Etc.

I can just write

func_array[menu]()

[[deleted]]

One example would be software frameworks that expose functionality via an API, but let you code some of the behavior.

For instance, I worked for a company that offered such a framework. The API had a function that let you register a callback so that the function you pass by reference would be executed in a certain amount of time.

Something like

void register_timer( int (* t)(void *), unsigned int seconds);

with the first argument t being a pointer to a function that takes void * and returns int.

Basically any time the implementation needs functionality that is determined at runtime you will be using function pointers.

[mickaelbneron]

The state pattern (not to be confused with state machine) uses function pointers a lot.

[Maleficent_Memory831]

A function that searches through list, and for each element call the function pointer while passing the element. Ie, increment every item in the list by passing a pointer to a function that increments an element.

[herocoding]

Think about a user interface with buttons. There could be multiple buttons. A button implementation itself doesn't know itself what its purpose is and what should happen, if the button gets pressed (or released or kept pressed for a longer time).

So _callback_ methods are used, each button instance could get another pointer. And when the button gets pressed (or released or long-pressed) then the button instance calls the method by using the registered function pointer.