C-ifying a capturing lambda

There's an existing technique which is not dissimilar referred to as "exception vomiting". Observe:

void f(void(*p)()) {
    p();
}
template<typename F> void real_f(F func) {
    try {
        throw func;
    } catch(...) {
        f([] {
            try {
                throw;
            } catch(F func) {
                func();
            }
        });
    }
}

This abuses the fact that the compiler must provide a thread-local stack for complex objects for use as exception storage, regardless of their support for other thread local features, and therefore enjoys much broad compiler support. The most obvious drawbacks are a) it's horrible, and b) it's limited to stack semantics.

You could consider a less terrible version as follows assuming the relevant compiler support:

template<typename F> void real_f(F func) {
    thread_local std::vector<std::function<void()>> funcs;
    funcs.push_back(func);
    f([] { funcs.back()(); });
    funcs.pop_back();
}

Your cify function is nothing more than real_f as posted here, but a bit more generic and a lot less reliable as you can't handle multiple instances properly even with the use of __COUNTER__.

The general case cannot be solved without the use of a JIT to create new functions at runtime.

This is clever, but it does not work in the general case. The problem is that it requires cify to have a different template instantiation for every distinct value of the lambda that it wraps, but in reality it will only get a different instantiation for every distinct type of lambda. So if you cify two lambdas with the same type but different values of captured variables, the second cify will clobber the captured variables from the first cify. You have the I template parameter to try to work around this, but that only works if you know at compile time exactly how many times cify will be called.

For example, consider the following code:

std::vector<void(*)()> callbacks;

void add_callback (int x)
{
        callbacks.emplace_back(cify<void(*)()>([x] () { std::cout << x; }));
}

int main ()
{
        add_callback(1);
        add_callback(2);

        for (auto& callback : callbacks) {
                callback();
        }
        return 0;
}

Instead of printing 12 as desired, it will print 22, because cify only gets instantiated once. And since you can't, in general, know at compile time how many times cify will be called, you can't use I to force distinct instantiations.

EDIT: __COUNTER__ doesn't solve the problem that you need to know at compile time how many times cify will be called. For example, the following does not work as expected:

std::vector<void(*)()> callbacks;
int x;
while (std::cin >> x) {
        callbacks.emplace_back(cify<void(*)(), __COUNTER__>([x] () { std::cout << x; }));
}
for (auto& callback : callbacks) {
        callback();
}

Every call to cify will clobber the previously captured values. And you can't unroll the loop to get distinct __COUNTER__ values because you don't know at compile time how many iterations the loop will execute.