（ 注意： 正如标签中已经清楚的那样，这是严格的 C ++ 03。 是的，我知道，lambda会让所有这些痛苦消失（并引入新的类型，我打赌），但这是一个嵌入式系统，具有90年代的操作系统版本，以及我被告知我应该很高兴我有一个C ++ 03编译器（GCC4.1.x，BTW）或C ++编译器。所以请不要发布C ++ 11解决方案。不需要揉搓，真的。
此外，std::bind()，std::function()等当然实际上在std::tr1，但我编辑了tr1前缀，因为我认为它主要只增加了噪音代码。）
我有一些类似服务器的东西，我需要注册函数，我需要调整它们来调用一些对象类似但略有不同的函数。这些函数具有不同的参数列表。服务器“知道”当我尝试注册一个函数时，它只接受一个具有正确签名的函数（正如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;}
};
这实际上是有效的，但实际上有更多的功能，这样做是一个繁琐的复制'''''''''''''''''''''''''I I I I I I I I I I I I I I I I I I I I I I由于所有这些函数完全相同，唯一的区别是它们调用的函数和它们拥有或不具有的参数，我应该能够将它们折叠成一个参数化函数，隐藏{{{ 1}}。如果做不到这一点，我决定首先为所有函数执行此操作，而不使用任何参数（如std::bind()），这是绝大多数。
所以我想通过单个函数foo()路由foo()的所有调用 - 就像X中的函数一样，这个函数执行繁琐的部分：
Y::call_it并将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_) );
玩了10个星期，所以请耐心等待我。）最后，我迷失在一片令人难以置信的迷人错误信息之中，这些错误信息来自于std::bind()的模板化的胆量，这些信息可以让一个成年男子流下眼泪，至少应该让他们的家庭萎缩一年。
所以在我kill myself out of sheer frustration和我的孩子孤儿之前 - 我怎么能这样做？
答案 0 :(得分：3)
根据我收集的内容，您希望使用Y::call_it()对象进行适当约束来调用std::function。假设您的内部函数使用不同数量的参数，则必须为传递其他参数的情况创建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);
}
答案 1 :(得分：1)
在聊天频道链接中，您似乎已将问题归结为嵌套绑定无法编译的事实：
bind( &Y::call_it, this, bind( &X::foo, ref(x_) ) )
因为编译器无法推断出内部bind（）的类型签名（在本例中为函数＆lt; bool（）＆gt;）。这可能会改为：
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。