Изменение соглашения о вызовах

В случае с Visual C ++ (начиная с VC11) лямбда-выражения без состояния реализуют оператор преобразования для указания функций всех соглашений о вызовах.

Так этот, может работать так же хорошо

#include <iostream>
using namespace std;

int __cdecl foo()
{
return 2;
}

void bar (int (__stdcall *pFunc)() )
{
cout << pFunc()*2;
}

int main() {

bar([](){ return foo(); });

return 0;
}

Если обратный вызов не известен во время компиляции, у вас есть следующие опции:

• Используйте одну функцию-обертку и передайте целевой обратный вызов в user_data, Pro — достаточно прост в использовании; кон — потребности user_data для собственного использования; требует очень похожих функций подписей
• Используйте класс-оболочку, выделите экземпляр класса и передайте this в user_data, Pro — более универсально, так как он может захватывать некоторые данные в каждом случае (например, он может хранить user_data для целевого обратного вызова или передачи дополнительных данных целевому обратному вызову); con — необходимо управлять временем жизни экземпляра оболочки
• Создайте отдельные thunks для каждого отдельного целевого обратного вызова. Pro — не требует использования user_data; con — довольно низкоуровневый и довольно непереносимый (в обоих компиляторах в ОС); может быть трудно сделать; трудно сделать в С ++, не прибегая к сборке.

Первый вариант будет выглядеть примерно так (беззастенчиво срывая @krzaq):

template<typename T> struct callback_maker;
template<typename R, typename... Params> struct callback_maker<R(Params...)> {
static R __stdcall call_with_userdata_as_last_parameter(Params... ps, void* userData) {
R(__cdecl *Func)(Params...) = reinterpret_cast<R(__cdecl *)(Params...)>(userData);
return Func(std::forward<Params>(ps)...);
}
};
template<typename Func> constexpr auto make_callback() {
return &callback_maker<Func>::call_with_userdata_as_last_parameter;
}

...
extern void external_api(void(__stdcall*)(int,int,void*), void* userdata);
extern void __cdecl not_stdcall_func(int,int);
external_api(make_callback<void(int,int)>(), &not_stdcall_func);

Вероятно, не для вас, так как вам нужно userData для обоих обратных вызовов.

Второй вариант:

template<typename T> struct CallbackWrapper;
template<typename R, typename... Params> struct CallbackWrapper<R(Params...)> {
using stdcall_callback_t = R(__stdcall*)(Params..., void*);
using cdecl_callback_t = R(__cdecl*)(Params..., void*);
using MyType = CallbackWrapper<R(Params...)>;
CallbackWrapper(cdecl_callback_t target, void* target_userdata) : _target(target), _target_userdata(target_userdata) {}
stdcall_callback_t callback() const { return &MyType::callback_function; }
private:
static R __stdcall callback_function(Params... ps, void* userData) {
auto This = reinterpret_cast<MyType*>(userData);
return This->_target(std::forward<Params>(ps)..., This->_target_userdata);
}
cdecl_callback_t _target;
void* _target_userdata;
};

...
extern void external_api(void(__stdcall*)(int,int,void*), void* userdata);
extern void __cdecl not_stdcall_func(int,int, void*);

void * userdata_for_not_stdcall_func = nullptr;
CallbackWrapper<void(int, int)> wrapper(&not_stdcall_func, userdata_for_not_stdcall_func);
external_api(wrapper.callback(), &wrapper);
// make sure wrapper is alive for as long as external_api is using the callback!

Отвечая на себя, надеясь, что у кого-то есть более простое решение.
Подход такой же, как объяснено Вот.

Мы собираемся использовать следующее:

1. Беззастенчивые лямбды могут быть автоматически приведение к указателям на функции с любой желаемое соглашение о вызовах.
2. Функция C-API обеспечивает void* user_data способ передачи данных в обратный вызов.

Мы передадим C-API две лабмда:

1. Один из них приведен к правильному соглашению о вызовах;
2. Другой захватывает обратный вызов fn-ptr и передается как user_data в захваченную лямбду звонить. Захватывает и то и другое оригинальный обратный звонок а также оригинал user_data для внутреннего использования.

Вот код:

// This is a lambda that calls the (cdecl) callback via capture list
// However, you can't convert a non-captureless lambda to a function pointer
auto callback_trampoline = [&callback, &user_data](const void *aBuf, CTMuint aCount) -> CTMuint
{
return callback(aBuf, aCount, user_data);
};

using trampoline_type = decltype(callback_trampoline);

// so we create a capture-less wrapper which will get the lambda as the user data!
// this CAN be cast to a function pointer!
auto callback_wrapper_dispatcher = [](const void *aBuf, CTMuint aCount, void *aUserData) -> CTMuint
{
auto& lambda = *reinterpret_cast<trampoline_type*>(aUserData);
return lambda(aBuf, aCount);
};

ctmSaveCustom(context_, callback_wrapper_dispatcher, &callback_trampoline, nullptr);

Это безопасный тип и работает как положено.

Было бы здорово превратить это в универсальный инструмент, подобный тому, что предлагает @krzaq в ответе.

ОБНОВИТЬ:
Вот более простая формулировка с одной лямбдой без захвата, но с той же концепцией:

auto payload = std::tie(callback, user_data);
using payload_type = decltype(payload);
auto dispatcher = [](const void *aBuf, CTMuint aCount, void *aUserData)->CTMuint
{
// payload_type is visible to the captureless lamda
auto& payload = *reinterpret_cast<payload_type*>(aUserData);
return std::get<0>(payload)(aBuf, aCount, std::get<1>(payload));
};
ctmSaveCustom(context_, dispatcher, &payload, nullptr);