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

Вы можете создать оболочку для перевода между различными соглашениями о вызовах:

template<typename Func, Func* callback>
auto make_callback()
{
    return &detail::callback_maker<Func, callback>::call;
}

с callback_maker определенным как

template<typename T, T*>
struct callback_maker;

template<typename R, typename... Params, R(*Func)(Params...)>
struct callback_maker<R(Params...), Func>
{
    static R __stdcall call(Params... ps)
    {
        return Func(std::forward<Params>(ps)...);
    }
};

Это должно быть довольно общим решением, позволяющим указать прототип функции. Вы можете использовать его следующим образом:

//  external_api(&not_stdcall_func); // error
external_api(make_callback<void(int,int), &not_stdcall_func>());

демонстрация

Если указатель должен быть определен во время выполнения, вы можете сохранить обратный вызов в пользовательских данных. Вам нужно будет правильно управлять временем жизни, но вполне вероятно, что вам это уже нужно. Опять же, попытка универсального решения. Сделайте обратный вызов и сообщите ему, какой аргумент является указателем на пользовательские данные:

template<typename Callback, size_t N>
auto make_callback()
{
    using callback_maker = detail::callback_maker<Callback, N>;
    return &callback_maker::call;
}

С callback_maker определенным как

template<typename T, size_t N>
struct callback_maker;

template<typename R, typename... Params, size_t N>
struct callback_maker<R(*)(Params...), N>
{
    using function_type = R(Params...);

    static R __stdcall call(Params... ps)
    {
        void const* userData = get_nth_element<N>(ps...);
        auto p = static_cast<pair<function_type*, void*> const*>(userData);
        return p->first(ps...);
    }
};

и get_nth_element как

template<size_t N, typename First, typename... Ts>
decltype(auto) get_nth_element_impl(false_type, First&& f, Ts&&...);

template<size_t N, typename First, typename... Ts>
decltype(auto) get_nth_element_impl(true_type, First&&, Ts&&... ts)
{
    return get_nth_element_impl<N-1>(integral_constant<bool, (N > 1)>{}, forward<Ts>(ts)...);
}

template<size_t N, typename First, typename... Ts>
decltype(auto) get_nth_element_impl(false_type, First&& f, Ts&&...)
{
    return forward<First>(f);
}

template<size_t N, typename... Ts>
decltype(auto) get_nth_element(Ts&&... ts)
{
    return get_nth_element_impl<N>(integral_constant<bool, (N > 0)>{}, forward<Ts>(ts)...);
}

Теперь на сайте вызова

using callback_t = CTMuint(*)(const void *aBuf, CTMuint aCount, void *aUserData);
auto runtime_ptr = &not_stdcall_func;

pair<callback_t, void*> data;
data.first = runtime_ptr;
data.second = nullptr; // actual user data you wanted

auto callback = make_callback<callback_t, 2>();

ctmSaveCustom({}, callback, &data, nullptr);

демонстрация

По предложению Андрея Туркина можно заменить указатель пользовательских данных в списке параметров. Вместе с forward_as_tuple он устраняет необходимость в get_nth_element. Обновленная функция вызова:

static R __stdcall call(Params... ps)
{
    auto params_tuple = forward_as_tuple(ps...);
    void const* userData = get<N>(params_tuple);
    auto p = static_cast<pair<function_type*, void*> const*>(userData);
    get<N>(params_tuple) = p->second;
    return apply(p->first, move(params_tuple));
}

а вот упрощенная реализация apply С++ 17:

template<typename Func, typename T, size_t... Is>
decltype(auto) apply_impl(Func f, T&& t, index_sequence<Is...>)
{
    return f(get<Is>(t)...);
}

template<typename Func, typename... Ts>
decltype(auto) apply(Func f, tuple<Ts...>&& tup)
{
    return apply_impl(f, move(tup), index_sequence_for<Ts...>{});
}

демонстрация

В случае 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 - достаточно прост в использовании; con - нуждается в user_data для собственного использования; требует очень похожих сигнатур функций
• Используйте класс-оболочку, выделите экземпляр класса и передайте this в user_data. Pro — более универсальный, поскольку он может собирать некоторые данные в каждом экземпляре (например, он может хранить user_data для целевого обратного вызова или передавать дополнительные данные для целевого обратного вызова); con - необходимо управлять временем жизни экземпляра оболочки
• Создайте отдельные преобразователи для каждого отдельного целевого обратного вызова. 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);