Question

I’d like to be able to generically pass a function to a function in C. I’ve used C for a few years, and I’m aware of the barriers to implementing proper closures and higher-order functions. It’s almost insurmountable.

I scoured StackOverflow to see what other sources had to say on the matter:

• higher-order-functions-in-c
• anonymous-functions-using-gcc-statement-expressions
• is-there-a-way-to-do-currying-in-c
• functional-programming-currying-in-c-issue-with-types
• emulating-partial-function-application-in-c
• fake-anonymous-functions-in-c
• functional-programming-in-c-with-macro-higher-order-function-generators
• higher-order-functions-in-c-as-a-syntactic-sugar-with-minimal-effort

…and none had a silver-bullet generic answer, outside of either using varargs or assembly. I have no bones with assembly, but if I can efficiently implement a feature in the host language, I usually attempt to.

Since I can’t have HOF easily…

I’d love higher-order functions, but I’ll settle for delegates in a pinch. I suspect that with something like the code below I could get a workable delegate implementation in C.

An implementation like this comes to mind:

enum FUN_TYPES {
    GENERIC,
    VOID_FUN,
    INT_FUN,
    UINT32_FUN,
    FLOAT_FUN,
};

typedef struct delegate {
    uint32 fun_type;
    union function {
        int (*int_fun)(int);
        uint32 (*uint_fun)(uint);
        float (*float_fun)(float);
        /* ... etc. until all basic types/structs in the 
           program are accounted for. */
    } function;
} delegate;

Usage Example:

void mapint(struct fun f, int arr[20]) {
    int i = 0;
    if(f.fun_type == INT_FUN) {
        for(; i < 20; i++) {
            arr[i] = f.function.int_fun(arr[i]);
        }
    }
}

Unfortunately, there are some obvious downsides to this approach to delegates:

• No type checks, save those which you do yourself by checking the ‘fun_type’ field.
• Type checks introduce extra conditionals into your code, making it messier and more branchy than before.
• The number of (safe) possible permutations of the function is limited by the size of the ‘fun_type’ variable.
• The enum and list of function pointer definitions would have to be machine generated. Anything else would border on insanity, save for trivial cases.
• Going through ordinary C, sadly, is not as efficient as, say a mov -> call sequence, which could probably be done in assembly (with some difficulty).

Does anyone know of a better way to do something like delegates in C?

Note: The more portable and efficient, the better

Also, Note: I’ve heard of Don Clugston’s very fast delegates for C++. However, I’m not interested in C++ solutions–just C .

Answer 1

You could add a void* argument to all your functions to allow for bound arguments, delegation, and the like. Unfortunately, you’d need to write wrappers for anything that dealt with external functions and function pointers.