如何用std :: bind做到这一点？
（ 注意：从标签中应该已经清楚了，这完全是C ++ 03。是的，我知道，lambda使所有这些痛苦消失（并且带来了新的种类，我敢打赌），但这是一个嵌入式系统，与从90年代的操作系统版本，我被告知我应该很高兴我有一个C ++ 03编译器（GCC4.1.x，顺便说一句），或者一个C ++编译器，所以请放弃发布C ++ 11解决方案，无需揉搓，真的。
当然， std::bind() ， std::function()等实际上在std::tr1 ，但是我编辑出了tr1前缀，因为我认为它大部分只会对代码添加噪声。）
我有一些服务器类的东西，我需要注册的功能，我需要调整它们来调用一些对象的相似但略有不同的功能。 这些函数有不同的参数列表。 服务器“知道”，当我尝试注册一个函数时，它只接受具有正确签名的std::function （正如std::function要求的那样），这取决于作为模板参数传入的某个魔术标记。
这是代码草图：
// this I just use
class server {
public:
template<unsigned int MagicTag>
bool register_call(typename some_traits_type<MagicTag>::func_type);
};
// this needs to be called from the server
class X {
public:
bool foo();
bool bar(std::string&);
bool baz(int);
};
// this is the glue
class Y {
public:
Y(X& x) : x_(x) {
register_call<MAGIC_FOO>(&Y::foo );
register_call<MAGIC_BAZ>(&Y::bar, _1);
register_call<MAGIC_FBZ>(&Y::baz, _1);
}
private:
X& x_;
template<unsigned int MagicTag, typename Function>
bool register_call(Function function) {
somewhere->register_call<MagicTag>(std::bind( function
, this ));
}
template<unsigned int MagicTag, typename Function, typename PlaceHolder1>
bool register_call(Function function, PlaceHolder1 place_holder1) {
somewhere->register_call<MagicTag>(std::bind( function
, this
, place_holder1 ));
}
int foo() {return x_.foo() ? MAGIC_OK : MAGIC_FAILED;}
int bar(std::string& s) {return x_.bar(s) ? MAGIC_OK : MAGIC_FAILED;}
int baz(int i) {return x_.baz(i) ? MAGIC_OK : MAGIC_FAILED;}
};
这实际上是有效的，但实际上有更多的功能，并且做这种繁琐的复制和努力会损害我的尊严感并产生臭味的代码。 由于所有这些函数的功能完全相同，唯一的区别是它们调用的函数以及它们有或没有要传递的参数，所以我应该能够将它们折叠成一个参数化函数，从而隐藏std::bind()后面的差异std::bind() 。 如果没有这个，我首先对所有没有任何参数的函数（如在foo() ）中这样做，这是绝大多数。
所以我想通过一个单独的函数Y::call_it将X类foo()函数的所有调用路由到这个单调函数中：
int call_it(std::function<bool()> f) {return f() ? MAGIC_OK : MAGIC_FAILED;}
并将X的适当函数作为参数绑定到它：
register_call<MAGIC_FOO>(&X::foo); // note the X!
// (this is wrong)
somewhere->register_call<MagicCode>( std::bind( std::bind( &Y::call_it
, this
, function )
, std::ref(x_) );
显然，这是错误的，我所有的其他尝试都是为了解决这个问题。 （我现在只玩了std::bind() 10周，所以请耐心等待）。 最后，我迷失在一个令人难以置信的迷宫中，这些迷人的错误信息来自std::function的模板化内脏，可以让一个成年男子流下眼泪，至少应该让他的家庭缩水一年。
所以，在我因为绝望而孤儿并孤儿我的孩子之前自杀 - 我该怎么做？
从我收集的内容来看，你想用一个适当绑定的std::function对象来调用Y::call_it() 。 考虑到你的内部函数有不同数量的参数，有必要为传递附加参数的情况创建一个std::function<bool()>生成器。 假设X对象可以在注册时绑定，那么注册一个没有附加参数的成员函数是直接的：
template <int Magic, typename RC>
void register_call(RC (X::*member)()) {
somewhere->register_call<Magic>(
std::bind(&Y::call_it, this,
std::function<bool()>(std::bind(member,
std::ref(this->x_)))));
}
当传递一个或多个参数时，必须在调用时创建一个std::function<bool()>对象，因为需要绑定附加参数。 我不认为这可以在没有辅助函数的情况下完成，但可以通过每个参数数量的一个辅助函数完成：
template <typename RC, typename Arg0>
static std::function<bool()>
bind_argument(RC (X::*member)(Arg0), X& x, Arg0 const& arg0) {
return std::bind(member, std::ref(x), arg0);
}
template <int Magic, typename RC,
typename Arg0, typename PlaceHolder>
void register_call(RC (X::*member)(Arg0), PlaceHolder pc) {
somewhere->register_call<Magic>(
typename some_traits_type<Magic>::type(
std::bind(&Y::call_it, this,
std::bind(&bind_argument<RC, Arg0>, member,
std::ref(this->x_), pc))));
}
辅助函数创建一个函数，并绑定一个附加参数。 请注意，被绑定的函数被构造为与寄存器函数期望的函数类型相同：这是必要的，例如，创建一个带有额外的被忽略参数的函数。
以下是我用来查看是否编译的测试程序。 我手边没有带有TR1的C ++ 2003编译器，并用C ++ 2011编译器编译了代码。 但是，我不认为我已经使用了C ++ 2011扩展，它不能从C ++ 2003和TR1中获得。
#include <functional>
enum {
MAGIC_OK,
MAGIC_FAILED,
MAGIC_FOO,
MAGIC_BAR,
MAGIC_FBZ,
MAGIC_BAZ
};
template <int> struct server_traits;
template <> struct server_traits<MAGIC_FOO> {
typedef std::function<bool()> type;
};
template <> struct server_traits<MAGIC_BAR> {
typedef std::function<bool(std::string&)> type;
};
template <> struct server_traits<MAGIC_FBZ> {
typedef std::function<bool(long)> type;
};
template <> struct server_traits<MAGIC_BAZ> {
typedef std::function<bool(std::string, long)> type;
};
// this I just use
class server {
public:
template<unsigned int MagicTag>
bool register_call(typename server_traits<MagicTag>::type) {
return true;
}
};
server s;
server* somewhere = &s;
// this needs to be called from the server
class X {
public:
bool foo() { return true; }
bool bar(std::string&) { return true; }
bool baz(int) { return true; }
};
// this is the glue
class Y {
public:
Y(X& x) : x_(x) {
register_call<MAGIC_FOO>(&X::foo );
register_call<MAGIC_BAR>(&X::bar, std::placeholders::_1);
register_call<MAGIC_FBZ>(&X::baz, std::placeholders::_1);
register_call<MAGIC_BAZ>(&X::baz, std::placeholders::_2);
}
private:
X& x_;
int call_it(std::function<bool()> f) {
return f() ? MAGIC_OK : MAGIC_FAILED;
}
template <int Magic, typename RC>
void register_call(RC (X::*member)()) {
somewhere->register_call<Magic>(
std::bind(&Y::call_it, this,
std::function<bool()>(std::bind(member,
std::ref(this->x_)))));
}
template <typename RC, typename Arg0>
static std::function<bool()>
bind_argument(RC (X::*member)(Arg0), X& x, Arg0 const& arg0) {
return std::bind(member, std::ref(x), arg0);
}
template <int Magic, typename RC,
typename Arg0, typename PlaceHolder>
void register_call(RC (X::*member)(Arg0), PlaceHolder pc) {
somewhere->register_call<Magic>(
typename server_traits<Magic>::type(
std::bind(&Y::call_it, this,
std::bind(&bind_argument<RC, Arg0>, member,
std::ref(this->x_), pc))));
}
};
int main()
{
X x;
Y y(x);
}
从聊天频道链接看来，您已将问题归结为嵌套绑定无法编译的事实：
bind( &Y::call_it, this, bind( &X::foo, ref(x_) ) )
因为编译器无法推导内部bind（）的类型签名（在这种情况下，作为函数<bool（）>）。 这可能会起作用：
bind( &Y::call_it, this, function<bool()>( bind( &X::foo, ref(x_) ) ) )
如果是这样，你会有类似的东西
template<unsigned int MagicTag, typename Function >
bool register_call(Function func) {
somewhere->register_call<MagicTag>(
bind( &Y::call_it, this, function<bool()>( bind( func, ref(x_)))));
}
尽管我觉得第二个模板参数可能不是必要的。 关键的想法是在两个std :: bind之间放置一个std :: function。
链接地址: http://www.djcxy.com/p/67959.html