Boost.Bind为函数和函数对象，值语义和指针提供语义了一致的语法。我们首先通过一些简单的例子来看看它的基本用法，之后我们会延伸到嵌套绑定以实现功能组合。理解bind用法的一个关键是理解占位符（placeholder）的概念。占位符表示该参数将在函数对象里面提供。Boost.Bind提供多达9个这样的参数--_1, _2, _3, _4, _5,_6,_7,_8, _9.你可以在想要加入参数的地方使用它们。在第一个示例程序中，我们定义一个函数"nine_arguments",之后用bind表达式调用它。
#include <IOSTREAM>
#include boost/bind.hpp
void nine_arguments（
int i1,int i2,int i3,int i4,
int i5,int i6,int i7,int i8, int i9） {
std::cout 《 i1 《 i2 《 i3 《 i4 《 i5
《 i6 《 i7 《 i8 《 i9 《 '
';
}
int main（） {
int i1=1,i2=2,i3=3,i4=4,i5=5,i6=6,i7=7,i8=8,i9=9;
（boost::bind（&nine_arguments,_9,_2,_1,_6,_3,_8,_4,_5,_7））
（i1,i2,i3,i4,i5,i6,i7,i8,i9）；
}</IOSTREAM>
在这个程序中，你可以创建临时的匿名绑定器并且立即传参调用。如你所见，占位符的顺序是在本例中是混乱的，这使得参数的顺序也被打乱。另外，占位符可以在表达式中重复使用。示例程序1的输出是 www.lefeng123.com
921638457
占位符的序数与参数的位置是对应的，也就是说，_1被换为第一个参数，_2被换为第二个参数，以此类推。
#include <IOSTREAM>
#include <BOOST bind.hpp="">
void PlaceholderTest（int a, int b, int c）
{
std::cout 《 a 《 b 《 c 《 std::endl;
}
int main（）
{
int a = 1, b = 2, c = 3;
//（boost::bind（&PlaceholderTest, _1, _2））（a, b）； //error
//（boost::bind（&PlaceholderTest, _1, _2, _1, _3））（a, b, c）； //error
//（boost::bind（&PlaceholderTest, _1, _2, _3））（a, b）； //error
（boost::bind（&PlaceholderTest, _1, _2, _1））（a, b）； //OK,output:121
（boost::bind（&PlaceholderTest, 99, _2, _1））（a, b） //OK,output:9921
} </BOOST></IOSTREAM>
总结 www.jamo123.com
1、参数占位符数量与函数形参数量必须一致
2、占位符的替代值可以少于占位符数量
3、占位符和实参可以混合使用
翻译：调用成员函数（1）
我们看看如何使用bind调用类的成员函数。首先我们也从一个可以由标准库完成的操作开始，这样方便我们对比标准库调用和Boost.Bind调用。当我们在标准库容器类类型中存储元素时，通常需要对部分或所有元素调用成员函数。通常的实现方法是，将这些操作可以放在一个循环中。但是现在有更好的解决办法。观察如下的简单类--status.我们之后将用它来展示Boost.Bind的简单易用和强大之处。
class status {
std::string name_;
bool ok_;
public:
status（const std::string& name）：name_（name），ok_（true） {}
void break_it（） {
ok_=false;
}
bool is_broken（） const {
return ok_;
}
void report（） const {
std::cout 《 name_ 《 is 《
（ok_ ? working nominally:terribly broken） 《 '
';
}
};
如果我们将这个类的实例储存在vector中，当我们需要调用成员函数report时，大概要遵循以下步骤
std::vector<STATUS> statuses;
statuses.push_back（status（status 1））；
statuses.push_back（status（status 2））；
statuses.push_back（status（status 3））；
statuses.push_back（status（status 4））；
statuses[1].break_it（）；
statuses[2].break_it（）；
for （std::vector<STATUS>::iterator it=statuses.begin（）；
it!=statuses.end（）；++it） {
it->report（）；
}</STATUS></STATUS>
for循环能够正确完成操作，但是它冗长、低效（每次都要检查statuses.end（）），还不如使用标准库中专为这种操作设计的for_each算法来的清楚。为了使用for_each替代for循环，我们需要为vector元素调用成员函数report配置一个适配器。在这个实例中，由于元素是值存储的，我们需要的是mem_fun_ref适配器 www.yztrans.com
std::for_each（
statuses.begin（），
statuses.end（），
std::mem_fun_ref（&status::report））；
这是一种更好的办法--它是如此简洁，不会对代码的作用产生任何迷惑和误解。Boost.Bind中的等效代码如下：
std::for_each（
statuses.begin（），
statuses.end（），
boost::bind（&status::report,_1））；
bind版本仍然清晰明了。这是我们第一次真正使用上面提及的Bind库占位符，它向编译器和代码阅读者传递了这样一个信息，_1将在调用绑定器的函数中被实参替换。尽管这段代码长度减少了，但在本例中，它与使用标准库mem_fun_ref几乎没有差别。
#include <IOSTREAM>
#include <STRING>
#include <VECTOR>
#include
#include <BOOST bind.hpp="">
class Status
{
public:
Status（const std::string &name） : name_（name）， ok_（true）{}
void BreakIt（）
{
ok_ = false;
}
bool IsBroken（） const
{
return ok_;
}
void Report（） const
{
std::cout 《 name_ 《 is 《 （ok_ ? ok : broken） 《 std::endl;
}
private:
std::string name_;
bool ok_;
};
int main（）
{
std::vector<STATUS> v_status;
v_status.push_back（Status（status 1））；
v_status.push_back（Status（status 2））；
v_status.push_back（Status（status 3））；
v_status.push_back（Status（status 4））；
v_status[1].BreakIt（）；
v_status[2].BreakIt（）；
std::cout 《 use or: 《 std::endl;
for （std::vector<STATUS>::iterator it = v_status.begin（）； it < v_status.end（）； it++）
{
it->Report（）；
}
std::cout 《
use or_each, mem_fun_ref: 《 std::endl;
std::for_each（v_status.begin（）， v_status.end（）， std::mem_fun_ref（&Status::Report））；
std::cout 《
use or_each, bind: 《 std::endl;
//std::for_each（v_status.begin（）， v_status.end（）， boost::bind（&Status::Report））； //error
std::for_each（v_status.begin（）， v_status.end（）， boost::bind（&Status::Report, _1））；
}</STATUS></STATUS></BOOST></ALGORITHM></VECTOR></STRING></IOSTREAM>
总结：
bind成员函数最大的不同是，必须指明调用该函数的实例对象，代码中用"_1"表示。
翻译：调用成员函数（2）
下面，我们稍微改造一下vector容器，让它装入指针而不是值：
std::vector<STATUS*> p_statuses;
p_statuses.push_back（new status（status 1））；
p_statuses.push_back（new status（status 2））；
p_statuses.push_back（new status（status 3））；
p_statuses.push_back（new status（status 4））；
p_statuses[1]->break_it（）；
p_statuses[2]->break_it（）；</STATUS*>
我们仍然可以用两种标准库，但是我们不能用mem_fun_ref,而是用mem_fun适配器，虽然它的名字听起来有点儿混淆，完成操作还是没问题的。
std::for_each（
p_statuses.begin（），
p_statuses.end（），
std::mem_fun（&status::report））；
注意到，这段代码的语法已经有所改变，尽管我们要做的工作几乎相同。当然，如果代码的语法和上面的例子一样就最好了，这样我们就可以更多地关注代码到底做了些什么而不是它怎么做的。使用Bind,我们不需要显式指明要处理的元素是指针（这在容器类型中已经说明了，重复的信息在现代的库里面显然是不必要的）
std::for_each（
p_statuses.begin（），
p_statuses.end（），
boost::bind（&status::report,_1））；
如你所见，这与之前非指针元素的代码没有任何区别。也就是说如果你理解了刚才的bind,那么这个也能理解。
#include <IOSTREAM>
#include <STRING>
#include <VECTOR>
#include
#include <BOOST bind.hpp="">
class Status
{
public:
Status（const std::string &name） : name_（name）， ok_（true）{}
void BreakIt（）
{
ok_ = false;
}
bool IsBroken（） const
{
return ok_;
}
void Report（） const
{
std::cout 《 name_ 《 is 《 （ok_ ? ok : broken） 《 std::endl;
}
private:
std::string name_;
bool ok_;
};
int main（）
{
std::vector<STATUS*> v_pstatus;
v_pstatus.push_back（new Status（status 1））；
v_pstatus.push_back（new Status（status 2））；
v_pstatus.push_back（new Status（status 3））；
v_pstatus.push_back（new Status（status 4））；
v_pstatus[1]->BreakIt（）；
v_pstatus[2]->BreakIt（）；
std::cout 《 use or: 《 std::endl;
for （std::vector<STATUS*>::iterator it = v_pstatus.begin（）； it < v_pstatus.end（）； it++）
{
（*it）->Report（）；
}
std::cout 《
use or_each, mem_fun_ref: 《 std::endl;
std::for_each（v_pstatus.begin（）， v_pstatus.end（）， std::mem_fun（&Status::Report））；
std::cout 《
use or_each, bind: 《 std::endl;
std::for_each（v_pstatus.begin（）， v_pstatus.end（）， boost::bind（&Status::Report, _1））；
}</STATUS*></STATUS*></BOOST></ALGORITHM></VECTOR></STRING></IOSTREAM>
总结：
只有bind保持了形式不变
翻译：调用成员函数（3）
我们决定使用指针后，有另外一个问题，即指针的生命周期控制。我们必须手动释放p_statuses中的元素，这很容易出错而且没有必要。因此，我们可能选择使用智能指针（smart pointers），代码变化如下：
std::vector<BOOST::SHARED_PTR<STATUS> > s_statuses;
s_statuses.push_back（
boost::shared_ptr<STATUS>（new status（status 1）））；
s_statuses.push_back（
boost::shared_ptr<STATUS>（new status（status 2）））；
s_statuses.push_back（
boost::shared_ptr<STATUS>（new status（status 3）））；
s_statuses.push_back（
boost::shared_ptr<STATUS>（new status（status 4）））；
s_statuses[1]->break_it（）；
s_statuses[2]->break_it（）；</STATUS></STATUS></STATUS></STATUS></BOOST::SHARED_PTR<STATUS>
现在，我们该使用标准库中的哪个适配器了？由于智能指针并没有report成员函数，mem_fun和mem_fun_ref都不能用了。如下代码会编译失败。
std::for_each（
s_statuses.begin（），
s_statuses.end（），
std::mem_fun（&status::report））；
我们的好运用完了，标准库并不能帮我们完成这个任务。因此，我们只能借助于之前想避开的for形式或者……Boost.Bind,它可以完全正确地完成任务。
std::for_each（
s_statuses.begin（），
s_statuses.end（），
boost::bind（&status::report,_1））；
这与前面的代码是完全一样的（除了容器的名字）。同样的语法可以用于绑定值语义、指针语义或者只能指针。有时候，不同的语法可以帮助我们理解代码，但在我们讨论的情况中不是这样--我们手中的任务是在容器的元素上调用成员函数，没有其他的需求。语法一致的价值是不容轻视的，它既帮助了写代码的人，也帮助了以后维护代码的人。（当然，实际上我们没有写需要维护的代码，但出于参数的考虑，让我们假装是这样做的吧^_^）。
#include <IOSTREAM>
#include <STRING>
#include <VECTOR>
#include
#include <BOOST bind.hpp="">
#include <BOOST shared_ptr.hpp="">
class Status
{
public:
Status（const std::string &name） : name_（name）， ok_（true）{}
void BreakIt（）
{
ok_ = false;
}
bool IsBroken（） const
{
return ok_;
}
void Report（） const
{
std::cout 《 name_ 《 is 《 （ok_ ? ok : broken） 《 std::endl;
}
private:
std::string name_;
bool ok_;
};
int main（）
{
std::vector< boost::shared_ptr<STATUS> > v_spstatus;
v_spstatus.push_back（boost::shared_ptr<STATUS>（new Status（status 1）））；
v_spstatus.push_back（boost::shared_ptr<STATUS>（new Status（status 2）））；
v_spstatus.push_back（boost::shared_ptr<STATUS>（new Status（status 3）））；
v_spstatus.push_back（boost::shared_ptr<STATUS>（new Status（status 4）））；
v_spstatus[1]->BreakIt（）；
v_spstatus[2]->BreakIt（）；
//std::cout 《 use or: 《 std::endl;
//for （std::vector<STATUS*>::iterator it = v_spstatus.begin（）； it < v_spstatus.end（）； it++）
//{
// （*it）->Report（）；
//}
//std::cout 《
use or_each, mem_fun_ref: 《 std::endl;
//std::for_each（v_spstatus.begin（）， v_spstatus.end（）， std::mem_fun（&Status::Report））；
std::cout 《
use or_each, bind: 《 std::endl;
std::for_each（v_spstatus.begin（）， v_spstatus.end（）， boost::bind（&Status::Report, _1））；
}</STATUS*></STATUS></STATUS></STATUS></STATUS></STATUS></BOOST>
</BOOST></ALGORITHM></VECTOR></STRING></IOSTREAM>
总结：
1、标准库中的方法不再能够使用
2、使用share_ptr必须引入头文件#include
这些例子展示了一些Boost.Bind最基本最常用的情况，也是它最擅长的方面。尽管标准库也提供了一些基本工具让我们完成同样的任务，但我们看到Bind提供了语法一致性和一些标准库目前没有的扩展功能。