CODEWITHSUNDEEP
c
lerosQ
lerosQ

Reputation: 250

Function pointers, design

I am in a problem with a design question in C.

Let's say that I have a pretty large amount of functions, with different argument count.

POQ:

int print_one(int x)
{
    printf("one: %d\n", x);
    return 1;
}

int print_three(int x, int y, int z)
{
    printf("three: %d-%d-%d\n", x, y, z);
    return 3;
}

Now, I want to connect some properties to these functions in a structure, so that I can manipulate them without knowing the exact function, including their parameter count (I might even call the structure interface)

I tryd it like this, (& I think is pretty wrong):

typedef int (*pfunc)(int c, ...);

typedef struct _stroffunc
{
    pfunc myfunction;
    int flags;
    int some_thing_count;
    int arguments[10];
    int argumentcount;
} stroffunc;

int main()
{
    stroffunc firststruct;

    firststruct.pfunc = (pfunc) print_two;
    firststruct.something_count = 101;
    arguments[0] = 102;
    argumentcount = 1;
    flag &= SOME_SEXY_FLAG;

    // now I can call it, in a pretty ugly way ... however I want (with patially random results ofc)
    firststruct.pfunc(firststruct.arguments[0]);
    firststruct.pfunc(firststruct.arguments[0], 124, 11);
    firststruct.pfunc(1, firststruct.arguments[0], 124, 1, 1);
}

I find this solution very ugly, & I think (hope) that there is a better solution for calling & and setting the function pointers.

I'm just hoping, that I was clear enough ... NOTE: I didn't compile this code, but i compiled & run a very similar one so the concepts are working. NOTE: pure C needed

Upvotes: 3

Views: 153

Answers (3)

Oliver Charlesworth
Oliver Charlesworth

Reputation: 272467

Calling a non-variadic function through a variadic function pointer leads to undefined behaviour. For a start, recall that the arguments to variadic functions undergo the default argument promotions (chars are converted to ints, etc.), which will totally screw things up.

It's not clear how or why you intend to dynamically call a function with differing numbers of arguments. But one solution could be to use a union:

typedef struct {
    int num_args;
    union {
        void (*f1)(int);
        void (*f2)(int, int);
        void (*f3)(int, int, int);
    } func;
} magic;


...

magic m;
...
switch (m.num_args) {
case 1: m.func.f1(arg1); break;
case 2: m.func.f2(arg1, arg2); break;
case 3: m.func.f3(arg1, arg2, arg3); break;
default: assert(0);
}

A second solution would be to rewrite all of your functions as variadic.

Upvotes: 1

DGomez
DGomez

Reputation: 1480

Maybe you can add a library which have some functions to handle the struct, like a "pseudo" class,

int initFunc(int (*pfunc)(int c,...));

This function will save the pointer into the struct, like a context in POO, in the struct you will use it like a "map" of all the function an you will call each one using an id.

which returns an id, and you save it in an array, then another func say

int call(int id,int p1,...);

where you say the function id and the parameters, sure you must now which function is each id

Upvotes: 0

Grady Player
Grady Player

Reputation: 14549

This is on the edge of my knowledge, but I believe that you need to make the functions variadic as well, due to incompatibilities in the ABI.

see: wikipedia's example

Upvotes: 0

Related Questions