改变呼叫习惯
Changing Calling Convention
我有一个第三方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调用第二个捕获lambda。第一个作为回调传递,第二个通过void* user_data
传递。这是有效的,并且是类型安全的。但是对于一个看起来很简单的东西来说,这是相当复杂的。
您可以创建一个包装器,用于在不同的调用约定之间进行转换:
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(¬_stdcall_func); // error
external_api(make_callback<void(int,int), ¬_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...);
}
};
and 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 = ¬_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...>{});
}
演示对于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;
}
如果在编译时不知道回调,您有以下选项:
- 在
user_data
中使用单个包装函数并传递目标回调。亲-相当容易使用;con -需要user_data
供自己使用;需要非常相似的函数签名 - 使用包装类,分配类的实例,并在
user_data
中传递this
。Pro -更多功能,因为它可以在每个实例中捕获一些数据(例如,它可以为目标回调存储user_data
或将额外的数据传递给目标回调);需要管理包装器实例生命周期 - 为每个不同的目标回调构建单独的thks。Pro -不需要使用
user_data
;con -相当低级和相当不可移植(在两个OS的编译器中);可能很难做到;
第一个选项看起来像这样(无耻地剽窃@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)>(), ¬_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(¬_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!
我自己回答,希望有人有更简单的解决方案。
方法与这里解释的相同。
我们将使用以下语句:
- 可通过任意所需的调用约定自动转换为函数指针。
- C-API函数提供了一种
void* user_data
方式来传递数据给回调。
- 一个是无捕获转换到正确的调用约定;
- 另一个捕获回调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);
- 呼叫运营商<<临时
- 复制和交换习惯用法与移动操作之间的交互
- 命名参数习惯用法和(抽象)基类
- C++ 命名参数习惯用语 - 未设置字符串属性
- 在解决链表问题时创建一个额外的节点是一个好习惯吗?
- 使用完数据结构后清空数据结构是一个好习惯吗?
- 呼叫 QSound,它们之间有延迟 Qt C++
- 什么是呼叫说明
- 复制交换习惯用法-我们可以在这里使用动态强制转换操作吗
- 错误:使用复制和交换习惯用法的交换函数中"operator="的重载不明确
- 为什么make_shared在不同的呼叫中分配相同的地址?
- 检测习惯用语和默认参数类型匹配
- 错误:类型"std::__1::basic_string<char>"不提供呼叫运算符
- 设备IO控制呼叫崩溃
- 根据呼叫位置进行记忆
- 成员呼叫通过接线员<<
- 如何在检测习惯用语中要求精确的功能签名?
- QSerialPort 手动 RTS 开/关未同步呼叫
- 将清除共享智能指针上的呼叫重置
- 改变呼叫习惯