struct X {int foo(int x) {std::cout << "X " << this << " foo x="<<x << std::endl;return x + 100;};
};

可以这样使用

    boost::function<int (X*, int)> mf;mf = &X::foo;X x;mf(&x, 5);

#include <boost/bind.hpp>

这样使用

    boost::function<int (int)> mbf;mbf = bind(&X::foo, &x, _1);mbf(10);

bind将x的指针保存在function对象中。

boost::factory<T*>()(arg1,arg2,arg3)
// same as new T(arg1,arg2,arg3)boost::value_factory<T>()(arg1,arg2,arg3)
// same as T(arg1,arg2,arg3)

使用function factory的原因

//声明接口
class Interface
{
public:virtual void print(int a) = 0; //接口函数
};
//声明抽象工厂
class Interface_Factory {
public:virtual Interface * create() = 0;
};

然后，我们有若干个实现

class ImplA : public Interface
{
public:virtual void print(int a) {std::cout << "== A ==  a=" << a << std::endl;}
};
//提供ImplA的类工厂
class ImplA_Factory : public Interface_Factory
{
public:Interface * create() { return new ImplA(); }static ImplA_Factory _implAFactory;
};
ImplA_Factory ImplA_Factory::_implAFactory;//同理,ImplB的实现class ImplB : public Interface
{
public:virtual void print(int a) {std::cout << "== B ==  a=" << a << std::endl;}
};
//提供ImplB的类工厂
class ImplB_Factory : public Interface_Factory
{
public:Interface * create() { return new ImplB(); }static ImplB_Factory _implBFactory;
};
ImplB_Factory ImplB_Factory::_implBFactory;

如果你要使用它，就需要这些写

std::map<std::string, Interface_Factory*> factories;int main()
{factories["A"] = &ImplA_Factory::_implAFactory;factories["B"] = &ImplB_Factory::_implBFactory;
.....
}

如果仔细观察下，就会发现，实际上，ImplA_Factory和ImplB_Factory的内容几乎都一样。但是却写了不少重复性的代码。factory就是解决该问题的。

typedef boost::function< I *() > I_factory; //替代Interface_Factory的定义

std::map<std::string, I_factory> factories;
....factories["A"] = boost::factory<ImplA*> ();  //等价于 &ImplA_Factory::_ImplAFactory;factories["B"] = boost::factory<ImplB*> (); //等价于 &ImplB_Factory::_ImplBFactory;

void run_interface(const char* name)
{I_factory factory = factories[name];if(!factory){   std::cout<<"factory " << name << " is not exist" << std::endl;return;}   I *i = factory();i->print(100);delete i;
}

    run_interface("A");run_interface("B");run_interface("C");

OverloadedFunction

考虑下面的代码

const std::string& identity_s(const std::string& x) // Function (as pointer).{ return x; }int identity_i_impl(int x) { return x; }
int (&identity_i)(int) = identity_i_impl; // Function reference.double identity_d_impl(double x) { return x; }
boost::function<double (double)> identity_d = identity_d_impl; // Functor.

在调用他们的时候，必须使用各自的函数名：identity_i, indentity_s, indentity_d; 例如

BOOST_TEST(identity_s("abc") == "abc");
BOOST_TEST(identity_i(123) == 123);
BOOST_TEST(identity_d(1.23) == 1.23);

但是，使用OverlaodedFunction，就可以使用统一的名字identity来调用了：

boost::overloaded_function<const std::string& (const std::string&), int (int), double (double)
> identity(identity_s, identity_i, identity_d);// All calls via single `identity` function.
BOOST_TEST(identity("abc") == "abc");
BOOST_TEST(identity(123) == 123);
BOOST_TEST(identity(1.23) == 1.23);