C++ 将 std::bind 转换为函数指针
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/13238050/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
convert std::bind to function pointer
提问by Nico Schertler
I have a third-party library which has a method that takes a function pointer as the first parameter:
我有一个第三方库，它有一个将函数指针作为第一个参数的方法：
int third_party_method(void (*func)(double*, double*, int, int, double*), ...);
I want to pass a pointer to a class' method that is declared as follows:
我想传递一个指向类方法的指针，该方法声明如下：
class TestClass
{
public:
void myFunction (double*, double*, int, int, void*);
I tried to pass this function as follows:
我尝试按如下方式传递此函数：
TestClass* tc = new TestClass();
using namespace std::placeholders;
third_party_method(std::bind(&TestClass::myFunction, tc, _1, _2, _3, _4, _5), ...);
However, this does not compile:
但是，这不会编译：
Conversion of parameter 1 from 'std::tr1::_Bind<_Result_type,_Ret,_BindN>' to 'void (__cdecl *)(double *,double *,int,int,void *)' is not possible
with
[
_Result_type=void,
_Ret=void,
_BindN=std::tr1::_Bind6<std::tr1::_Callable_pmf<void (__thiscall TestClass::* const )(double *,double *,int,int,void *),TestClass,false>,TestClass *,std::tr1::_Ph<1>,std::tr1::_Ph<2>,std::tr1::_Ph<3>,std::tr1::_Ph<4>,std::tr1::_Ph<5>>
]
Is there any way I can pass the member to the function?
有什么办法可以将成员传递给函数吗？
采纳答案by Evgeny Panasyuk
Is there any way I can pass the member to the function?
有什么办法可以将成员传递给函数吗？
Unless your class object is some kind of global object - it is not possible. Because objects may contain some data, while function pointer is just pointer to function - it doesn't contain any runtime context, only compile-time one.
除非您的类对象是某种全局对象 - 这是不可能的。因为对象可能包含一些数据，而函数指针只是指向函数的指针——它不包含任何运行时上下文，只包含编译时上下文。
If you accept having compile-time unique IDs for each callback passing, then you can use following generalized approach.
如果您接受每个回调传递具有编译时唯一 ID，那么您可以使用以下通用方法。
Usage:
用法：
void test(void (*fptr)())
{
fptr();
}
struct SomeStruct
{
int data;
void some_method()
{
cout << data << endl;
}
void another_method()
{
cout << -data << endl;
}
};
int main()
{
SomeStruct local[] = { {11}, {22}, {33} };
test(get_wrapper<0>( boost::bind(&SomeStruct::some_method,local[0]) ));
test(get_wrapper<1>( boost::bind(&SomeStruct::another_method,local[0]) ));
test(get_wrapper<2>( boost::bind(&SomeStruct::some_method,local[1]) ));
test(get_wrapper<3>( boost::bind(&SomeStruct::another_method,local[1]) ));
test(get_wrapper<4>( boost::bind(&SomeStruct::some_method,local[2]) ));
test(get_wrapper<5>( boost::bind(&SomeStruct::another_method,local[2]) ));
}
It may not require Unique ID's for each invocation, for instance because Functors may already have different types, or runtime scope of their usage do not overlap. But it is safer to use unique ID each time.
它可能不需要每个调用的唯一 ID，例如因为 Functor 可能已经有不同的类型，或者它们使用的运行时范围不重叠。但每次使用唯一 ID 更安全。
Implementation:
执行：
#include <boost/optional.hpp>
#include <boost/bind.hpp>
#include <iostream>
#include <ostream>
using namespace std;
template<unsigned ID,typename Functor>
boost::optional<Functor> &get_local()
{
static boost::optional<Functor> local;
return local;
}
template<unsigned ID,typename Functor>
typename Functor::result_type wrapper()
{
return get_local<ID,Functor>().get()();
}
template<typename ReturnType>
struct Func
{
typedef ReturnType (*type)();
};
template<unsigned ID,typename Functor>
typename Func<typename Functor::result_type>::type get_wrapper(Functor f)
{
(get_local<ID,Functor>()) = f;
return wrapper<ID,Functor>;
}
// ----------------------------------------------------------------------
void test(void (*fptr)())
{
fptr();
}
struct SomeStruct
{
int data;
void some_method()
{
cout << data << endl;
}
void another_method()
{
cout << -data << endl;
}
};
int main()
{
SomeStruct local[] = { {11}, {22}, {33} };
test(get_wrapper<0>( boost::bind(&SomeStruct::some_method,local[0]) ));
test(get_wrapper<1>( boost::bind(&SomeStruct::another_method,local[0]) ));
test(get_wrapper<2>( boost::bind(&SomeStruct::some_method,local[1]) ));
test(get_wrapper<3>( boost::bind(&SomeStruct::another_method,local[1]) ));
test(get_wrapper<4>( boost::bind(&SomeStruct::some_method,local[2]) ));
test(get_wrapper<5>( boost::bind(&SomeStruct::another_method,local[2]) ));
}
P.S. Beaware of multi-thread access - in such cases you should use some kind of Thread-local storagedata.
PS 注意多线程访问 - 在这种情况下，您应该使用某种线程本地存储数据。
回答by Rost
As other people mentioned you have no choice but to use global or static data to provide bind call context as raw function. But provided solution is not general, it's stuck with empty parameter list of functor. You will need to write manually wrapper, get_wrapperand Funcfor each different function signature you want to bind and give them different names.
正如其他人提到的，您别无选择，只能使用全局或静态数据来提供绑定调用上下文作为原始函数。但是提供的解决方案并不通用，它被函子的空参数列表卡住了。您将需要手动编写wrapper，get_wrapper并Func为每个不同的函数签名绑定并赋予它们不同的名称。
I would like to propose more generalized solution for raw bind:
我想为原始绑定提出更通用的解决方案：
#include <iostream>
#include <memory>
#include <functional>
#include <cassert>
// Raw Bind - simulating auto storage behavior for static storage data
template <typename BindFunctor, typename FuncWrapper> class scoped_raw_bind
{
public:
typedef scoped_raw_bind<BindFunctor, FuncWrapper> this_type;
// Make it Move-Constructible only
scoped_raw_bind(const this_type&) = delete;
this_type& operator=(const this_type&) = delete;
this_type& operator=(this_type&& rhs) = delete;
scoped_raw_bind(this_type&& rhs): m_owning(rhs.m_owning)
{
rhs.m_owning = false;
}
scoped_raw_bind(BindFunctor b): m_owning(false)
{
// Precondition - check that we don't override static data for another raw bind instance
if(get_bind_ptr() != nullptr)
{
assert(false);
return;
}
// Smart pointer is required because bind expression is copy-constructible but not copy-assignable
get_bind_ptr().reset(new BindFunctor(b));
m_owning = true;
}
~scoped_raw_bind()
{
if(m_owning)
{
assert(get_bind_ptr() != nullptr);
get_bind_ptr().reset();
}
}
decltype(&FuncWrapper::call) get_raw_ptr()
{
return &FuncWrapper::call;
}
static BindFunctor& get_bind()
{
return *get_bind_ptr();
}
private:
bool m_owning;
static std::unique_ptr<BindFunctor>& get_bind_ptr()
{
static std::unique_ptr<BindFunctor> s_funcPtr;
return s_funcPtr;
}
};
// Handy macro for creating raw bind object
// W is target function wrapper, B is source bind expression
#define RAW_BIND(W,B) std::move(scoped_raw_bind<decltype(B), W<decltype(B), __COUNTER__>>(B));
// Usage
///////////////////////////////////////////////////////////////////////////
// Target raw function signature
typedef void (*TargetFuncPtr)(double, int, const char*);
// Function that need to be called via bind
void f(double d, int i, const char* s1, const char* s2)
{
std::cout << "f(" << d << ", " << i << ", " << s1 << ", " << s2 << ")" << std::endl;
}
// Wrapper for bound function
// id is required to generate unique type with static data for
// each raw bind instantiation.
// THE ONLY THING THAT YOU NEED TO WRITE MANUALLY!
template <typename BindFunc, int id = 0> struct fWrapper
{
static void call(double d, int i, const char* s)
{
scoped_raw_bind<BindFunc, fWrapper<BindFunc, id>>::get_bind()(d, i, s);
}
};
int main()
{
using namespace std::placeholders;
auto rf1 = RAW_BIND(fWrapper, std::bind(&f, _1, _2, _3, "This is f trail - 1"));
TargetFuncPtr f1 = rf1.get_raw_ptr();
f1(1.2345, 42, "f1: Bind! Bind!");
auto rf2 = RAW_BIND(fWrapper, std::bind(&f, _1, _2, _3, "This is f trail - 2"));
TargetFuncPtr f2 = rf2.get_raw_ptr();
f2(10.2345, 420, "f2: Bind! Bind!");
auto rf3 = RAW_BIND(fWrapper, std::bind(&f, _1, _2, _3, "This is f trail - 3"));
TargetFuncPtr f3 = rf3.get_raw_ptr();
f3(100.2345, 4200, "f3: Bind! Bind!");
}
It was tested - see Live Action Here
它已经过测试 - 请参阅此处的实时操作
回答by John Dibling
It doesn't compile because the third-party function is expecting a pointer-to-function, but you are trying to pass it a pointer-to-member-function. The two types are fundamentally different, and cannot be interchanged. In fact, pointers-to-member-functions are very often strange animals.
它无法编译，因为第三方函数需要一个指向函数的指针，但您正试图向它传递一个指向成员函数的指针。这两种类型根本不同，不能互换。事实上，指向成员函数的指针常常是奇怪的动物。
Here's an SSCCEillustrating the problem you're having:
这是一个SSCCE，说明了您遇到的问题：
#include <iostream>
#include <iomanip>
using namespace std;
typedef void(*SpeakFn)(void);
void Bark()
{
cout << "WOOF" << endl;
}
void Meow()
{
cout << "meeow" << endl;
}
void SpeakUsing(SpeakFn fn)
{
fn();
}
class Alligator
{
public:
void Speak()
{
cout << "YAWWW" << endl;
}
typedef void(Alligator::*AlligatorSpeakFn)(void);
void SpeakUsing(AlligatorSpeakFn fn)
{
(this->*fn)();
}
};
int main()
{
SpeakUsing(&Bark); // OK
Alligator a;
Alligator::AlligatorSpeakFn mem_fn = &Alligator::Speak;
a.SpeakUsing(mem_fn); // OK
SpeakUsing(mem_fn); // NOT OK -- can't cvt from fn-ptr to mem-fn-ptr
}
You can't call SpeakUsingwith a pointer-to-member-function because it's not convertible to pointer-to-function.
您不能SpeakUsing使用指向成员函数的指针进行调用，因为它不能转换为指向函数的指针。
Use a static member function instead, such as:
改用静态成员函数，例如：
class Alligator
{
public:
static void Speak()
{
cout << "YAWWW" << endl;
}
typedef void(*AlligatorSpeakFn)(void);
void SpeakUsing(AlligatorSpeakFn fn)
{
fn();
}
};
回答by Yakk - Adam Nevraumont
No, not easily. The problem is that a function pointer has one chunk of info - the address of the function. A method needs both that and the address of the object, or alternatively it could be passed the objects address as a parameter.
不，不容易。问题是函数指针有一大块信息——函数的地址。一个方法需要它和对象的地址，或者可以将对象地址作为参数传递。
There are extremely hackey ways to do this, but they are going to be platform specific. And extremely hackey. So much so that I will recommend global variables instead of using them.
有很多非常黑客的方法可以做到这一点，但它们将是特定于平台的。而且非常hackey。如此之多以至于我将推荐全局变量而不是使用它们。
You do know how to do this if there is a single global instance of the class, right?
如果该类只有一个全局实例，您确实知道如何执行此操作，对吗？
