Is there a way for a function to return a unique function in C?

Question

I want to be able to call a function to do something with a struct kind of like a class's methode with the self argument in python.
Something like this: struct.doSomethingWithStruct() where doSomethingWithStruct doesn't need to have &struct passed to it in order to do something with it.

I tried to make a function that returns another function with the struct build into it but every time i call it, it modifies struct1* S for all other structs too because functionBuilder returns a pointer to the same function every time.

#include <stdlib.h>
#include <stdio.h>

typedef struct {
    int x;
    void* (*print)(int x);
} struct1;

void* functionBuilder(struct1* s){
    void printStruct1(int a){
        struct1* S = s;
        printf("%d\n", a+S->x);
    }
    return printStruct1;
}

struct1* structBuilder(int x){
    struct1* temp = malloc(sizeof(struct1));
    temp->x = x;
    temp->print = functionBuilder(temp);
    return temp;
}

int main() {
    struct1 *s1 = structBuilder(10);
    struct1 *s2 = structBuilder(20);
    
    s1->print(1);
    s2->print(2);
    
    free(s1);
    free(s2);

    return 0;
}

This code prints:
21
instead of
11
22

I've tried to allocate memory for struct1* S but that also didnt work.
I've been trying to find a way for functionBuilder to return a unique function each time but i'm new to C and I havn't managed to find a way to do this yet.

If anyone knows how to do this or something else that also work please provide an explenation of how it works because im new to C and like to learn new things.

PS: I'm new to stackoverflow and if there is any way for me to improve this question please tell me how.

Answer 1

ISO C offers no portable way to do this, but if you know what specific platform you're targeting, you can do it. For example, here's a solution that works on x86-64 linux:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/mman.h>

typedef void (*printType)(int x);

typedef struct {
    int x;
    printType print;
} struct1;

__asm__(
    "printStruct1Template:\n\t"
    "endbr64\n\t"
    "mov printStruct1TemplateEnd(%rip), %rsi\n\t"
    "jmp *printStruct1TemplateEnd+8(%rip)\n"
    "printStruct1TemplateEnd:"
);
extern const char printStruct1Template[], printStruct1TemplateEnd[];

void printStruct1Inner(int a, struct1* S){
    printf("%d\n", a+S->x);
}

#define TEMPLATE_LEN (printStruct1TemplateEnd - printStruct1Template)
#define LEN (TEMPLATE_LEN + 16)

printType functionBuilder(struct1* s){
    char *mem = mmap(NULL, LEN, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
    memcpy(mem, printStruct1Template, TEMPLATE_LEN);
    memcpy(mem + TEMPLATE_LEN, &s, 8);
    void *innerAddr = (void *)printStruct1Inner;
    memcpy(mem + TEMPLATE_LEN + 8, &innerAddr, 8);
    mprotect(mem, LEN, PROT_READ|PROT_EXEC);
    __builtin___clear_cache(mem, mem + LEN);
    return (printType)mem;
}

struct1* structBuilder(int x){
    struct1* temp = malloc(sizeof(struct1));
    temp->x = x;
    temp->print = functionBuilder(temp);
    return temp;
}

int main() {
    struct1 *s1 = structBuilder(10);
    struct1 *s2 = structBuilder(20);
    
    s1->print(1);
    s2->print(2);
    
    munmap((void *)s1->print, LEN);
    munmap((void *)s2->print, LEN);
    
    free(s1);
    free(s2);

    return 0;
}

Answer 2

C does not provide anything like lambdas that allow you to capture values from the current scope and call the function later to access those values. Even C extensions that allow nested functions (like you use here) make those nested functions local to the enclosing function (like local vars), so when the outer function returns, the nested function (and any pointer to it you may have saved or returned) is no longer valid.

So to do this, you need to somehow create a "new" function at runtime to capture the extra information you need. You can do that by JIT creating new functions as Joseph Sible describes above, but that tends to be very target specific as well as error-prone and tricky.

An alternative is to "pre-create" at compile time a bunch of instances of a function and an array of the extra data, with each function hard-coded to access a specific array element. You can then dole these out as needed. Some code I have lying around to save extra arguments to a callback function (for use with a library that only has callbacks with no arguments):

#define REP10(P, M)  M(P##0) M(P##1) M(P##2) M(P##3) M(P##4) M(P##5) M(P##6) M(P##7) M(P##8) M(P##9)
#define REP100(M) REP10(,M) REP10(1,M) REP10(2,M) REP10(3,M) REP10(4,M) REP10(5,M) REP10(6,M) REP10(7,M) REP10(8,M) REP10(9,M)

typedef void (*callback_fn_t)(void);            // or whatever signature you need
typedef void (*callback_internal_t)(void *);    // with extra args so you can get what you need

struct callback_t {
    struct callback_t   *next;
    const callback_fn_t callback;
    callback_internal_t internal;
    void                *extra;
};
#define CB_FUNC_DECL(M)  static void cbfunc##M();
REP100(CB_FUNC_DECL)
#define CB_TABLE_INIT(M) { M ? callback_table+M-1 : 0, cbfunc##M },
static struct callback_t callback_table[100] = { REP100(CB_TABLE_INIT) };
static struct callback_t *callback_freelist = &callback_table[99];
#define CB_FUNC_DEFN(M)  static void cbfunc##M() { callback_table[M].internal(callback_table[M].extra); }
REP100(CB_FUNC_DEFN)

struct callback_t *alloc_callback(callback_internal_t fn, void *arg) {
    struct callback_t *rv = callback_freelist;
    if (rv) {
        callback_freelist = rv->next;
        rv->internal = fn;
        rv->extra = arg;
    }
    return rv;
}   

void free_callback(struct callback_t *cb) {
    cb->next = callback_freelist;
    callback_freelist = cb;
}

With this you can allocate callbacks by calling alloc_callback and then pass cb->callback as the callback argument to the external library. When it calls that callback, it will then call your callback with the extra argument.

Answer 3

You are looking for a thing like callable objects that exist in C++ – unfortunately C doesn't provide support for, so you need a way to mimic such thing.

Classic callback mechanisms often provide means to pass custom objects through via a void pointer like:

void doSomething(void(*callback)(void*), void* userData)
                                         ^^^^^^^^^^^^^^
{
    // ...
    callback(userData);
}

We can base a solution on a struct containing a function pointer and the data object:

struct Functor
{
    void(*function)(void* /* additional parameters as needed... */);
    void* object;
};

Functor functionBuilder(/*...*/)
{
    struct Functor f = { /* set the members... */ };
    return f;
}

The user would then need to call it as:

struct Functor f = functionBuilder(/*...*/);
f.function(f.object);

Instead of or additionally to the void pointer you might include further data as needed; a variant could be a union containing data for different functions and an identifier for the active union member:

struct Functor
{
    void(*function)(void); // just ANY function pointer
    unsigned int type;     // even better: a dedicated ENUM!
    union
    {
        int n;
        char const* str;
        // ...
    } data;
};

Correct usage now is a bit challenging, so we might provide a helper function doing so:

void call(struct Functor f)
{
    switch(f.type)
    {
    case 0:
        ((void(*)(int))f.function)(f.data.n);
        break;
    case 1:
        ((void(*)(char const*))f.function)(f.data.str);
        break;
    default:
        // some appropriate error handling
        break;
    }
}

Usage is then simple:

struct Functor f = functionBuilder(/*...*/);
call(f);

or even as a one-liner:

call(functionBuilder(/*...*/));