Can I declare an "opaque" function pointer type without the full signature?

Question

Can I declare an opaque function pointer type, without a full prototype, and initialize a structure containing a pointer to a function of that type, without fleshing out the signature (which will be full declared at the point of use).

For example:

// file api.h

typedef void (*function_ptr)(???);

typedef struct {
  function_ptr func;
} S;

function_ptr foo;
function_ptr bar;

const S structs[] = { {foo}, {bar} };

// file impl.c

typedef ret_type (*function_ptr)( // complex argument list );

void foo( // complex argument list) {
...
}

void bar( // complex argument list) {
...
}

structs[0].func(arg1, arg2, arg3);

Basically I want to hide the details of the function prototype (the return type and the parameter list) from the api.h header file, but still declare structs that use a pointer to this function. At the location of the declaration of any such functions, or of their use, the full prototype should be in scope, and argument checking will occur, etc.

A similar pattern works fine with forward-declared structs: you could forward declare an opaque struct C and use pointers to that struct in other structures, including static initialization of pointers to C eg:

struct C;

typedef struct {
    struct C* c;
} D;

extern struct C c;

D d[] = {
        { &c }
};

The details of C are totally hidden. I'm looking for the equivalent pattern for function pointers.

Answer 1

In C, the typedef

typedef void (*function_ptr)();

associates the type void (*) () with function_ptr. The type void (*) () means "a pointer to a function that takes an unspecified number of arguments and returns void," and you can call such a function pointer with any number of arguments that you'd like. This might match what you're looking for.

Answer 2

Can't think of any meaningful way this is possible in C. (In C++ there are some solutions that probably meet the use case.) The main reason is there's not really any use in knowing something is a function pointer without any of the concrete info. A struct has a name, which needs to obey ODR rules, so there is a notion of type comparison with no details other than the name.

The opaque struct pointer technique is best used to hide everything inside a struct from those outside a file. So putting the function pointer inside a struct is likely the best bet. This may force an extra level of indirection.

Answer 3

One ugly workaround is to declare your pointers of any valid function pointer type (e.g., the simplest void returning 0-arg function like void (*voidfunc_ptr)(void)) in your api.h file and then cast them to the actual type at invocation time. You'll then need to expose the actual function pointers to the api.h file. You can't use the function itself since it isn't really of the right type (probably it would work if you declared your functions voidfunc in one place and used their full definition elsewhere, but it's an ODR violation).

One way you can do that is to use double indirection: in a file where the function implementations are visible, assign a function pointer to a voidfunc global.

Here's a sketch:

// file api.h
typedef void (*voidfunc_ptr)(void);

typedef {
    voidfunc_ptr* f;
} S;

extern voidfunc_ptr foo_p;
extern voidfunc_ptr bar_p;

S array_of_s[] = { {&foo_p}, {&bar_p} };

// file impl.h

typedef int (*real_function_ptr)( //complex signature... );

// file impl.c which defines foo and bar
int foo( //complex signature... ) { ... }
int bar( //complex signature... ) { ... }

voidfunc_ptr foo_p = (voidfunc_ptr)foo;
voidfunc_ptr bar_p = (voidfunc_ptr)bar;

// some file that uses impl.h and knows about real_function_ptr

void callS(S s) {
  ((real_function_ptr)(*s.f))(// pass complex args); 
}

void use_array() {
  callS(array_of_s[0]);
}

So you completely hide the type of the function pointer in the api.h file, but one cost is double indirection (you have to store a voidfunc_ptr* which is a pointer-to-a-function-pointer) in order to get allow static initialization from an extern voidfunc_ptr. If you didn't need static initialization, you could avoid the double indirection.

Another cost is an ugly call side: you need to cast the voidfunc_ptr back to the real underlying pointer type. Perhaps there is a way to move the pain elsewhere by declaring another struct like S2 that puns S to contain the correct pointer type (I'm not sure if this is legal). If you forget to do this cast you could call the function as a voidfunc_ptr possibly with disastrous results.

The upside is that you still get parameter type checking at the call sites (after the cast).