3

我有 2 个函数f()和g(). 我想每次都按顺序打电话给他们。我可以得到一个boost::function这样做吗？例如：

boost::function functor = boost::bind( boost::bind(f), boost::bind(g) );

进一步扩展，说它需要争论，那么我需要的是一个责任链。每个节点都用参数做一些事情，然后是链的下一个节点。我怎么做？

更新感谢赛斯卡内基的评论。我想我真正想要的是如何将责任链构建成一个单一boost::function的，链的每个节点都可以通过使用来构建boost::bind()。

4

3 回答 3

2

您是否考虑过使用boost::signal？

使用 boost::signal，您可以将多个函数调用合二为一。

#include <boost/signal.hpp> 
#include <iostream> 

void f() 
{ 
  std::cout << " Hello" << std::flush; 
} 

void g() 
{ 
  std::cout << " World" << std::endl; 
} 

int main() 
{ 
  boost::signal<void ()> s; 
  s.connect(f); 
  s.connect(g); 
  s(); 
}
于 2012-01-27T07:36:09.863 回答
1

为什么不这样呢？

#include <functional>

template <typename FirstFunctor, typename SecondFunctor>
void chainFunctionImpl(FirstFunctor first, SecondFunctor second)
{
   first();
   second();
}

template <typename FirstFunctor, typename SecondFunctor>
std::function<void(void)> chainFunction(FirstFunctor first, SecondFunctor second)
{
   return std::bind(chainFunctionImpl<FirstFunctor,SecondFunctor>,first,second);
}

使用应该比较简单，只是依次绑定函数，然后调用结果。理论上任何长度的函数都可以链接起来。

请注意，理论上也可以通过将参数传递到链中来做到这一点，但是模板 foo 的级别超出了我的范围。http://ideone.com/Xvp5U是我放弃的地方。

于 2012-01-27T05:51:12.397 回答
1

使用带有逗号运算符的 boost::lambda 有一个非常简单的解决方案。在我的情况下，我将它用于一个修改器函数，该函数被定义为（B 是一个任意类，例如，A 是一个应该改变但驻留在 B 中并且不应该出去的类）

void B::modify( boost::function<void(A&)> func );

我的意图是只将修改器传递给修改函数，这使得在修改它时更容易获得控制（例如用于发射信号）。

有时我想应用 2 修饰符：

void A::setInvalid();
void A::setX( int x );

调用 2 个步骤，这不是方式（仅作为参考显示我们希望如何使用 modify 方法）：

instanceA->modify( 
    boost::bind( &A::setInvalid, _1 );
instanceA->modify( 
    boost::bind( &A::setX, _1, 4 );

使用 boost::lambda 这可以连接到单个函数调用，因此只创建一个函数：

#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>

using namespace boost::lambda;
instanceA->modify(
    ( bind(&A::setInvalid, boost::lambda::_1)
    , bind(&A::setX, boost::lambda::_1, 4) ) );

与您的问题相关，这看起来会是：

using namespace boost::lambda;
boost::function<void()> func = ( bind(f), bind(g) )
于 2015-01-20T16:45:32.847 回答