C-style Callbacks in C++11

Question

In a C++11 project I'm using a C-style third-party library (curl in my case) which needs C-style callbacks.

To achieve this I used the "poiner-to-member" operator:

size_t c_callback_wrapper(char *ptr, size_t size, size_t nmemb, void *userdata)
{
    MyClass *p = (MyClass*)userdata;
    return (p->*&MyClass::actualCallback)(ptr, size, nmemb, userdata);
}


void Myclass::performSomething() {
    // register callback function
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, c_callback_wrapper);
    // register userdata
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, this);
    ...
    res = curl_easy_perform(curl);
}

This solution actually works, but it's not satisfying for me.

What I actually want to do is to write a lambda inside my registering function.

The advantage would be locality in general: I would be able to capture some local variables and there would be no need to write a complex "actualCallback" member routine.

I already read, that it seems not to be possible to use Lambdas as C-style Functions when they capture variables.

Are there any ways to achieve this using some tricks? (e.g. playing with the calling convention of lambdas, ...)

Thanks

Answer 1

A lambda that captures context variables cannot be converted to a bare function pointer because that would make it impossible to carry the captured state along. What you've shown in the example is the right way to go about dealing with the problem of invoking C++ member functions via a C callback.

You could replace c_callback_wrapper with a capture less lambda, if you find that any more appealing.

curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, 
                 [](char *ptr, size_t size, size_t nmemb, void *userdata) {
                    // invoke the member function via userdata
                    auto p = static_cast<MyClass *>(userdata);
                    return p->actualCallback(ptr, size, nmemb, userdata);
                 });

Note that you should probably get rid of the last parameter to the actualCallback() member function, since that is just the this pointer, which the non-static member function shouldn't need to be passed explicitly.

Answer 2

Here is what I would do (please note that I only know enough about C++ to blow off the occasional foot):

#include <iostream>
#include <functional>

void external_c_function(void cb(void *), void *userdata)
{
    cb(userdata);
}

void c_callback_wrapper(void *userdata)
{
    auto &lambda = *static_cast< std::function<void(void)>* >(userdata);
    std::cout << "calling lambda" << std::endl;
    lambda();
}

int main(void)
{
    int foo = 42;
    std::function<void(void)> lambda = [&] { std::cout << foo << std::endl; };
    external_c_function(c_callback_wrapper, &lambda);
    return 0;
}