深入理解 boost::bind

Asynchronous operations in Asio all expect a function object argument, the completion handler, which they invoke when the asynchronous operation completes. The signature of the handler depends on the type of operation. For example, a handler posted using
io_service::post()
must have the signature:

void handler();

while an asynchronous wait operation expects:

void handler(error_code ec);

and asynchronous read/write operations want:

void handler(error_code ec, size_t length);

Non-trivial applications will need to pass some context to the completion handler, such as a
this
pointer. One way to do this is to use a function object adapter like
boost::bind
,
std::tr1::bind
or (as of C++0x)
std::bind
.

Unfortunately, for many C++ programmers,
bind
represents a little bit of magic. This is not helped by the impenetrable compiler errors that confront you when you use it incorrectly. And, in my experience, the underlying concept (where some function arguments are bound up-front, while others are delayed until the point of call) can present quite a steep learning curve.

I have put together some diagrams to help explain how bind works. For clarity, I have taken a few liberties with C++ syntax (e.g. omitting the parameter types on the function call operator) and (over-)simplified
bind
‘s implementation. Finally, the examples are limited to those likely to be useful with Asio. Comments and suggestions welcome.

bind
can be used to adapt a user-supplied function expecting one argument into a function object that takes zero arguments. The bound value (
123
in this example) is stored in a function object and is automatically passed to the user-supplied function as required:

[ click images for full size ]

Binding an argument can be used to turn a class member function into a zero-argument function object. As you know, non-static member functions have an implicit
this
parameter. This means that an appropriate pointer needs to be bound into the function object:

Alternatively, the implicit
this
can be made explicit by adapting a member function into a function object taking one argument:

Function objects will often use both bound arguments and arguments supplied at the point of use. This can be done using member functions:

or non-member functions:

Sometimes the function object’s point of use will supply arguments which are not required to call the target function.
bind
will automatically discard these surplus arguments:

The surplus argument(s) need not be the at the end of the function object signature:

Finally,
bind
allows you to the reorder arguments to adapt the target function to the necessary function object signature:

翻译:

在Asio中，所有的异步操作都需要一个函数对象参数，亦称为completion handler，用于在异步操作完成时调用。这个handler的签名取决于异步操作的类型。例如：一个用于
io_service::post()
的handler必须拥有下面的签名：

void handler();

但异步等待操作的handler的签名则如下：

void handler(error_code ec);

而异步读/写操作则需要如下签名的函数：

void handler(error_code ec, size_t length);

事实上，应用程序可能需要传递某种应用环境（context）给这个completion handler，例如
this
指针。用
boost::bind, std::tr1::bind
或者C++0x的
std::bind
等函数对象适配器来达到这个目的，不失为一种办法。

不幸的是，对于许多C++猿类来说，
bind
代表了某种魔法。你在使用它时，如果稍有不慎，编译器就会给你一大堆编译错误，关键是你还不知道你错在哪儿。并且，根据我的经验，它的基本概念（有些函数参数预先被绑定，而有些则是在调用时才被绑定）的学习曲线非常陡峭。

为此，我画了一些图来解释
bind
是如何工作的。为了清晰，我对图中的语法作了一些简化（例如，省略函数调用操作符的参数类型），并且简化了
bind
的实现。最后，the examples are limited to those likely to be useful with Asio（译者注：这句根本不知道是什么意思好吗。。）。欢迎大家给我提建议和留言（感谢xiaoyu建议，这句话大概意思是：下面列举的主要是一些有助于在Asio中使用bind的例子）。

bind
可以用来将用户提供的需要一个参数的函数转换成不需要参数的函数对象。绑定的值（在这个例子中是123）存储在函数对象内并且会被自动传递给用户指定的函数：