如何使用 std：：bind 做到这一点？-解网

问：

(注意：从标签中应该已经清楚了，这是严格的 C++03。 是的，我知道，lambda 让所有这些痛苦都消失了（我敢打赌，并带来了新的种类），但这是一个嵌入式系统，具有 90 年代的操作系统版本，我被告知我应该很高兴我有一个 C++ 编译器（GCC4.1.x，顺便说一句），或者一个 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;}
};

这确实有效，但实际上还有更多的功能，并且将其作为繁琐的复制粘贴工作来做会侮辱我的尊严感并产生臭代码。由于所有这些函数的作用完全相同，唯一的区别是它们调用的函数以及它们有或没有传递的参数，因此我应该能够将它们折叠成一个参数化函数，将差异隐藏在后面。如果做不到这一点，我决定首先对没有任何参数的所有函数执行此操作（如），这是绝大多数。std::bind()foo()

因此，我想通过一个函数来路由所有类似函数的调用，该函数可以完成繁琐的部分：foo()XY::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()std::function

因此，在我因纯粹的挫败感而自杀并让我的孩子成为孤儿之前——我该怎么做呢？

C++ C++03 标准函数 stdbind

从我收集到的信息来看，您希望使用适当绑定的对象进行调用。鉴于内部函数采用不同数量的参数，因此有必要为传递其他参数的情况创建一个生成器。假设对象可以在注册时绑定，那么在没有其他参数的情况下注册成员函数非常简单：Y::call_it()std::functionstd::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))));
}

helper 函数创建一个绑定了附加参数的函数。请注意，被绑定的函数被构造为与寄存器函数预期的函数具有相同的类型：这是必要的，例如，创建一个采用附加的、被忽略的参数的函数。

下面是我用来查看东西是否编译的测试程序。我手头没有带有 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);
}

它肯定是使用 gcc 的编译器。尝试使用 clang 编译代码失败，因为似乎与我正在使用的 libcxx 版本有关。但是，尝试更改的声明以删除参数（这是我推断参数的尝试的遗留物，无论如何都是正确的类型。bind_argument()const&Arg0const&Arg0

0赞 sbi 12/27/2012

是的，我已经删除了，但这只会导致其他错误，这些错误同样让我感到困惑：和，加上另外两个，都涉及我的 std tr1 lib 的元组类的 Nil 类型。const&invalid initialization of reference of type 'std::string&' from expression of type 'std::tr1::_NullClass'cannot convert 'std::tr1::_NullClass' to 'int' in argument passing

0赞 sbi 1/18/2013

这有更多的麻烦，但最终，这就是我们让它工作的方式，所以我会接受你的回答。

1赞 arayq2 12/28/2012 #2

从聊天频道链接来看，您似乎已将问题归结为嵌套绑定无法编译的事实：

bind( &Y::call_it, this, bind( &X::foo, ref(x_) ) )

因为编译器无法推断内部 bind（）的类型签名（在本例中为 function< 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。

上一个：C# 中的泛型类型：将类型参数限制为集合

下一个：我可以在对象中存储对变量的引用吗？[复制]

如何使用 std：：bind 做到这一点？

How to do this with std::bind?

评论

评论