C++ 如何将两个独立的boost:：bind（）组合成一个boost:：函数？

我有两个函数

f（）

和

g（）

。我想每次都按顺序给他们打电话。我可以使用

boost:：function

来执行此操作吗？ 例如，类似于：

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

进一步扩展，假设它需要争论，那么我需要的是一个责任链。每个节点都使用参数执行某些操作，然后是链的下一个节点。 我该怎么做

---

更新感谢赛斯·卡内基的评论。

---

我想我真正想要的是如何将责任链构建成一个单一的

boost:：function

，链的每个节点都可以通过使用

boost:：bind（）

来构建，为什么不这样呢

#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);
}

#包括
模板
void chainFunctionImpl（第一个函子，第二个函子）
{
第一个（）；
第二个（）；
}
模板
函数链函数（第一个函子，第二个函子）
{
返回std:：bind（chainFunctionImpl，first，second）；
}

使用应该相对简单，只需按顺序绑定函数，然后调用结果。理论上，任何长度的函数都可以链接起来

请注意，理论上也可以通过向下传递参数来实现这一点，但模板foo的级别远远超出了我的理解范围。是我放弃的地方。

你考虑过使用吗

使用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(); 
} 

#包括
#包括
void f（）
{ 
std:：cout使用boost:：lambda及其逗号运算符有一个非常简单的解决方案。在我的例子中，我将其用于一个修改器函数，该函数定义为（例如，B是的任意类，a是一个应该更改但驻留在B中且不应该超出B的类）

在两个步骤中调用，但这两个步骤都不是正确的方法（只是作为说明如何使用modify方法的参考）：

使用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) ) );

#包括
#包括
使用名称空间boost:：lambda；
instanceA->modify(
（绑定（&A:：setInvalid，boost:：lambda:：_1）
，绑定（&A:：setX，boost:：lambda:：_1，4））；

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

using namespace boost::lambda;
boost::function<void()> func = ( bind(f), bind(g) )

使用名称空间boost:：lambda；
函数func=（绑定（f），绑定（g））
bind
用于将参数绑定到函数，而不是将函数绑定到一个链中。您是指
f（g（x））
还是
f（x）；g（x）<代码> > Boo:：Boo/<代码>实际上不是正确的工具。也许<代码> Boost。信号< /代码>或<代码> BooSo.Simulals2<代码>？您所描述的与扭曲的延迟对象的语义相匹配。它的C++实现可能值得关注：@戴维RoDr Guez -DReBeas：我的意思是f（x）；g（x）。；这就是我添加独立模板的原因。对于模板foo，我的建议是避免使用函数模板，而选择实现静态函数的类模板。如果编译器支持变量模板，那么实现实际上非常简单。谢谢，但这不是我想要的。不简单谢谢，但这不是我想要的我想要，还不够简单
instanceA->modify( 
    boost::bind( &A::setInvalid, _1 );
instanceA->modify( 
    boost::bind( &A::setX, _1, 4 );

#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) )