Which type to use for an arbitrary function pointer in C?

Question

In short, my question is: does the C standard allow for an arbitrary function pointer type similar to void * being an arbitrary data pointer type?

It is common to define call-back function types with a void * parameter to pass on an arbitrary data package whose format is known to the call-back function, but not to the caller.

For example:

    typedef void (* EventFunctionType)(void *data);

    void RegisterEventFunction(EventFunctionType function, void *data);

An "EventFunction" can then be registered with a data pointer which will be passed to the function when it is called.

Now suppose we want to pass a function pointer to the call-back. The function could have any prototype which would be known to the specific call-back function, just like the arbitrary data structure above.

A void * cannot hold a function pointer, so which type could be used?

Note: An obvious solution to this problem would be to wrap the function pointer in a data structure with the correct function pointer type, but the question is if the function pointer could be passed on directly in a generic form which the call-back could then cast to a pointer with the correct prototype?

Answer 1

does the C standard allow for an arbitrary function pointer type similar to void * being an arbitrary data pointer type?

No. Two function pointers are only compatible if their return types and parameters (including qualifiers) match.

However, pointer conversions between any two function pointers by means of a cast are well-defined (6.3.2.3/8) as long as you don't invoke the function through the wrong pointer type. This means that you can use any function pointer type as a "generic function pointer" as long as you keep track of what function that pointer actually points at. Such as using an extra enum for that purpose.

Generally when using function pointers, we don't do that however, but instead define a common interface. For example like the callbacks to bsearch/qsort which use the form int (*)(const void*, const void*).

---

Here's an example of "keep track of type using enum", which is not something I particularly recommend but otherwise perfectly well-defined:

#include <stdio.h>

static int intfunc (int x)
{
  printf("%d\n", x);
  return x;
}

static double doublefunc (double x)
{
  printf("%f\n", x);
  return x;
}

typedef enum
{
  INTFUNC,
  DOUBLEFUNC
} functype_t;

typedef void generic_func_t (void);
typedef int  int_func_t     (int);
typedef int  double_func_t  (double);

typedef struct
{
  generic_func_t* fptr;
  functype_t type;
} func_t;

void func_call (const func_t* f)
{
  switch(f->type)
  {
    case INTFUNC:    ((int_func_t*)f->fptr )   (1);   break;
    case DOUBLEFUNC: ((double_func_t*)f->fptr) (1.0); break;
  }
}

int main (void)
{
  func_t f1 = { (generic_func_t*)intfunc, INTFUNC };
  func_t f2 = { (generic_func_t*)doublefunc, DOUBLEFUNC };

  func_call(&f1);
  func_call(&f2);
}

That's "old school" C, but it is not recommended since it is clunky, brittle and not really type safe. In modern C programming we wouldn't write that kind of code however, but replace that whole mess with something like this:

#include <stdio.h>

static int intfunc (int x)
{
  printf("%d\n", x);
  return x;
}

static double doublefunc (double x)
{
  printf("%f\n", x);
  return x;
}

#define func_call(obj)               \
  _Generic((obj),                    \
           int:    intfunc,          \
           double: doublefunc) (obj) \
                        

int main (void)
{
  func_call(1);
  func_call(1.0);
}

Answer 2

There are no function pointer type that works the same as/similar to to void-pointer.

But function pointers has another characteristic that can be used. It's already referenced in the answer linked in this question:

In the C11 draft standard N1570, 6.3.2.3 §8:

A pointer to a function of one type may be converted to a pointer to a function of another type and back again.

This mean that you can use any function pointer type as your "arbitrary function pointer type". It doesn't matter as long as you know how to get back to the real/original type (i.e. know the original type so that you can cast correctly).

For instance:

typedef void (*func_ptr_void)(void);

and then use func_ptr_void as your "arbitrary function pointer type".

But notice that unlike conversion between void* and other object pointer types, the conversion between function pointers will always require an explicit cast. The code example below shows this difference:

#include <stdio.h>

typedef void (*func_ptr_void)(void);

typedef int (*f_int)(int);

int bar(int n)
{
    return n * n;
}

int test(func_ptr_void f, int y)
{
    f_int fc = (f_int)f; // Explicit cast
    return fc(y);
}

int foo(void* p)
{
    int* pi = p;    // Explicit cast not needed
    return *pi;
}

int main(void)
{
    int x = 42;
    void* pv = &x;  // Explicit cast not needed
    printf("%d \n", foo(pv));
    
    func_ptr_void fpv = (func_ptr_void)bar;   // Explicit cast
    printf("%d \n", test(fpv, 5));
    
    return 0;
}