10

我有一个需要回调函数的第 3 方 C API 。 我的代码有一个外部提供的回调函数。__stdcall
__cdecl

我无法将函数指针传递给 C-API，因为它们被认为是不同的类型。
绕过类型系统并使用reinterpret_cast<>自然会导致运行时错误。

这是这里的一个例子：

// C-API
// the stdcall function pointer type:
typedef CTMuint(__stdcall *CTMwritefn)(const void *aBuf, CTMuint aCount, void *aUserData);

// A function needing the callback: 
CTMEXPORT void __stdcall ctmSaveCustom(CTMcontext aContext, CTMwritefn aWriteFn, void *aUserData, int *newvertexindex);
                                                            ^^^^^^^^^^^^^^^^^^^

//////////////////////////////////////////////////////////////////////////////

// C++
CTMuint __cdecl my_func(const void *aBuf, CTMuint aCount, void *aUserData);

// I want to call here:
ctmSaveCustom(context, my_func, &my_data, nullptr);
//                     ^^^^^^^

有没有一种方法可以安全地将具有一个调用约定的函数转换和/或包装到另一个？

我确实找到了一种方法，方法是传递一个调用第二个捕获 lambda 的强制转换的无捕获 lambda。第一个作为回调传递，第二个通过void* user_data. 这有效并且是类型安全的。但是对于看起来如此简单的事情来说，它是相当令人费解的。

4

4 回答 4

11

您可以为不同调用约定之间的转换制作一个包装器：

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);

演示

根据 Andrey Turkin 的建议，您可以替换参数列表中的用户数据指针。同时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));
}

这是 C++17 的简单实现apply：

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...>{});
}

演示

于 2016-10-30T07:31:32.557 回答
4

在 Visual c++（从 VC11 开始）的情况下，无状态 lambda 实现了一个转换运算符到所有调用约定的函数指针。

所以这个，也可以正常工作

#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;
}
于 2016-10-30T07:44:15.963 回答
4

如果在编译时回调未知，您有以下选项：

  • 使用单个包装函数并在user_data. Pro - 相当容易使用；con -user_data自用需求；需要非常相似的函数签名
  • 使用包装类，分配类的实例并传入this. user_dataPro - 更通用，因为它可以在每个实例中捕获一些数据（例如，它可以存储user_data目标回调或将附加数据传递给目标回调）；con - 需要管理包装器实例的生命周期
  • 为每个不同的目标回调构建单独的 thunk。Pro - 不需要使用user_data; con - 相当低级且相当不可移植（在操作系统中的两个编译器中）；可能很难做到；如果不求助于汇编，很难在 C++ 中完成。

第一个选项看起来像这样（无耻地扯掉@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!
于 2016-10-30T08:39:45.910 回答
3

回答自己，希望有人有更简单的解决方案。该方法与此处
说明的相同。

我们将使用以下内容：

  1. 无捕获的lambda 可以自动转换为具有任何所需调用约定的函数指针。
  2. C-API 函数提供了void* user_data一种将数据传递给回调的方法。

我们将通过 C-API 两个 labmda：

  1. 一种是无捕获强制转换为正确的调用约定；
  2. 另一个捕获回调 fn-ptr 并作为 传递user_data给要调用的无捕获 lambda。它捕获原始回调和原始回调以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 答案中建议的通用工具会很酷。

更新：
这是一个更简单的公式，只有一个无捕获 lambda，但概念相同：

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);
于 2016-10-30T08:33:26.937 回答