C function pointer: returning a function pointer from a function

Question

I'm currently learning C, and trying to make my code more readable and easy to write, I found myself in need of creating a function (closure) in a function, and returning that function. Here's what I'm trying to do:

#typedef int (int_predicate*)(int);
int_predicate equals(int x) {
  int ret(int y) { return x == y; }
  return ret;
}

Now, this, doesn't work, and I get it: I'm creating this closure (ret) inside a function, so once this function returns, the pointer is no longer relevant, because it was defined on the stack. This is similar to if I did it for a pointer for a simpler type:

int* bad_int_ptr_function() {
  int intOnTheStack;
  int* ptr = &intOnTheStack;
  return ptr;
}

So, how can I achieve what I want - creating a closure in a function and returing it? If the size of the type pointed at, was known, I'd be able to use malloc, and if I wanted to, I could follow it with a memcpy. But, I can only presume that the size of a function can't be found with a sizeof, because a function can have any number of lines.

This is C, I can't use syntax or libraries that are specific to C++ (I've heard C++ recently-ish got lambda expressions - if only I could use C++, but I can't, this if for a C-specific course).

Answer 1

In Standard C, you cannot define closures as functions, but you can emulate them using data structures:

#include <stdio.h>

typedef struct int_predicate_t {
    int (*func)(struct int_predicate_t *s, int x);
    int y, z;
} int_predicate_t;

#define APPLY(p, x)  ((p).func(&(p), x))

int equal_func(struct int_predicate_t *s, int x) {
    return x == s->y;
}

int greater_func(struct int_predicate_t *s, int x) {
    return x > s->y;
}

int between_func(struct int_predicate_t *s, int x) {
    return x >= s->y && x <= s->z;
}

int_predicate_t equals(int y) {
    int_predicate_t s = { equal_func, y, 0 };
    return s;
}

int_predicate_t greater(int y) {
    int_predicate_t s = { greater_func, y, 0 };
    return s;
}

int_predicate_t between(int y, int z) {
    int_predicate_t s = { between_func, y, z };
    return s;
}

int main() {
    int_predicate_t p1 = equals(42);
    int_predicate_t p2 = greater(10);
    int_predicate_t p3 = between(1, 100);

    printf("p1(42) = %d\n", APPLY(p1, 42));
    printf("p2(42) = %d\n", APPLY(p2, 42));
    printf("p3(42) = %d\n", APPLY(p3, 42));
    printf("p1(0) = %d\n", APPLY(p1, 0));
    printf("p2(0) = %d\n", APPLY(p2, 0));
    printf("p3(0) = %d\n", APPLY(p3, 0));

    return 0;
}

Answer 2

There's no (easy, robust) way in C to create closures.*

But one way you can come somewhat close: you can return a struct that contains a function pointer that can take the struct or its address as an argument:

typedef int ( *intClosureFuncPtr )( struct intClosure * );

struct intClosure
{
    int tag // can be used to differentiate multiple struct
            // types in a union
    intClosureFuncPtr func;
        .
        .
    // fields as necessary
};

Closure functions:

int closureFunc0( struct intClosure *c )
{
       .
       .
       .
    return( 0 );
}

int closureFunc42( struct intClosure *c )
{
       .
       .
       .
    return( 42 );
}

Calling the function that creates the closure and returns the struct:

struct intClosure someFunc( ... )
{

    struct intClosureInstance = { 0 };

    intClosure.tag = 7;
    intClosure.func = closureFunc42;
    // fill in rest of the struct fields as needed 

    return( intClosureInstance );
}

Usage:

struct intClosure closureInstance = someFunc(...);
    .
    .
    .

// call the closure:
int result = closureInstance.func( &closureInstance );

It's also possible to malloc() the struct and return it by address, but that requires the caller to free() it. You'd need to assess the size of your "closure" struct and having to pass it by value against the extra complexity of requiring the caller to free() it.

Note that the return type of this "closure" is fixed. There are hacks that would likely allow dynamic selection of return types on POSIX and Windows systems since those both have one flat address space shared (current Windows does...) by all variables and functions, but those hacks would be diving into behavior that's not defined by the C standard.

* - If you're willing to limit C "closures" to being called only from the thread they're created in and to only one outstanding "closure" per thread at any instant in time, you could use thread-specific data to pass information to an actual function that's returned by function pointer when the closure is generated, and that function could then be called directly without any indirection via the above struct method. And there may be ways to allow for more complex usage patterns, but I'm not able to come up with any at the moment.