boost :: bind ，是对标准库函数 std :: bind1st 和 std :: bind2nd 的泛化。 它支持任意的函数对象、函数、函 数指针和成员函数指针 。 它能够 将任意参数绑定为特定的值。它还能够将输入参数路由（route）到任意位置。 bind ，对于目标函数对象没有任何要求；尤其 是，它并不需要提供 result_type 、 first_argument_type 和 second_argument_type 这些标准类型定义（typedef）。

看以下定义：

int f( int a, int b)

{

return a + b ;

}

int g( int a, int b, int c)

{

return a + b + c ;

}

bind ( f , 1 , 2 ) ，会产生一个“零元”（"nullary"）函数对象， 该对象不需要任何参数，而返回 f ( 1 , 2 ) 。类似 地， bind ( g , 1 , 2 , 3 )() 等价 于 g ( 1 , 2 , 3 ) 。

还可以有选择地只将其中的一些参数绑定进去。 bind ( f ,  _1 , 5 )( x ) 等价 于 f ( x , 5 ) ；此处 的 _1 ，是一个占位参数， 它表示，“替换 成第一个输入参数 ”。

作为比较，看一看下面使用标准库中的原语实现的相同操作：

std::bind2nd(std::ptr_fun(f), 5 )(x);

bind 也支持 std :: bind1st 的功能：

std::bind1st(std::ptr_fun(f), 5 )(x); // f(5, x)

bind(f, 5 , _1)(x); // f(5, x)

bind 还支持超过两个参数的函数，并且 ，它的参数替换机制更通用：

bind(f, _2, _1)(x, y); // f(y, x)

bind(g, _1, 9 , _1)(x); // g(x, 9, x)

bind(g, _3, _3, _3)(x, y, z); // g(z, z, z)

bind(g, _1, _1, _1)(x, y, z); // g(x, x, x)

注意 ，在最后一个示例中， 由 bind ( g ,  _1 ,  _1 ,  _1 ) 所产生的那个函数对象， 并不会引用到第一个参数之外的那些参数，但是 妳仍然可以向它传入多个参数。任何额外 的参数都被静静 地无视了，类似 的，第三个示例中，第一 和第二个参数都被无视了。

向 bind 中所传入的那些参数， 会被复制且内部储存在所返回的函数对象中。例如 ，看以下代码：

int i = 5 ;

bind(f, i, _1);

bind 并不仅仅限于针对函数进行使用； 它还可以接受任意的函数对象。 在一般情况下， 所生成的函数对象的，其 operator () 函数 的 返回数据类型必须显式指定 (没有 typeof 操作符 的话，其返回数据类型无法推导 ) ：

struct F

{

int operator ()( int a , int b ) { return a - b ; }

bool operator ()( long a , long b ) { return a == b ; }

};

F f;

int x = 104 ;

bind< int >(f, _1, _1)(x); // f(x, x) ，也就是0

某些编译器无法识别 bind < R >( f , ...) 语法 。出于 可移植性方面的考虑，我们还支持另外 一种写法：

boost::bind(boost::type< int >(), f, _1, _1)(x);

注意 ，这里所说的另外一种写法，仅仅是在不得以情况下的写法。它并不是所设计的接口的组成部分。

如果 该个函数对象暴露出了一个名为 result_type 的嵌套数据类型，那么， 就可以省略掉显式指定的返回数据类型：

int x = 8 ;

bind(std::less< int >(), _1, 9 )(x); // x < 9

[注意 ：并不是所有的编译器中都可以省略掉返回数据类型。 ]

默认情况 下，对于妳所提供的函数对象， bind 会复制一个副本。 可使用 boost :: ref 和 boost :: cref 来储存该个函数对象的引用，而不是储存其副本。 以下情况下使用这种用法尤其有用： 该函数对象不可复制、复制的代价太大或者其中包含有状态数据；当然 ，在这种用法中，程序 猿需要确保， 在这个函数对象正在被使用的过程中，不要被销毁掉。

struct F2

{

int s ;

typedef void result_type ;

void operator ()( int x ) { s += x ; }

};

F2 f2 = { 0 };

int a[] = { 1 , 2 , 3 };

std::for_each(a, a+ 3 , bind(ref(f2), _1));

assert(f2.s == 6 );

向 bind 中传入的参数，本身也可以是嵌套的 bind 表达式：

bind(f, bind(g, _1))(x); // f(g(x))

当这个函数对象被调用时，内层的 bind 表达式会在外层 bind 表达式之前以不确定的顺序来算值；然后 ，当外层 bind 被算值时， 会将内层表达式的算值结果替换到对应的位置。 在上面的示例中，当这个函数对象被调用 且传入参数列表 ( x ) 时，首先 对 bind ( g ,  _1 )( x ) 进行算值，产生 g ( x ) ，然后 对 bind ( f , g ( x ))( x ) 进行算值，产生最终结果 f ( g ( x )) 。

为了使用方便，由 bind 产生的那些函数对象都会重载逻辑非操作符operator  ! ，还有那些关系及逻辑操作符 == 、 != 、 < 、 <= 、 > 、 >= 、 && 、 || 。

! bind ( f , ...) 等价 于 bind ( logical_not (),  bind ( f , ...)) ，其中 ， logical_not 是一个函数对象， 它接受一个参数 x ，并返回 ! x 。

bind ( f , ...)  op x ，其中， op 是一个关系或逻辑操作符，整个表达式等价于 bind ( relation (),  bind ( f , ...),  x ) ，其中 ， relation ，是一个函数对象，它接受两个参数 a 和 b ，并且返回 a op b 。

这些东西的意义在于，妳可以方便地将 bind 的结果反转。

std::remove_if(first, last, !bind(&X::visible, _1)); // 删除 不可见的对象

还可以将 bind 的结果与某个值进行比较：

std::find_if(first, last, bind(&X::name, _1) == "Peter" );

std::find_if(first, last, bind(&X::name, _1) == "Peter" || bind(&X::name, _1) == "Paul" );

还可以与占位符比较：

bind(&X::name, _1) == _2

还可以与另一个 bind 表达式比较：

std::sort(first, last, bind(&X::name, _1) < bind(&X::name, _2)); // 按照名字 来排序

class image;

class animation

{

public :

void advance ( int ms );

bool inactive () const ;

void render ( image & target ) const ;

};

std::vector<animation> anims;

template < class C, class P> void erase_if(C & c, P pred)

{

c . erase ( std :: remove_if ( c . begin (), c . end (), pred ), c . end ());

}

void update( int ms)

{

std :: for_each ( anims . begin (), anims . end (), boost :: bind (& animation :: advance , _1 , ms ));

erase_if ( anims , boost :: mem_fn (& animation :: inactive ));

}

void render(image & target)

{

std :: for_each ( anims . begin (), anims . end (), boost :: bind (& animation :: render , _1 , boost :: ref ( target )));

}

class button

{

public :

可能 是因为妳使用了通用的 bind < R >( f , ...) 语法， 这将导致 bind 不再“检查”f 以探测参数个数和返回数据类型方面的错误。

第一 种形式 ， 会要求 bind 对 f 的类型进行检查，确认 它的元数（arity(参数个数)）及返回数据类型。 元数相关的错误会在“绑定时刻”（"bind time"）检测。显然 ，这种语法会对 f 有所要求。 它必须是一个函数，或是一个函数指针，或者一个成员函数指针，或是一个定义了名为 result_type 的嵌套类型的函数对象；简单 地说，它必须能够被 bind 所识别。

第二 种形式，会要求 bind 不要对 f 的类型进行识别。 它通常用于那些没有暴露或无法暴露出 result_type 的函数对象， 但也可用于非标准的函数。例如，目前 的实现中，无法自动识别 可变数量参数的函数，比如 printf ，所以妳就需要使用 bind < int >( printf , ...) 了。注意 ，另外还提供了一个 bind ( type < R >(),  f , ...) 语法，用于解决可移植性方面的问题。

另一个重要因素就是，那些 不具有部分模板特化功能或函数模板部分排序功能的编译器， 在遇到 f 是函数对象的情况时，无法处理第一种语法 ，并且，遇到 f 是函数（指针）或成员函数指针时大部分都无法处理第二种语法。

在 bind ( f ,  a1 ,  a2 , ...,  aN ) 这样一个表达式中，函数对象 f ，必须能够刚好接受N 个参数。 这方面的错误，一般是在“绑定时刻”检测的； 换句话说，相关 的编译错误， 是在 bind () 被调用的地方报告的：

int f( int , int );

int main()

{

boost :: bind ( f , 1 ); // 错误 ， f需要两个参数

boost :: bind ( f , 1 , 2 ); // OK

}

这个错误的另一种表现形式就是，忘记了一点，成员函数都有一个隐藏的"this"参数：

struct X

{

int f ( int );

}

int main()

{

boost :: bind (& X :: f , 1 ); // 错误 ， X::f需要两个参数

boost :: bind (& X :: f , _1 , 1 ); // 正确

}

与普通的函数调用相同，被绑定的函数对象，必须 与传入的参数列表相兼容。如果 发生了不兼容的情况，那么，这种错误通常是在编译器在“调用时刻”检测到的， 所产生的结果是， 在 bind . hpp 中类似下面 这样的某行代码中 报告出错误：

return f(a[a1_], a[a2_]);

以下示例展示了这种错误：

int f( int );

int main()

{

boost :: bind ( f , "incompatible" ); // 目前 为止没有问题，因为未发生调用

boost :: bind ( f , "incompatible" )(); // 错误 ， "incompatible" 并不是 int

boost :: bind ( f , _1 ); // 没有问题

boost :: bind ( f , _1 )( "incompatible" ); // 错误 ， "incompatible" 并不是 int

}

占位符 _N ，命中 的是在“调用时刻”传入的参数列表中位于第 N 个位置的参数。自然 地，当妳试图访问到超出这个列表范围的参数时，就会出错：

int f( int );

int main()

{

boost :: bind ( f , _1 ); // 目前 没问题

boost :: bind ( f , _1 )(); // 错误 ，第1个位置没有参数

}

这个错误，通常在 bind . hpp 中类似下面的某行代码中报告：

return f(a[a1_]);

在模拟 std :: bind1st ( f ,  a ) 的时候， 与此相关的一个常见错误就是， 写出了 bind ( f ,  a ,  _2 ) ，而正确的写法应当是 bind ( f , a ,  _1 ) 。

试图对一个重载函数进行绑定的话，通常会产生错误，因为，无法指定要对重载函数中的哪一个进行绑定。对于拥有常量和非常量两种重载的成员函数来说，这是常见的错误，以下简单示例中展示这一点：

struct X

{

int & get ();

int const & get () const ;

};

int main()

{

boost :: bind (& X :: get , _1 );

}

这里的歧义性，可通过手动将（成员）函数指针转换成预期类型的方式来解决：

int main()

{

boost :: bind ( static_cast < int const & ( X ::*) () const >(& X :: get ), _1 );

}

另一种显然更具可读性的解决方法是，引入一个临时变量：

int main()

{

int const & ( X ::* get ) () const = & X :: get ;

boost :: bind ( get , _1 );

}

某些编译器， 在处理函数特征签名中的顶级 const 关键字时会有问题：

int f( int const );

int main()

{

boost :: bind ( f , 1 ); // 错误

}

解决方法 ：删除参数所带的 const 限制符。

namespace boost

{

// 不带参数

由 bind 返回的所有的 unspecified-N 类型，都是可复制构造的（ CopyConstructible ）。 unspecified-N :: result_type ，被定义为 unspecified-N :: operator () 的返回数据类型。

所有 的 unspecified-placeholder-N 数据类型都是可复制构造的（ CopyConstructible ）。它们 的复制构造函数不会抛出异常。

函数μ ( x ,  v1 ,  v2 , ...,  vm ) ，其中， m 是一个非负整数， 其定义是：

• •. 返回 ： 一个函数对象 λ ，使得，表达式λ ( v1 ,  v2 , ...,  vm ) 与 f () 等价， 它被 隐式转换 成 R 。

• •. 抛出异常： 除非 F 的复制构造函数抛出了异常，否则不会抛出异常。

• •. 效果 ： 等价 于 bind < typename  F :: result_type ,  F >( f ) 。

• •. 注意 ： 在具体实现中，可以以扩展的方式利用其它手段来推导 f 的返回类型， 而不需要依赖 result_type 成员。

• •. 返回 ： 一个函数对象λ，使得 ，表达式λ ( v1 ,  v2 , ...,  vm ) 等价于 f () 。

• •. 抛出异常 ： 不抛出任何异常。

• •. 返回 ： 一个 函数对象λ ，使得 ，表达式λ ( v1 ,  v2 , ...,  vm ) 等价于 f ( μ ( a1 ,  v1 ,  v2 , ...,  vm )) ， 它被隐式转换成 R 。

• •. 抛出异常： 除非 F 或 A1 的复制构造函数抛出了异常，否则不抛出任何异常。

• •. 效果 ： 等价 于 bind < typename  F :: result_type ,  F ,  A1 >( f ,  a1 ) 。

• •. 注意 ： 在具体实现中，可以以扩展的方式利用其它手段来推导 f 的返回类型， 而不需要依赖 result_type 成员。

• •. 返回 ： 一个函数对象λ，使得 ，表达式λ ( v1 ,  v2 , ...,  vm ) 等价 于 f ( μ ( a1 ,  v1 ,  v2 , ...,  vm )) 。

• •. 抛出异常 ： 除非 A1 的复制构造函数抛出异常，否则不会抛出任何异常。

• •. 返回 ： 一个函数对象λ，使得 ，表达式λ ( v1 ,  v2 , ...,  vm ) 等价于 f ( μ ( a1 ,  v1 ,  v2 , ...,  vm ), μ ( a2 ,  v1 ,  v2 , ...,  vm )) ， 它被隐式转换成 R 。

• •. 抛出异常： 除非 F 、 A1 或 A2 的复制构造函数抛出异常，否则不会抛出任何异常。

• •. 效果 ： 等价 于 bind < typename  F :: result_type ,  F ,  A1 ,  A2 >( f ,  a1 ,  a2 ) 。

• •. 注意 ： 在具体实现中，可以以扩展的方式利用其它手段来推导 f 的返回类型， 而不需要依赖 result_type 成员。

• •. 返回 ： 一个函数对象λ，使 得，表达式λ ( v1 ,  v2 , ...,  vm ) 等价于 f ( μ ( a1 ,  v1 ,  v2 , ...,  vm ), μ ( a2 ,  v1 ,  v2 , ...,  vm )) 。

• •. 抛出异常 ： 除非 A1 或 A2 的复制构造函数抛出异常，否则不会抛出任何异常。

具体 的实现中，允许提供更多的 bind 重载， 以支持更多的参数个数，或者其它形式的函数指针。

在这个实现中，支持多达9个参数的函数对象。这个限制是由具体实现决定的，不是由最初设计而决定的。

某些平台上，允许存在着多种（成员）函数类型，它们因为其调用风格（这些函数在调用时遵循的规则：参数如何传递；返回值如何处理；以及，（如果有的话）谁来清理栈）的不同而被区别为不同的类型。

要将 bind 与 __stdcall 函数配套使用，则在包含 < boost / bind . hpp > 之前定义（ #define ）这个宏 BOOST_BIND_ENABLE_STDCALL 。

要将 bind 与 __stdcall 成员函数配套使用，则在包含 < boost / bind . hpp > 之前定义（ #define ）这个宏 BOOST_MEM_FN_ENABLE_STDCALL 。

要将 bind 与 __fastcall 函数配套使用，则在包含 < boost / bind . hpp > 之前定义（ #define ）这个宏 BOOST_BIND_ENABLE_FASTCALL 。

要将 bind 与 __fastcall 成员函数配套使用，则在包含 < boost / bind . hpp > 之前定义（ #define ）这个宏 BOOST_MEM_FN_ENABLE_FASTCALL 。

要将 bind 与 pascal 函数配套使用，则在包含 < boost / bind . hpp > 之前定义（ #define ）这个宏 BOOST_BIND_ENABLE_PASCAL 。

要将 bind 与 __cdecl 成员函数配套使用，则在包含 < boost / bind . hpp > 之前定义（ #define ）这个宏 BOOST_MEM_FN_ENABLE_CDECL 。

最好 是用以下方式来定义这些宏： 在项目的配置选项中定义；在命令行中通过 - D 选 项 来定义；或者 在用到了 bind 的翻译单元（ .cpp 文件）的第一行定义。 不遵守这个规则的话，可能会引起奇特的错误，因为，某个 头文件可能在尚未定义这些宏的情况下就包含了 bind . hpp 。

[注意 ： 这是一个不可移植的扩展。它不是接口的一部分。 ]

[注意 ： 某些编译器 仅对 __stdcall 关键字提供了最小化的支持。 ]

由 bind 所返回的函数对象，支持目前 尚处于试验状态、未被文档说明的 visit_each 枚举接口。