Comments on: Closures In Straight C

By: Anonymous

Anonymous — Tue, 15 May 2012 02:15:56 +0000

Thanks, I too have found this useful in embedded environment. Beats having global or static global variables. As others have pointed out, it may be quite far from closures as they are traditionally understood, but I wouldn’t have found this article by googling “closures in C” if you didn’t mention them. Ended up having code similar to this:


typedef struct

{

    int counter;

} context_t;
static void onEventCallback(void *event, void *context)

{

    context_t *self = (context_t *)context;

    self->counter++;

}
void processAsync()

{

    context_t context, *self = &context;

    self->counter = 0;

    startProcess(onEventCallback, self);

}

By: jack

jack — Tue, 21 Feb 2012 23:48:02 +0000

..and he scores!!!

By: Travis Parks

Travis Parks — Tue, 21 Feb 2012 13:35:44 +0000

I actually found this article very useful. I have been working in Node.js lately and realized that it's asynchronous approach could actually simplify some error handling aspects in C. The only problem: closures. However, following your lead, as long as every function has a "context" object, you can overcome that limitation. Sure, the developer has to allocate/deallocate memory, but I don't think this is "inconvenient". Simply define a "context" object for each function, allocate that context for each "instance" of that function and pass it and the context as a callback. I may look into creating an async library in C, similar to caolan/async, just to play around with the concept.

By: hopia

hopia — Wed, 14 Dec 2011 17:25:33 +0000

As a long time C developer, I totally agree that callbacks and cookies are the closest thing to closures in the C world. Of course, we all know it’s not part of the language, so it’s not as intuitive and natural to use. However, I think the point of the article is that C developers can and have been able to “simulate” the behavior.

By: David

David — Sun, 11 Jun 2006 20:39:35 +0000

Douglas, I’m not sure what you mean by “everything”. Please explain.

You could keep a pointer to you local variables (if you were sure the callback were going to happen before they go away) or you could use the variables in the created structure instead of locals (this is what C folk tend to do in these cases).

By: Douglas

Douglas — Sat, 10 Jun 2006 12:13:16 +0000

The difference is the same as between “I want X, Y and Z” and “I want everything”.

If you only want X, Y and Z in the first place, that’s going to be fine, it will work in that limited case. But I don’t know how you’d express “everything” in C.

What you want is a pointer to the current scope, not a pointer to a copy of some of the variables from the current scope.

Douglas

By: David

David — Sat, 10 Jun 2006 10:07:00 +0000

But you see, that is my point. The “closing over itself” is just syntactic sugar.

C only supports 2 types of variables. Global variables and stack based local variables. Anything more than that is supported by the standard library—malloc, to be specific.

The point is that you have to hand hold C to get anything that lasts longer than a local stack variable but shorter than a global variable (which lasts forever).

By passing these user data pointers around with the function pointer itself, you are effectively passing around your local lexical environment—just the parts you care about.

Like you guys pointed out (and as I said in the article), it’s painful to do compared to a language with language level closures.

But that’s the way it is with C for practically everything! It’s the exact same concept as a closure, regardless of how much extra you have to do to implement it…

By: Ryan Davis

Ryan Davis — Sat, 10 Jun 2006 08:37:34 +0000

Thirded. Not even close to closures.

By: Blake Watters

Blake Watters — Sat, 10 Jun 2006 08:33:19 +0000

Those are just pointers to data. A closure has to ‘close over’ its lexical scope, restoring its state and scope at run time.

By: ratatask

ratatask — Sat, 10 Jun 2006 07:41:14 +0000

This isn’t really closure – you have to manually create the environment you want to capture (your struct) and make it have dynamic extent(stuff it at file scope or malloc it).

Extremly painful compared to languages with real closures.