I make regular use of forward class declarations and pointers to such classes.
I now have a need to pass a function pointer through a number of layers. I would prefer to include the header that declares my function pointer's prototype only into the module that dereferences a function pointer rather than into each layer that simply passes along that pointer value.
Is this possible?
=====
From the replies I suspect that I have not expressed by question clearly enough. I seek an analog to a forward class declaration. We all agree that I can write:
class foo;
void bar(foo*);
void waz(foo* p) { bar(p); }
Notice that waz knows nothing about class foo other than its name. Perhaps bar will have access to foo's complete description. Perhaps bar will simply pass p further along. Who cares? Only those sites that dereference a foo*. All other sites need only "class foo;".
Similarly I know that I can write:
typedef void foo(int, double);
void bar(foo*);
void waz(foo* p) { bar(p); }
The difference is that now the identifier foo not only is known to denote a function type but further already carries the full signature/prototype. This forces me into one of two unpleasant scenarios:
1) clone the typedef at multiple sites (yuck! fragile!) 2) stick the typedef in a header and include it everywhere that a foo* is mentioned.
Notice the asymetry: in the case of a data object I only needed to provide a complete description of class foo at those points where I want to dereference a foo*; in the case of a function I need to provide the full signature/prototype everywhere I want to mention a foo*.
So is there anyway to remedy this asymmetry?
You can do this using an undefined structure type, at the cost of an extra dereference.
put this in the main header file:
typedef struct FuncStruct *FuncPtr;
This declares struct FuncStruct
but does not declare any fields, then it declares a pointer to this struct called FuncPtr
. You can pass FuncPtr
s around but you can not dereference them.
then in a particular file (or a more specific .h file), you can actually define a struct FuncStruct
like this:
struct FuncStruct {
int (*f)(int, char, double);
};
Then code past this definition can dereference a FuncPtr
to get the actual function pointer.
Note this is an extra dereference from just a cast, and it means you'll need to do some memory management of FuncStruct
s.