Question

Scenario:

There are multiple C structs, each of which contains a function pointer to the same function. These pointers can be different if necessary (pointers to pointers, etc.), but must all point, eventually, to the same function.

Problem:

When the function is called from one of the pointers, I need to retrieve, within the function, which struct it was called from.

e.g.

typedef struct A {
    void * (*func)();
    ... /* Custom properties */
} * A;

typedef struct B {
    void * (*func)();
    ... /* Custom properties */
} * B;


A a_init() {
    A a;
    ... /* Custom initialisation, allocation, etc. */
    a->func = myFunc;
    return a;
}

B b_init() {
    B b;
    ... /* Custom initialisation, allocation, etc. */
    b->func = myFunc;
    return b;
}


int main () {
    A a = a_init();
    void *something = a->func();
}


void * myFunc () {
    // Need to get pointer to the instance of the struct this was called from here
}

Is there any way I can retrieve a pointer to the caller within myFunc? If necessary, I was thinking of creating pointers to pointers, etc. to the function, so each instance of an object would have a different pointer, and store all of them in a central location to match them up, but that obviously won’t work if I can’t even find the instance of the object or the pointer which was used. Any ideas?

Edit:

The question was intended a bit more broadly than I seem to have put it. Currying would be a great solution, if anyone has any ideas as to how to implement it in C. I had some ideas, but I just ended up coming right back to this spot with it.

Answer 1

I don’t think there is any way within the language to do that, without explicitly passing some identifier (as an argument or a global) to myFunc. The address of a_init() exists somwhere within the call stack, but it’s not accessible from the program.

It’s like if somebody showed up at your door unannounced, how would you find out where that person came from without asking?