Thread: Doing a linked-list of function pointers

This should suffice as a generic function pointer if that's what you are asking.

Code:

typedef void (*voidFunc)(void);

Of course if you want to store a function pointer to something with a different signature, and cast back to what it should be before calling it, then I would hope that you just use the right function signature to begin with. Perhaps consider making all of your functions have the same signature, e.g. the parameters could be an array of some kind of variant structure. I dunno, it would really help to know what you are doing as this is a really strange thing to do.

> The functions will have different return types and different numbers of arguments.
You're going to have to have some kind of flag indicating the type, otherwise how will you cast it back to the right type to call it?

Code:

typedef struct fp {
    enum { ONE, TWO } type;
    union {
        int (*one)(void);
        void (*two)(int);
    } fn;
    struct fp *next;
} fp_list;

Your call list traversal would just have a switch/case to use the correct union member.

Code:

switch ( p->type ) {
    case ONE: result = p->fn.one(); break;
    case TWO: ....
}

Hi again -
Thanks very much for your solutions, iMalc and Salem! Very useful!

The "use case" for this is that I want to poke around with a simple "object system". The linked-list of function pointers will be the methods that an object has.
( If there is a better way of doing this, then I'm very keen to hear about it. )

( I should say that I'm doing this in C rather than C++ because I much prefer the simpler, cleaner syntax of C. )

Anyway, I reckon that the code you've given here should be fine for getting me on my way with this.
Many thanks again - bye for now -
- Andy (latte123)

I would not use a linked-list of function pointers. An Array of function pointers might be best. And if in fact you are just emmulating OOP then I'd suggest doing it the C++ way where you know the actual function signature of each method, and you don't have an array per object, but an array per type of object. Really, try and understand how C++ compilers do it internally, as the problem has had plenty of prior work done on it.