Boost C++ 库

2

Boost C++ 库

Boost C++ 库

来源：Boost C++ 库

版本：1.0 / 19 八月 2010

协议：CC BY-NC-ND 3.0

Boost C++ 库

Boost C++ 库

目录

第 1 章 简介

第 2 章 智能指针 第 3 章 函数对象 第 4 章 事件处理 第 5 章 字符串处理 第 6 章 多线程

第 7 章 异步输入输出 第 8 章 进程间通讯 第 9 章 文件系统

第 10 章 日期与时间 第 11 章 序列化

第 12 章 词法分析器 第 13 章 容器

第 14 章 数据结构 第 15 章 错误处理

第 16 章 类型转换操作符

该书采用 Creative Commons License 授权

本书的中文版由 Albert Lai, Jerry Guo, Kun Zeng, Liangfu Chen (主页), Cui Wei 和 Rui Shi 翻译。

内容

你将学到些什么

本书是对 Boost C++ 库的介绍，Boost 库通过加入一些在实践中非常有用的函数对 C++ 标准进行了补充。 由于 Boost C++ 库是基于 C++ 标准的，所以它们是使用最 先进的 C++ 来实现的。 它们是平台独立的，并由于有一个大型的开发人员社区， 它可以被包括 Windows 和 Linux 在内的许多操作系统所支持。

Boost C++ 库可以提升你作为一个 C++ 开发人员的生产力。 例如，你可以从智能 指针中受益，帮助你写出更可靠的代码，或者使用某个库来开发平台独立的网络应 用。 因为多数 Boost C++ 库正被收录进下一个版本的 C++ 标准，所以你可以从今 天就开始作好准备。

要求

Boost C++ 库

你应该懂得些什么

因为 Boost C++ 库是基于且扩展了 C++ 标准，所以你应该懂得 C++ 标准。 你应 该了解且能够使用容器、迭代器及算法，最好有听说过以下概念：RAII，函数对 象，或是谓词。 你越是了解 C++ 标准，就越能从 Boost C++ 库中受益。

Boost C++ 库

第 1 章 简介

目录

1.1 C++ 与 Boost

1.2 开发过程

1.3 安装

1.4 概述

该书采用 Creative Commons License 授权

1.1. C++ 与 Boost

Boost C++ 库 是一组基于C++标准的现代库。 其源码按 Boost Software License 来发布，允许任何人自由地使用、修改和分发。 这些库是平台独立的，且支持大多 数知名和不那么知名的编译器。

Boost 社区负责开发和发布 Boost C++ 库。 社区由一个很大的C++开发人员群组组 成，这些开发人员来自于全球，他们通过网站 www.boost.org 以及几个邮件列表相 互协调。 社区的使命是开发和收集高质量的库，作为C++标准的补充。 那些被证 实有价值且对于C++应用开发非常重要的库，将会有很大机会在某天被纳入C++标 准中。

Boost 社区在1998年左右出现，当时刚刚发布了C++标准的第一个版本。 从那时 起，社区就不断地扩大，现在已成为C++标准化工作中的一个重要角色。 虽然 Boost 社区与标准化委员会之间没有直接的关系，但有部分开发者同时活跃于两 方。 下一个版本的C++标准很大可能在2011年通过，其中将扩展一批库，这些库均 起源于 Boost 社区。

要增强C++项目的生产力，除了C++标准以外，Boost C++ 库是一个不错的选择。 由于当前版本的C++标准在2003年修订之后，C++又有了新的发展，所以 Boost C++ 库提供了许多新的特性。 由于有了 Boost C++ 库，我们无需等待下一个版本 的C++标准，就可以立即享用C++演化中取得的最新进展。

Boost C++ 库具有良好的声誉，这基于它们的使用已被证实是非常有价值的。 在面 试中询问关于 Boost C++ 库的知识是不常见的，因为知道这些库的开发人员通常也 清楚C++的最新创新，并且能够编写和理解现代的C++代码。

1.2.开发过程

正是因为大量的独立开发者和组织的支持和参与，才使用 Boost C++ 库的开发成为 可能。 由于 Boost 只接受满足以下条件的库：解决了真实存在的问题、表现出令人 信服的设计、使用现代C++来开发且以可理解的方式提供文档，所以每一个 Boost C++ 库的背后都有大量的工作。

Boost C++ 库

C++ 开发者都可以加入到 Boost 社区中，并提出自己的新库。 但是，要将一个想 法变成一个 Boost C++ 库，需要投入大量的时间和努力。 其中最重要的是在 Boost 邮件列表中与其他开发者及潜在用户讨论需求和可能的解决方案。

除了这些好象不知从何处冒出来的新库以外，也可以提名一些已有的 C++ 库进入 Boost。 不过，由于对这些库的要求是与专门为 Boost 开发的库一样的，所以可能 需要对它们进行大量的修改。

一个库是否被接纳入 Boost，取决于评审过程的结果。 库的开发者可以申请评审， 这通常需要10天的时间。 在这段时间内，其他开发者被邀请对这个库进行评分。 基于正面和负面评价的数量，评审经理将决定该库是否被接纳进入 Boost。 由于有 些开发者是在评审阶段才首次公开库的代码，所以在评审期间被要求对库进行修改 并不罕见。

如果一个库是因为技术原因被拒绝，那么它还有可能在修改之后对更新后的版本申 请新的评审。 但是，如果一个库是因为不能解决实际问题或未能提供令人信服的解 决方案而被拒绝，那么再一次评审也很可能会被拒绝。

因为可能随时接纳新的库，所以 Boost C++ 库会每三个月发布一次新版本。本书所 涉及的库均基于2010年2月发布的 1.42.0 版本。

请注意，另外还有一些库已被接纳，但尚未成为 Boost C++ 库发布版的一部分。在 被包含进发布版之前，它们必须手工安装。

1.3.安装

Boost C++ 库均带有源代码。其中大多数库只包含头文件，可以直接使用，但也有 一些库需要编译。 为了尽可能容易安装，可以使用 Boost Jam 进行自动安装。 无 需逐个库进行检查和编译，Boost Jam 自动安装整个库集。 它支持许多操作系统和 编译器，并且知道如何基于适当的配置文件来编译单个库。

为了在 Boost Jam 的帮助下自动安装，要使用一个名为 bjam 的应用程序，它也带 有源代码。 对于某些操作系统，包括 Windows 和 Linux，也有预编译好的 bjam 二进制文件。

为了编译 bjam 本身，要执行一个名为 build 的简单脚本，它也为不同的操作系统 提供了源代码。 对于 Windows，它是批处理文件 build.bat 。 对于 Linux，文 件名为 build.sh 。

如果执行 build 时不带任何命令行选项，则该脚本尝试找到一个合适的编译器来生

成bjam。 通过使用命令行开关，称为 toolset，可以选择特定的编译器。 对于

Windows，build 支持 toolsets vc7 , vc8 和 vc9 ，可以选择不同版本的 Microsoft C++ 编译器。 要从 Visual Studio 2008 的C++编译器编译 bjam，需要指 定命令 build vc9。对于 Linux，支持 toolsets gcc 和 intel-linux ，分别选

定 GCC 和 Intel 的C++编译器。

应用程序 bjam 必须复制到本地的 Boost 目录 - 不论它是编译出来的还是下载的预 编译二进制文件。 然后就可以不带任何命令行选项地执行 bjam，编译并安装 Boost C++ 库。 由于缺省选项 - 在这种情况下所使用的 - 并不一定是最好的选择，

Boost C++ 库

Boost C++ 库

Boost C++ 库

Technical Report 1 是在2003年发布的，有关 C++0x 标准和 Technical Report 2 的 一些细节才能反映当前的状态。由于无论是下一个版本的 C++ 标准，还是 Technical Report 2 都尚未被批准，所以在往后的时间里，它们仍然可能会有改 变。

Boost C++ 库

第 2 章 智能指针

目录

2.1 概述

2.2 RAII

2.3 作用域指针

2.4 作用域数组

2.5 共享指针

2.6 共享数组

2.7 弱指针

2.8 介入式指针

2.9 指针容器

2.10 练习

该书采用 Creative Commons License 授权

2.1.概述

1998年修订的第一版C++标准只提供了一种智能指针： std::auto_ptr 。 它基

本上就像是个普通的指针： 通过地址来访问一个动态分配的对象。 std::auto_ptr 之所以被看作是智能指针，是因为它会在析构的时候调用 delete 操作符来自动释放所包含的对象。 当然这要求在初始化的时候，传给它

一个由 new 操作符返回的对象的地址。 既然 std::auto_ptr 的析构函数会调

用delete 操作符，它所包含的对象的内存会确保释放掉。 这是智能指针的一个 优点。

当和异常联系起来时这就更加重要了：没有 std::auto_ptr 这样的智能指针， 每一个动态分配内存的函数都需要捕捉所有可能的异常，以确保在异常传递给函数 的调用者之前将内存释放掉。 Boost C++ 库 Smart Pointers 提供了许多可以用在 各种场合的智能指针。

2.2. RAII

智能指针的原理基于一个常见的习语叫做 RAII ：资源申请即初始化。 智能指针只 是这个习语的其中一例——当然是相当重要的一例。 智能指针确保在任何情况下， 动态分配的内存都能得到正确释放，从而将开发人员从这项任务中解放了出来。 这 包括程序因为异常而中断，原本用于释放内存的代码被跳过的场景。 用一个动态分 配的对象的地址来初始化智能指针，在析构的时候释放内存，就确保了这一点。 因 为析构函数总是会被执行的，这样所包含的内存也将总是会被释放。

Boost C++ 库

无论何时，一定得有第二条指令来释放之前另一条指令所分配的资源时，RAII 都是 适用的。 许多的 C++ 应用程序都需要动态管理内存，因而智能指针是一种很重要 的 RAII 类型。 不过 RAII 本身是适用于许多其它场景的。

#include <windows.h>

class windows_handle

{

public: windows_handle(HANDLE h)

: handle_(h)

{

}

~windows_handle()

{

CloseHandle(handle_);

}

HANDLE handle() const

{

return handle_;

}

private:

HANDLE handle_;

};

int main()

{

windows_handle h(OpenProcess(PROCESS_SET_INFORMATION, FALSE, Get SetPriorityClass(h.handle(), HIGH_PRIORITY_CLASS);

}

下载源代码

上面的例子中定义了一个名为 windows_handle 的类，它的析构函数调用了

CloseHandle() 函数。 这是一个 Windows API 函数，因而这个程序只能在 Windows 上运行。 在 Windows 上，许多资源在使用之前都要求打开。 这暗示着 一旦资源不再使用之后就应该关闭。 windows_handle 类的机制能确保这一点。

windows_handle 类的实例以一个句柄来初始化。 Windows 使用句柄来唯一的 标识资源。 比如说， OpenProcess() 函数返回一个 HANDLE 类型的句柄，通过 该句柄可以访问当前系统中的进程。 在示例代码中，访问的是进程自己——换句话 说就是应用程序本身。

我们通过这个返回的句柄提升了进程的优先级，这样它就能从调度器那里获得更多

的CPU 时间。 这里只是用于演示目的，并没什么实际的效应。 重要的一点是：通

过 OpenProcess() 打开的资源不需要显示的调用 CloseHandle() 来关闭。 当

Boost C++ 库

然，应用程序终止时资源也会随之关闭。 然而，在更加复杂的应用程序里，

windows_handle 类确保当一个资源不再使用时就能正确的关闭。 某个资源一旦 离开了它的作用域——上例中 h 的作用域在 main() 函数的末尾——它的析构 函数会被自动的调用，相应的资源也就释放掉了。

2.3.作用域指针

一个作用域指针独占一个动态分配的对象。 对应的类名为

boost::scoped_ptr ，它的定义在 boost/scoped_ptr.hpp 中。 不像 std::auto_ptr ，一个作用域指针不能传递它所包含的对象的所有权到另一个作

用域指针。 一旦用一个地址来初始化，这个动态分配的对象将在析构阶段释放。

因为一个作用域指针只是简单保存和独占一个内存地址，所以

boost::scoped_ptr 的实现就要比 std::auto_ptr 简单。 在不需要所有权传 递的时候应该优先使用 boost::scoped_ptr 。 在这些情况下，比起 std::auto_ptr 它是一个更好的选择，因为可以避免不经意间的所有权传递。

#include <boost/scoped_ptr.hpp>

int main()

{

boost::scoped_ptr<int> i(new int); *i = 1;

*i.get() = 2; i.reset(new int);

}

下载源代码

一经初始化，智能指针 boost::scoped_ptr 所包含的对象，可以通过类似于普 通指针的接口来访问。 这是因为重载了相关的操作符

operator*() ， operator->() 和 operator bool() 。 此外，还有 get() 和 reset() 方法。 前者返回所含对象的地址，后者用一个新的对象来

重新初始化智能指针。 在这种情况下，新创建的对象赋值之前会先自动释放所包含 的对象。

boost::scoped_ptr 的析构函数中使用 delete 操作符来释放所包含的对象。 这对 boost::scoped_ptr 所包含的类型加上了一条重要的限制。 boost::scoped_ptr 不能用动态分配的数组来做初始化，因为这需要调用 delete[] 来释放。 在这种情况下，可以使用下面将要介绍的

boost:scoped_array 类。

2.4.作用域数组

Boost C++ 库

作用域数组的使用方式与作用域指针相似。 关键不同在于，作用域数组的析构函数 使用 delete[] 操作符来释放所包含的对象。 因为该操作符只能用于数组对象， 所以作用域数组必须通过动态分配的数组来初始化。

对应的作用域数组类名为 boost::scoped_array ，它的定义在 boost/scoped_array.hpp 里。

#include <boost/scoped_array.hpp>

int main()

{

boost::scoped_array<int> i(new int[2]); *i.get() = 1;

i[1] = 2; i.reset(new int[3]);

}

下载源代码

boost:scoped_array 类重载了操作符 operator[]() 和

operator bool() 。 可以通过 operator[]() 操作符访问数组中特定的元素， 于是 boost::scoped_array 类型对象的行为就酷似它所含的数组。

正如 boost::scoped_ptr 那样, boost:scoped_array 也提供了 get() 和 reset() 方法，用来返回和重新初始化所含对象的地址。

2.5.共享指针

这是使用率最高的智能指针，但是 C++ 标准的第一版中缺少这种指针。 它已经作 为技术报告1（TR 1）的一部分被添加到标准里了。 如果开发环境支持的话，可以 使用 memory 中定义的 std::shared_ptr 。 在 Boost C++ 库里，这个智能指

针命名为 boost::shared_ptr ，定义在 boost/shared_ptr.hpp 里。

智能指针 boost::shared_ptr 基本上类似于 boost::scoped_ptr 。 关键不同 之处在于 boost::shared_ptr 不一定要独占一个对象。 它可以和其他

boost::shared_ptr 类型的智能指针共享所有权。 在这种情况下，当引用对象 的最后一个智能指针销毁后，对象才会被释放。

因为所有权可以在 boost::shared_ptr 之间共享，任何一个共享指针都可以被 复制，这跟 boost::scoped_ptr 是不同的。 这样就可以在标准容器里存储智能 指针了——你不能在标准容器中存储 std::auto_ptr ，因为它们在拷贝的时候传 递了所有权。

Boost C++ 库

#include <boost/shared_ptr.hpp> #include <vector>

int main()

{

std::vector<boost::shared_ptr<int> > v;

v.push_back(boost::shared_ptr<int>(new int(1))); v.push_back(boost::shared_ptr<int>(new int(2)));

}

下载源代码

多亏了有 boost::shared_ptr ，我们才能像上例中展示的那样，在标准容器中 安全的使用动态分配的对象。 因为 boost::shared_ptr 能够共享它所含对象的 所有权，所以保存在容器中的拷贝（包括容器在需要时额外创建的拷贝）都是和原 件相同的。如前所述， std::auto_ptr 做不到这一点，所以绝对不应该在容器中 保存它们。

类似于 boost::scoped_ptr ， boost::shared_ptr 类重载了以下这些操作

符： operator*() ， operator->() 和 operator bool() 。另外还有 get() 和 reset() 函数来获取和重新初始化所包含的对象的地址。

#include <boost/shared_ptr.hpp>

int main()

{

boost::shared_ptr<int> i1(new int(1)); boost::shared_ptr<int> i2(i1); i1.reset(new int(2));

}

下载源代码

本例中定义了2个共享指针 i1 和 i2 ，它们都引用到同一个 int 类型的对 象。 i1 通过 new 操作符返回的地址显示的初始化， i2 通过 i1 拷贝构造 而来。 i1 接着调用 reset() ，它所包含的整数的地址被重新初始化。不过它 之前所包含的对象并没有被释放，因为 i2 仍然引用着它。 智能指针

boost::shared_ptr 记录了有多少个共享指针在引用同一个对象，只有在最后 一个共享指针销毁时才会释放这个对象。

默认情况下， boost::shared_ptr 使用 delete 操作符来销毁所含的对象。 然而，具体通过什么方法来销毁，是可以指定的，就像下面的例子里所展示的：

Boost C++ 库

#include <boost/shared_ptr.hpp> #include <windows.h>

int main()

{

boost::shared_ptr<void> h(OpenProcess(PROCESS_SET_INFORMATION, F SetPriorityClass(h.get(), HIGH_PRIORITY_CLASS);

}

下载源代码

boost::shared_ptr 的构造函数的第二个参数是一个普通函数或者函数对象， 该参数用来销毁所含的对象。 在本例中，这个参数是 Windows API 函数

CloseHandle() 。 当变量 h 超出它的作用域时，调用的是这个函数而不是 delete 操作符来销毁所含的对象。 为了避免编译错误，该函数只能带一个 HANDLE 类型的参数， CloseHandle() 正好符合要求。

该例和本章稍早讲述 RAII 习语时所用的例子的运行是一样的。 然而，本例没有单

独定义一个 windows_handle 类，而是利用了 boost::shared_ptr 的特性， 给它的构造函数传递一个方法，这个方法会在共享指针超出它的作用域时自动调 用。

2.6.共享数组

共享数组的行为类似于共享指针。 关键不同在于共享数组在析构时，默认使用

delete[] 操作符来释放所含的对象。 因为这个操作符只能用于数组对象，共享 数组必须通过动态分配的数组的地址来初始化。

共享数组对应的类型是 boost::shared_array ，它的定义在 boost/shared_array.hpp 里。

#include <boost/shared_array.hpp> #include <iostream>

int main()

{

boost::shared_array<int> i1(new int[2]); boost::shared_array<int> i2(i1);

i1[0] = 1;

std::cout << i2[0] << std::endl;

}

下载源代码

Boost C++ 库

就像共享指针那样，所含对象的所有权可以跟其他共享数组来共享。 这个例子中定 义了2个变量 i1 和 i2 ，它们引用到同一个动态分配的数组。 i1 通过

operator[]() 操作符保存了一个整数1——这个整数可以被 i2 引用，比如打 印到标准输出。

和本章中所有的智能指针一样， boost::shared_array 也同样提供了 get()

和reset() 方法。 另外还重载了 operator bool() 。

2.7.弱指针

到目前为止介绍的各种智能指针都能在不同的场合下独立使用。 相反，弱指针只有 在配合共享指针一起使用时才有意义。 弱指针 boost::weak_ptr 的定义在

boost/weak_ptr.hpp 里。

#include <windows.h>

#include <boost/shared_ptr.hpp> #include <boost/weak_ptr.hpp> #include <iostream>

DWORD WINAPI reset(LPVOID p)

{

boost::shared_ptr<int> *sh = static_cast<boost::shared_ptr<int>* sh->reset();

return 0;

}

DWORD WINAPI print(LPVOID p)

{

boost::weak_ptr<int> *w = static_cast<boost::weak_ptr<int>*>(p); boost::shared_ptr<int> sh = w->lock();

if (sh)

std::cout << *sh << std::endl; return 0;

}

int main()

{

boost::shared_ptr<int> sh(new int(99)); boost::weak_ptr<int> w(sh);

HANDLE threads[2];

threads[0] = CreateThread(0, 0, reset, &sh, 0, 0); threads[1] = CreateThread(0, 0, print, &w, 0, 0); WaitForMultipleObjects(2, threads, TRUE, INFINITE);

}

下载源代码

Boost C++ 库

boost::weak_ptr 必定总是通过 boost::shared_ptr 来初始化的。一旦初始 化之后，它基本上只提供一个有用的方法: lock() 。此方法返回

的boost::shared_ptr 与用来初始化弱指针的共享指针共享所有权。 如果这个 共享指针不含有任何对象，返回的共享指针也将是空的。

当函数需要一个由共享指针所管理的对象，而这个对象的生存期又不依赖于这个函 数时，就可以使用弱指针。 只要程序中还有一个共享指针掌管着这个对象，函数就 可以使用该对象。 如果共享指针复位了，就算函数里能得到一个共享指针，对象也 不存在了。

上例的 main() 函数中，通过 Windows API 创建了2个线程。 于是乎，该例只能

在Windows 平台上编译运行。

第一个线程函数 reset() 的参数是一个共享指针的地址。 第二个线程函数

print() 的参数是一个弱指针的地址。 这个弱指针是之前通过共享指针初始化 的。

一旦程序启动之后， reset() 和 print() 就都开始执行了。 不过执行顺序是 不确定的。 这就导致了一个潜在的问题： reset() 线程在销毁对象的时

候print() 线程可能正在访问它。

通过调用弱指针的 lock() 函数可以解决这个问题：如果对象存在，那么

lock() 函数返回的共享指针指向这个合法的对象。否则，返回的共享指针被设 置为0，这等价于标准的null指针。

弱指针本身对于对象的生存期没有任何影响。 lock() 返回一个共享指

针， print() 函数就可以安全的访问对象了。 这就保证了——即使另一个线程要 释放对象——由于我们有返回的共享指针，对象依然存在。

2.8.介入式指针

大体上，介入式指针的工作方式和共享指针完全一样。 boost::shared_ptr 在 内部记录着引用到某个对象的共享指针的数量，可是对介入式指针来说，程序员就 得自己来做记录。 对于框架对象来说这就特别有用，因为它们记录着自身被引用的 次数。

介入式指针 boost::intrusive_ptr 定义在 boost/intrusive_ptr.hpp 里。

Boost C++ 库

#include <boost/intrusive_ptr.hpp> #include <atlbase.h>

#include <iostream>

void intrusive_ptr_add_ref(IDispatch *p)

{

p->AddRef();

}

void intrusive_ptr_release(IDispatch *p)

{

p->Release();

}

void check_windows_folder()

{

CLSID clsid; CLSIDFromProgID(CComBSTR("Scripting.FileSystemObject"), &clsid); void *p;

CoCreateInstance(clsid, 0, CLSCTX_INPROC_SERVER, __uuidof(IDispa boost::intrusive_ptr<IDispatch> disp(static_cast<IDispatch*>(p)) CComDispatchDriver dd(disp.get());

CComVariant arg("C:\\Windows"); CComVariant ret(false); dd.Invoke1(CComBSTR("FolderExists"), &arg, &ret); std::cout << (ret.boolVal != 0) << std::endl;

}

void main()

{

CoInitialize(0);

check_windows_folder(); CoUninitialize();

}

下载源代码

上面的例子中使用了 COM（组件对象模型）提供的函数，于是乎只能在 Windows 平台上编译运行。 COM 对象是使用 boost::intrusive_ptr 的绝佳范例，因为 COM 对象需要记录当前有多少指针引用着它。 通过调用 AddRef() 和

Release() 函数，内部的引用计数分别增 1 或者减 1。当引用计数为 0 时， COM 对象自动销毁。

在intrusive_ptr_add_ref() 和 intrusive_ptr_release() 内部调用 AddRef() 和 Release() 这两个函数，来增加或减少相应 COM 对象的引用计

数。 这个例子中用到的 COM 对象名为 'FileSystemObject'，在 Windows 上它是默 认可用的。通过这个对象可以访问底层的文件系统，比如检查一个给定的目录是否 存在。 在上例中，我们检查 C:\Windows 目录是否存在。 具体它在内部是怎么 实现的，跟 boost::intrusive_ptr 的功能无关，完全取决于 COM。 关键点在

Boost C++ 库

于一旦介入式指针 disp 离开了它的作用域——函 数的末尾，函数 intrusive_ptr_release() 将会被自动调用。 这将减少 COM 对象 'FileSystemObject' 的内部引用计数到0，于是该对象就销毁了。

2.9.指针容器

在你见过 Boost C++ 库的各种智能指针之后，应该能够编写安全的代码，来使用动 态分配的对象和数组。多数时候，这些对象要存储在容器里——如上所述——使用

boost::shared_ptr 和 boost::shared_array 这就相当简单了。

#include <boost/shared_ptr.hpp> #include <vector>

int main()

{

std::vector<boost::shared_ptr<int> > v;

v.push_back(boost::shared_ptr<int>(new int(1))); v.push_back(boost::shared_ptr<int>(new int(2)));

}

下载源代码

上面例子中的代码当然是正确的，智能指针确实可以这样用，然而因为某些原因， 实际情况中并不这么用。 第一，反复声明 boost::shared_ptr 需要更多的输 入。 其次，将 boost::shared_ptr 拷进，拷出，或者在容器内部做拷贝，需要 频繁的增加或者减少内部引用计数，这肯定效率不高。 由于这些原因，Boost C++ 库提供了 指针容器 专门用来管理动态分配的对象。

#include <boost/ptr_container/ptr_vector.hpp>

int main()

{

boost::ptr_vector<int> v; v.push_back(new int(1)); v.push_back(new int(2));

}

下载源代码

boost::ptr_vector 类的定义在 boost/ptr_container/ptr_vector.hpp 里，它跟前一个例子中用 boost::shared_ptr 模板参数来初始化的容器具有相 同的工作方式。 boost::ptr_vector 专门用于动态分配的对象，它使用起来更 容易也更高效。 boost::ptr_vector 独占它所包含的对象，因而容器之外的共 享指针不能共享所有权，这跟

std::vector<boost::shared_ptr<int> > 相反。

Boost C++ 库

boost::ptr_vector 之外，专门用于管理动态分配对象的容器还包 boost::ptr_deque ， boost::ptr_list ， boost::ptr_set ，

boost::ptr_map ， boost::ptr_unordered_set 和

boost::ptr_unordered_map 。这些容器等价于C++标准里提供的那些。最后两 个容器对应于 std::unordered_set 和 std::unordered_map ，它们作为技术

报告1的一部分加入 C++ 标准。 如果所使用的 C++ 标准实现不支持技术报告1的

22

Boost C++ 库

#include <vector>

template <typename T>

T*create()

{

return new T;

}

int main()

{

std::vector<int*> v; v.push_back(create<int>());

}

下载源代码

Boost C++ 库

第 3 章 函数对象

目录

3.1 概述

3.2 Boost.Bind

3.3 Boost.Ref

3.4 Boost.Function

3.5 Boost.Lambda

3.6 练习

该书采用 Creative Commons License 授权

3.1.概述

本章介绍的是函数对象，可能称为'高阶函数'更为适合。 它实际上是指那些可以被 传入到其它函数或是从其它函数返回的一类函数。 在C++中高阶函数是被实现为函 数对象的，所以这个标题还是有意义的。

在这整一章中，将会介绍几个用于处理函数对象的 Boost C++ 库。 其 中，Boost.Bind 可替换来自C++标准的著名的 std::bind1st() 和 std::bind2nd() 函数，而 Boost.Function 则提供了一个用于封装函数指针的 类。 最后，Boost.Lambda 则引入了一种创建匿名函数的方法。

3.2. Boost.Bind

Boost.Bind 是这样的一个库，它简化了由C++标准中的 std::bind1st() 和

std::bind2nd() 模板函数所提供的一个机制：将这些函数与几乎不限数量的参 数一起使用，就可以得到指定签名的函数。 这种情形的一个最好的例子就是在 C++标准中定义的多个不同算法。

Boost C++ 库

#include <iostream> #include <vector> #include <algorithm>

void print(int i)

{

std::cout << i << std::endl;

}

int main()

{

std::vector<int> v; v.push_back(1); v.push_back(3); v.push_back(2);

std::for_each(v.begin(), v.end(), print);

}

下载源代码

算法 std::for_each() 要求它的第三个参数是一个仅接受正好一个参数的函数 或函数对象。 如果 std::for_each() 被执行，指定容器中的所有元素 - 在上例 中，这些元素的类型为 int - 将按顺序被传入至 print() 函数。 但是，如果 要使用一个具有不同签名的函数的话，事情就复杂了。 例如，如果要传入的是以下 函数 add() ，它要将一个常数值加至容器中的每个元素上，并显示结果。

void add(int i, int j)

{

std::cout << i + j << std::endl;

}

由于 std::for_each() 要求的是仅接受一个参数的函数，所以不能直接传入 add() 函数。 源代码必须要修改。

Boost C++ 库

#include <iostream> #include <vector> #include <algorithm> #include <functional>

class add

: public std::binary_function<int, int, void>

{

public:

void operator()(int i, int j) const

{

std::cout << i + j << std::endl;

}

};

int main()

{

std::vector<int> v; v.push_back(1); v.push_back(3); v.push_back(2);

std::for_each(v.begin(), v.end(), std::bind1st(add(), 10));

}

下载源代码

以上程序将值10加至容器 v 的每个元素之上，并使用标准输出流显示结果。 源 代码必须作出大幅的修改，以实现此功能： add() 函数已被转换为一个派生自

std::binary_function 的函数对象。

Boost.Bind 简化了不同函数之间的绑定。 它只包含一个 boost::bind() 模板函 数，定义于 boost/bind.hpp 中。 使用这个函数，可以如下实现以上例子：

Boost C++ 库

#include <boost/bind.hpp> #include <iostream> #include <vector> #include <algorithm>

void add(int i, int j)

{

std::cout << i + j << std::endl;

}

int main()

{

std::vector<int> v; v.push_back(1); v.push_back(3); v.push_back(2);

std::for_each(v.begin(), v.end(), boost::bind(add, 10, _1));

}

下载源代码

象add() 这样的函数不再需要为了要用于 std::for_each() 而转换为函数对

象。 使用 boost::bind() ，这个函数可以忽略其第一个参数而使用。

因为 add() 函数要求两个参数，两个参数都必须传递给 boost::bind() 。 第 一个参数是常数值10，而第二个参数则是一个怪异的 _1 。

_1 被称为占位符(placeholder)，定义于 Boost.Bind。 除了 _1 ，Boost.Bind 还 定义了 _2 和 _3 。 通过使用这些占位符， boost::bind() 可以变为一元、 二元或三元的函数。 对于 _1 , boost::bind() 变成了一个一元函数 - 即只要 求一个参数的函数。 这是必需的，因为 std::for_each() 正是要求一个一元函 数作为其第三个参数。

当这个程序执行时， std::for_each() 对容器 v 中的第一个元素调用该一元 函数。 元素的值通过占位符 _1 传入到一元函数中。 这个占位符和常数值被进一 步传递到 add() 函数。 通过使用这种机制， std::for_each() 只看到了由 boost::bind() 所定义的一元函数。 而 boost::bind() 本身则只是调用了另 一个函数，并将常数值或占位符作为参数传入给它。

下面这个例子通过 boost::bind() 定义了一个二元函数，用于 std::sort() 算法，该算法要求一个二元函数作为其第三个参数。

Boost C++ 库

#include <boost/bind.hpp> #include <vector> #include <algorithm>

bool compare(int i, int j)

{

return i > j;

}

int main()

{

std::vector<int> v; v.push_back(1); v.push_back(3); v.push_back(2);

std::sort(v.begin(), v.end(), boost::bind(compare, _1, _2));

}

下载源代码

因为使用了两个占位符 _1 和 _2 ，所以 boost::bind() 定义了一个二元函 数。 std::sort() 算法以容器 v 的两个元素来调用该函数，并根据返回值来 对容器进行排序。 基于 compare() 函数的定义，容器将被按降序排列。

但是，由于 compare() 本身就是一个二元函数，所以使用 boost::bind() 确 是多余的。

#include <boost/bind.hpp> #include <vector> #include <algorithm>

bool compare(int i, int j)

{

return i > j;

}

int main()

{

std::vector<int> v; v.push_back(1); v.push_back(3); v.push_back(2);

std::sort(v.begin(), v.end(), compare);

}

下载源代码

Boost C++ 库

不过使用 boost::bind() 还是有意义的。例如，如果容器要按升序排列而又不 能修改 compare() 函数的定义。

#include <boost/bind.hpp> #include <vector> #include <algorithm>

bool compare(int i, int j)

{

return i > j;

}

int main()

{

std::vector<int> v; v.push_back(1); v.push_back(3); v.push_back(2);

std::sort(v.begin(), v.end(), boost::bind(compare, _2, _1));

}

下载源代码

该例子仅改变了占位符的顺序： _2 被作为第一参数传递，而 _1 则被作为第二 参数传递至 compare() ，这样即可改变排序的顺序。

3.3. Boost.Ref

本库 Boost.Ref 通常与 Boost.Bind 一起使用，所以我把它们挨着写。 它提供了两 个函数 - boost::ref() 和 boost::cref() - 定义于 boost/ref.hpp .

当要用于 boost::bind() 的函数带有至少一个引用参数时，Boost.Ref 就很重要 了。 由于 boost::bind() 会复制它的参数，所以引用必须特别处理。

Boost C++ 库

#include <boost/bind.hpp> #include <iostream> #include <vector> #include <algorithm>

void add(int i, int j, std::ostream &os)

{

os << i + j << std::endl;

}

int main()

{

std::vector<int> v; v.push_back(1); v.push_back(3); v.push_back(2);

std::for_each(v.begin(), v.end(), boost::bind(add, 10, _1, boost

}

下载源代码

以上例子使用了上一节中的 add() 函数。 不过这一次该函数需要一个流对象的 引用来打印信息。 因为传给 boost::bind() 的参数是以值方式传递的，所以

std::cout 不能直接使用，否则该函数会试图创建它的一份拷贝。

通过使用模板函数 boost::ref() ，象 std::cout 这样的流就可以被以引用方 式传递，也就可以成功编译上面这个例子了。

要以引用方式传递常量对象，可以使用模板函数 boost::cref() 。

3.4. Boost.Function

为了封装函数指针，Boost.Function 提供了一个名为 boost::function 的类。 它定义于 boost/function.hpp ，用法如下：

Boost C++ 库

#include <boost/function.hpp> #include <iostream> #include <cstdlib> #include <cstring>

int main()

{

boost::function<int (const char*)> f = std::atoi; std::cout << f("1609") << std::endl;

f = std::strlen;

std::cout << f("1609") << std::endl;

}

下载源代码

boost::function 可以定义一个指针，指向具有特定签名的函数。 以上例子定 义了一个指针 f ，它可以指向某个接受一个类型为 const char* 的参数且返回 一个类型为 int 的值的函数。 定义完成后，匹配此签名的函数均可赋值给这个 指针。 这个例程就是先将 std::atoi() 赋值给 f ，然后再将它重赋值为

std::strlen() 。

注意，给定的数据类型并不需要精确匹配：虽然 std::strlen() 是以 std::size_t 作为返回类型的，但是它也可以被赋值给 f 。

因为 f 是一个函数指针，所以被赋值的函数可以通过重载的 operator()() 操 作符来调用。 取决于当前被赋值的是哪一个函数，在以上例子中将调用

std::atoi() 或 std::strlen() 。

如果 f 未赋予一个函数而被调用，则会抛出一个 boost::bad_function_call 异常。

#include <boost/function.hpp> #include <iostream>

int main()

{

try

{

boost::function<int (const char*)> f; f("");

}

catch (boost::bad_function_call &ex)

{

std::cout << ex.what() << std::endl;

}

}

下载源代码

Boost C++ 库

注意，将值 0 赋给一个 boost::function 类型的函数指针，将会释放当前所赋 的函数。 释放之后再调用它也会导致 boost::bad_function_call 异常被抛 出。 要检查一个函数指针是否被赋值某个函数，可以使用 empty() 函数或

operator bool() 操作符。

通过使用 Boost.Function，类成员函数也可以被赋值给类型为 boost::function 的对象。

#include <boost/function.hpp> #include <iostream>

struct world

{

void hello(std::ostream &os)

{

os << "Hello, world!" << std::endl;

}

};

int main()

{

boost::function<void (world*, std::ostream&)> f = &world::hello; world w;

f(&w, boost::ref(std::cout));

}

下载源代码

在调用这样的一个函数时，传入的第一个参数表示了该函数被调用的那个特定对 象。 因此，在模板定义中的左括号后的第一个参数必须是该特定类的指针。 接下 来的参数才是表示相应的成员函数的签名。

这个程序还使用了来自 Boost.Ref 库的 boost::ref() ，它提供了一个方便的机 制向 Boost.Function 传递引用。

3.5. Boost.Lambda

匿名函数 - 又称为 lambda 函数 - 已经在多种编程语言中存在，但 C++ 除外。 不过 在 Boost.Lambda 库的帮助下，现在在 C++ 应用中也可以使用它们了。

lambda 函数的目标是令源代码更为紧凑，从而也更容易理解。 以本章第一节中的 代码例子为例。

Boost C++ 库

#include <iostream> #include <vector> #include <algorithm>

void print(int i)

{

std::cout << i << std::endl;

}

int main()

{

std::vector<int> v; v.push_back(1); v.push_back(3); v.push_back(2);

std::for_each(v.begin(), v.end(), print);

}

下载源代码

这段程序接受容器 v 中的元素并使用 print() 函数将它们写出到标准输出 流。 由于 print() 只是写出一个简单的 int ，所以该函数的实现相当简单。 严格来说，它是如此地简单，以致于如果可以在 std::for_each() 算法里面直 接定义它的话，会更为方便； 从而省去增加一个函数的需要。 另外一个好处是代 码更为紧凑，使得算法与负责数据输出的函数不是局部性分离的。 Boost.Lambda 正好使之成为现实。

#include <boost/lambda/lambda.hpp> #include <iostream>

#include <vector> #include <algorithm>

int main()

{

std::vector<int> v; v.push_back(1); v.push_back(3); v.push_back(2);

std::for_each(v.begin(), v.end(), std::cout << boost::lambda::_1

}

下载源代码

Boost.Lambda 提供了几个结构来定义匿名函数。 代码就被置于执行的地方，从而 省去将它包装为一个函数再进行相应的函数调用的这些开销。 与原来的例子一样， 这个程序将容器 v 的所有元素写出至标准输出流。

Boost C++ 库

与Boost.Bind 相类似，Boost.Lambda 也定义了三个占位符，名为 _1 , _2 和 _3 。 但与 Boost.Bind 不同的是，这些占位符是定义在单独的名字空间的。 因

此，该例中的第一个占位符是通过 boost::lambda::_1 来引用的。 为了满足编 译器的要求，必须包含相应的头文件 boost/lambda/lambda.hpp 。

虽然代码的位置位于 std::for_each() 的第三个参数处，看起来很怪异，但 Boost.Lambda 可以写出正常的 C++ 代码。 通过使用占位符，容器 v 的元素可 以通过 << 传给 std::cout 以将它们写出到标准输出流。

虽然 Boost.Lambda 非常强大，但也有一些缺点。 要在以上例子中插入换行的话， 必须用 "\n" 来替代 std::endl 才能成功编译。 因为一元 std::endl 模板函数

所要求的类型不同于 lambda 函数 std::cout << boost::lambda::_1 的函数，所以在此不能使用它。

下一个版本的 C++ 标准很可能会将 lambda 函数作为 C++ 语言本身的组成部分加 入，从而消除对单独的库的需要。 但是在下一个版本到来并被不同的编译器厂商所 采用可能还需要好几年。 在此之前，Boost.Lambda 被证明是一个完美的替代品， 从以下例子可以看出，这个例子只将大于1的元素写出到标准输出流。

#include <boost/lambda/lambda.hpp> #include <boost/lambda/if.hpp> #include <iostream>

#include <vector> #include <algorithm>

int main()

{

std::vector<int> v; v.push_back(1); v.push_back(3); v.push_back(2);

std::for_each(v.begin(), v.end(), boost::lambda::if_then(boost::lambda::_1 > 1, std::cout << boost::lambda::_1 << "\n"));

}

下载源代码

头文件 boost/lambda/if.hpp 定义了几个结构，允许在 lambda 函数内部使用

if 语句。 最基本的结构是 boost::lambda::if_then() 模板函数，它要求两 个参数：第一个参数对条件求值 - 如果为真，则执行第二个参数。 如例中所示，每 个参数本身都可以是 lambda 函数。

除了 boost::lambda::if_then() , Boost.Lambda 还提供了 boost::lambda::if_then_else() 和

boost::lambda::if_then_else_return() 模板函数 - 它们都要求三个参数。 另外还提供了用于实现循环、转型操作符，甚至是 throw - 允许 lambda 函数抛 出异常 - 的模板函数。

Boost C++ 库

虽然可以用这些模板函数在 C++ 中构造出复杂的 lambda 函数，但是你必须要考虑 其它方面，如可读性和可维护性。 因为别人需要学习并理解额外的函数，如用

boost::lambda::if_then() 来替代已知的 C++ 关键字 if 和 else ， lambda 函数的好处通常随着它的复杂性而降低。 多数情况下，更为合理的方法是 用熟悉的 C++ 结构定义一个单独的函数。

3.6.练习

You can buy solutions to all exercises in this book as a ZIP file.

1.简化以下程序，将函数对象 divide_by 转换为一个函数，并将 for 循环 替换为用一个标准的 C++ 算法来输出数据：

#include <algorithm> #include <functional> #include <vector> #include <iostream>

class divide_by

: public std::binary_function<int, int, int>

{

public:

int operator()(int n, int div) const

{

return n / div;

}

};

int main()

{

std::vector<int> numbers; numbers.push_back(10); numbers.push_back(20); numbers.push_back(30);

std::transform(numbers.begin(), numbers.end(), numbers.begin(

for (std::vector<int>::iterator it = numbers.begin(); i std::cout << *it << std::endl;

}

下载源代码

2. 简化以下程序，将两个 for 循环都替换为标准的 C++ 算法：

Boost C++ 库

#include <string> #include <vector> #include <iostream>

int main()

{

std::vector<std::string> strings; strings.push_back("Boost"); strings.push_back("C++"); strings.push_back("Libraries");

std::vector<int> sizes;

for (std::vector<std::string>::iterator it = strings.be sizes.push_back(it->size());

for (std::vector<int>::iterator it = sizes.begin(); it std::cout << *it << std::endl;

}

下载源代码

3.简化以下程序，修改变量 processors 的类型，并将 for 循环替换为标准 的 C++ 算法：

#include <vector> #include <iostream> #include <cstdlib> #include <cstring>

int main()

{

std::vector<int(*)(const char*)> processors; processors.push_back(std::atoi); processors.push_back(reinterpret_cast<int(*)(const char*)&

const char data[] = "1.23";

for (std::vector<int(*)(const char*)>::iterator it = pr std::cout << (*it)(data) << std::endl;

}

下载源代码

Boost C++ 库

第 4 章 事件处理

目录

4.1 概述

4.2 信号 Signals

4.3 连接 Connections

4.4 练习

该书采用 Creative Commons License 授权

4.1.概述

很多开发者在听到术语'事件处理'时就会想到GUI：点击一下某个按钮，相关联的功 能就会被执行。 点击本身就是事件，而功能就是相对应的事件处理器。

这一模式的使用当然不仅限于GUI。 一般情况下，任意对象都可以调用基于特定事 件的专门函数。 本章所介绍的 Boost.Signals 库提供了一个简单的方法在 C++ 中应 用这一模式。

严格来说，Boost.Function 库也可以用于事件处理。 不过，Boost.Function 和 Boost.Signals 之间的一个主要区别在于，Boost.Signals 能够将一个以上的事件处 理器关联至单个事件。 因此，Boost.Signals 可以更好地支持事件驱动的开发，当 需要进行事件处理时，应作为第一选择。

4.2. 信号 Signals

虽然这个库的名字乍一看好象有点误导，但实际上并非如此。 Boost.Signals 所实 现的模式被命名为 '信号至插槽' (signal to slot)，它基于以下概念：当对应的信号被 发出时，相关联的插槽即被执行。 原则上，你可以把单词 '信号' 和 '插槽' 分别替换

为'事件' 和 '事件处理器'。 不过，由于信号可以在任意给定的时间发出，所以这一 概念放弃了 '事件' 的名字。

因此，Boost.Signals 没有提供任何类似于 '事件' 的类。 相反，它提供了一个名为

boost::signal 的类，定义于 boost/signal.hpp . 实际上，这个头文件是唯 一一个需要知道的，因为它会自动包含其它相关的头文件。

Boost.Signals 定义了其它一些类，位于 boost::signals 名字空间中。 由于 boost::signal 是最常被用到的类，所以它是位于名字空间 boost 中的。

Boost C++ 库

#include <boost/signal.hpp> #include <iostream>

void func()

{

std::cout << "Hello, world!" << std::endl;

}

int main()

{

boost::signal<void ()> s; s.connect(func);

s();

}

下载源代码

boost::signal 实际上被实现为一个模板函数，具有被用作为事件处理器的函数 的签名，该签名也是它的模板参数。 在这个例子中，只有签名为 void () 的函 数可以被成功关联至信号 s 。

信号是通过调用 s 来触发的，就象普通的函数调用那样。 这个函数的签名对应 于作为模板参数传入的签名：因为 void () 不要求任何参数，所以括号内是空 的。

调用 s 会引发一个触发器，进而执行相应的 func() 函数 - 之前用 connect() 关联了的。

同一例子也可以用 Boost.Function 来实现。

#include <boost/function.hpp> #include <iostream>

void func()

{

std::cout << "Hello, world!" << std::endl;

}

int main()

{

boost::function<void ()> f; f = func;

f();

}

Boost C++ 库

下载源代码

和前一个例子相类似， func() 被关联至 f 。 当 f 被调用时，就会相应地执

行func() 。 Boost.Function 仅限于这种情形下适用，而 Boost.Signals 则提供 了多得多的方式，如关联多个函数至单个特定信号，示例如下。

#include <boost/signal.hpp> #include <iostream>

void func1()

{

std::cout << "Hello" << std::flush;

}

void func2()

{

std::cout << ", world!" << std::endl;

}

int main()

{

boost::signal<void ()> s; s.connect(func1); s.connect(func2);

s();

}

下载源代码

boost::signal 可以通过反复调用 connect() 方法来把多个函数赋值给单个 特定信号。 当该信号被触发时，这些函数被按照之前用 connect() 进行关联时 的顺序来执行。

另外，执行的顺序也可通过 connect() 方法的另一个重载版本来明确指定，该 重载版本要求以一个 int 类型的值作为额外的参数。

Boost C++ 库

这个例子仅输出 Hello ，因为与 func2() 的关联在触发信号之前已经被释放。

除了 connect() 和 disconnect() 以外， boost::signal 还提供了几个方 法。

#include <boost/signal.hpp> #include <iostream>

void func1()

{

std::cout << "Hello" << std::flush;

}

void func2()

{

std::cout << ", world!" << std::endl;

}

int main()

{

boost::signal<void ()> s; s.connect(func1); s.connect(func2);

std::cout << s.num_slots() << std::endl; if (!s.empty())

s(); s.disconnect_all_slots();

}

下载源代码

num_slots() 返回已关联函数的数量。如果没有函数被关联，则

num_slots() 返回0。 在这种特定情况下，可以用 empty() 方法来替代。 disconnect_all_slots() 方法所做的实际上正是它的名字所表达的：释放所有

已有的关联。

看完了函数如何被关联至信号，以及弄明白了信号被触发时会发生什么事之后，还 有一个问题：这些函数的返回值去了哪里？ 以下例子回答了这个问题。

Boost C++ 库

#include <boost/signal.hpp> #include <iostream>

int func1()

{

return 1;

}

int func2()

{

return 2;

}

int main()

{

boost::signal<int ()> s; s.connect(func1); s.connect(func2);

std::cout << s() << std::endl;

}

下载源代码

func1() 和 func2() 都具有 int 类型的返回值。 s 将处理两个返回值， 并将它们都写出至标准输出流。 那么，到底会发生什么呢？

以上例子实际上会把 2 写出至标准输出流。 两个返回值都被 s 正确接收，但 除了最后一个值，其它值都会被忽略。 缺省情况下，所有被关联函数中，实际上只 有最后一个返回值被返回。

你可以定制一个信号，令每个返回值都被相应地处理。 为此，要把一个称为合成器 (combiner)的东西作为第二个参数传递给 boost::signal 。

Boost C++ 库

#include <boost/signal.hpp> #include <iostream> #include <algorithm>

int func1()

{

return 1;

}

int func2()

{

return 2;

}

template <typename T> struct min_element

{

typedef T result_type;

template <typename InputIterator>

T operator()(InputIterator first, InputIterator last) const

{

return *std::min_element(first, last);

}

};

int main()

{

boost::signal<int (), min_element<int> > s; s.connect(func1);

s.connect(func2);

std::cout << s() << std::endl;

}

下载源代码

合成器是一个重载了 operator()() 操作符的类。这个操作符会被自动调用，传 入两个迭代器，指向某个特定信号的所有返回值。 以上例子使用了标准 C++ 算法

std::min_element() 来确定并返回最小的值。

不幸的是，我们不可能把象 std::min_element() 这样的一个算法直接传给

boost::signal 作为一个模板参数。 boost::signal 要求这个合成器定义一 个名为 result_type 的类型，用于说明 operator()() 操作符返回值的类 型。 由于在标准 C++ 算法中缺少这个类型，所以在编译时会产生一个相应的错 误。

除了对返回值进行分析以外，合成器也可以保存它们。

Boost C++ 库

#include <boost/signal.hpp> #include <iostream> #include <vector> #include <algorithm>

int func1()

{

return 1;

}

int func2()

{

return 2;

}

template <typename T> struct min_element

{

typedef T result_type;

template <typename InputIterator>

T operator()(InputIterator first, InputIterator last) const

{

return T(first, last);

}

};

int main()

{

boost::signal<int (), min_element<std::vector<int> > > s; s.connect(func1);

s.connect(func2); std::vector<int> v = s();

std::cout << *std::min_element(v.begin(), v.end()) << std::endl;

}

下载源代码

这个例子把所有返回值保存在一个 vector 中，再由 s() 返回。

4.3. 连接 Connections

函数可以通过由 boost::signal 所提供的 connect() 和 disconnect() 方 法的帮助来进行管理。 由于 connect() 会返回一个类型为

boost::signals::connection 的值，它们可以通过其它方法来管理。

Boost C++ 库

#include <boost/signal.hpp> #include <iostream>

void func()

{

std::cout << "Hello, world!" << std::endl;

}

int main()

{

boost::signal<void ()> s; boost::signals::connection c = s.connect(func); s();

c.disconnect();

}

下载源代码

boost::signal 的 disconnect() 方法需要传入一个函数指针，而直接调用 boost::signals::connection 对象上的 disconnect() 方法则略去该参数。

除了 disconnect() 方法之外， boost::signals::connection 还提供了其它 方法，如 block() 和 unblock() 。

#include <boost/signal.hpp> #include <iostream>

void func()

{

std::cout << "Hello, world!" << std::endl;

}

int main()

{

boost::signal<void ()> s; boost::signals::connection c = s.connect(func); c.block();

s();

c.unblock();

s();

}

下载源代码

以上程序只会执行一次 func() 。 虽然信号 s 被触发了两次，但是在第一次触 发时 func() 不会被调用，因为连接 c 实际上已经被 block() 调用所阻塞。 由于在第二次触发之前调用了 unblock() ，所以之后 func() 被正确地执行。

Boost C++ 库

#include <boost/signal.hpp> #include <boost/bind.hpp> #include <iostream> #include <memory>

class world

{

public:

void hello() const

{

std::cout << "Hello, world!" << std::endl;

}

};

int main()

{

boost::signal<void ()> s;

{

std::auto_ptr<world> w(new world()); s.connect(boost::bind(&world::hello, w.get()));

}

std::cout << s.num_slots() << std::endl; s();

}

下载源代码

以上程序使用 Boost.Bind 将一个对象的方法关联至一个信号。 在信号触发之前， 这个对象就被销毁了，这会产生问题。 我们不传递实际的对象 w ，而只传递一个 指针给 boost::bind() 。 在 s() 被实际调用的时候，该指针所引向的对象已 不再存在。

可以如下修改这个程序，使得一旦对象 w 被销毁，连接就会自动释放。

Boost C++ 库

#include <boost/signal.hpp> #include <boost/bind.hpp> #include <iostream> #include <memory>

class world :

public boost::signals::trackable

{

public:

void hello() const

{

std::cout << "Hello, world!" << std::endl;

}

};

int main()

{

boost::signal<void ()> s;

{

std::auto_ptr<world> w(new world()); s.connect(boost::bind(&world::hello, w.get()));

}

std::cout << s.num_slots() << std::endl; s();

}

下载源代码

如果现在再执行， num_slots() 会返回 0 以确保不会试图调用已销毁对象之上

的方法。 仅需的修改是让 world 类继承自 boost::signals::trackable 。 当使用对象的指针而不是对象的副本来关联函数至信号

时， boost::signals::trackable 可以显著简化连接的管理。

4.4.练习

You can buy solutions to all exercises in this book as a ZIP file.

1.编写一个程序，定义一个名为 button 的类，表示GUI中的一个可点击按 钮。 为该类加入两个方法 add_handler() 和 remove_handler() ，它们 均要求一个函数名作为参数。 如果 click() 方法被调用，已登记的函数将 被按顺序执行。

如下测试你的代码，创建一个 button 类的实例，从事件处理器内部向标准 输出流写出一个信息。 调用 click() 函数模拟用鼠标点击该按钮。

Boost C++ 库

第 5 章 字符串处理

目录

5.1 前言

5.2 区域设置

5.3 字符串算法库 Boost.StringAlgorithms

5.4 正则表达式库 Boost.Regex

5.5 词汇分割器库 Boost.Tokenizer

5.6 格式化输出库 Boost.Format

5.7 练习

该书采用 Creative Commons License 授权

5.1.前言

在标准 C++ 中，用于处理字符串的是 std::string 类，它提供很多字符串操 作，包括查找指定字符或子串的函数。 尽管 std::string 囊括了百余函数，是 标准 C++ 中最为臃肿的类之一，然而却并不能满足很多开发者在日常工作中的需 要。 例如， Java 和 .Net 提供了可以将字符串转换到大写字母的函数，而

std::string 就没有相应的功能。 Boost C++ 库试图弥补这一缺憾。

5.2.区域设置

在进入正题之前，有必要先审视下区域设置的问题，本章中提到的很多函数都需要 一个附加的区域设置参数。

区域设置在标准 C++ 中封装了文化习俗相关的内容，包括货币符号，日期时间格 式， 分隔整数部分与分数部分的符号（基数符）以及多于三个数字时的分隔符（千 位符）。

在字符串处理方面，区域设置和特定文化中对字符次序以及特殊字符的描述有关。 例如，字母表中是否含有变异元音字母以及其在字母表中的位置都由语言文化决 定。

如果一个函数用于将字符串转换为大写形式，那么其实施步骤取决于具体的区域设 置。 在德语中，字母 'ä' 显然要转换为 'Ä'， 然而在其他语言中并不一定。

使用类 std::string 时区域设置可以忽略， 因为它的函数均不依赖于特定语 言。 然而在本章中为了使用 Boost C++ 库， 区域设置的知识是必不可少的。

C++ 标准中在 locale 文件中定义了类 std::locale 。 每个 C++ 程序自动拥 有一个此类的实例， 即不能直接访问的全局区域设置。 如果要访问它，需要使用 默认构造函数构造类 std::locale 的对象，并使用与全局区域设置相同的属性

Boost C++ 库

初始化。

#include <locale> #include <iostream>

int main()

{

std::locale loc;

std::cout << loc.name() << std::endl;

}

下载源代码

以上程序在标准输出流输出 C ，这是基本区域设置的名称，它包括了 C 语言编 写的程序中默认使用的描述。

这也是每个 C++ 应用的默认全局区域设置，它包括了美式文化中使用的描述。 例 如，货币符号使用美元符号，基字符为英文句号，日期中的月份用英语书写。

全局区域设置可以使用类 std::locale 中的静态函数 global() 改变。

#include <locale> #include <iostream>

int main()

{

std::locale::global(std::locale("German")); std::locale loc;

std::cout << loc.name() << std::endl;

}

下载源代码

静态函数 global() 接受一个类型为 std::locale 的对象作为其唯一的参数。 此类的另一个版本的构造函数接受类型为 const char* 的字符串，可以为一个 特别的文化创建区域设置对象。 然而，除了 C 区域设置相应地命名为 "C" 之外， 其他区域设置的名字并没有标准化，所以这依赖于接受区域设置名字的 C++ 标准 库。 在使用 Visual Studio 2008 的情况下，语言字符串文档 指出， 可以使用语言 字符串 "German" 选择定义为德国文化。

执行程序，会输出 German_Germany.1252 。 指定语言字符串为 "German" 等于 选择了德国文化作为主要语言和子语言，这里选择了字符映射 1252。

如果想指定与德国文化不同的子语言设置，例如瑞士语，需要使用不同的语言字符 串。

Boost C++ 库

#include <locale> #include <iostream>

int main()

{

std::locale::global(std::locale("German_Switzerland")); std::locale loc;

std::cout << loc.name() << std::endl;

}

下载源代码

现在程序会输出 German_Switzerland.1252 。

在初步理解了区域设置以及如何更改全局设置后， 下面的例子说明了区域设置如何 影响字符串操作。

#include <locale> #include <iostream> #include <cstring>

int main()

{

std::cout << std::strcoll("ä", "z") << std::endl; std::locale::global(std::locale("German")); std::cout << std::strcoll("ä", "z") << std::endl;

}

下载源代码

本例使用了定义在文件 cstring 中的函数 std::strcoll() ，这个函数用于 按照字典顺序比较第一个字符串是否小于第二个。 换言之，它会判断这两个字符串 中哪一个在字典中靠前。

执行程序，得到结果为 1 和 -1 。 虽然函数的参数是一样的， 却得到了不同 的结果。 原因很简单，在第一次调用函数 std::strcoll() 时，使用了全局 C 区域设置； 而在第二次调用时，全局区域设置更改为德国文化。 从输出中可以看 出，在这两种区域设置中，字符 'ä' 和 'z' 的次序是不同的。

很多 C 函数以及 C++ 流都与区域设置有关。 尽管类 std::string 中的函数是 与区域设置独立工作的， 但是以下各节中提到的函数并不是这样。 所以，在本章 中还会多次提到区域设置的相关内容。

5.3. 字符串算法库 Boost.StringAlgorithms

Boost C++ 库

Boost C++ 字符串算法库 Boost.StringAlgorithms 提供了很多字符串操作函数。 字 符串的类型可以是 std::string ， std::wstring 或任何其他模板类

std::basic_string 的实例。

这些函数分类别在不同的头文件定义。 例如，大小写转换函数定义在文件

boost/algorithm/string/case_conv.hpp 中。 因为 Boost.StringAlgorithms 类中包括超过20个类别和相同数目的头文件， 为了方便起见，头文件

boost/algorithm/string.hpp 包括了所有其他的头文件。 后面所有例子都会 使用这个头文件。

正如上节提到的那样， Boost.StringAlgorithms 库中许多函数 都可以接受一个类型

为std::locale 的对象作为附加参数。 而此参数是可选的，如果不设置将使用 默认全局区域设置。

#include <boost/algorithm/string.hpp> #include <locale>

#include <iostream> #include <clocale>

int main()

{

std::setlocale(LC_ALL, "German"); std::string s = "Boris Schäling";

std::cout << boost::algorithm::to_upper_copy(s) << std::endl; std::cout << boost::algorithm::to_upper_copy(s, std::locale("Ger

}

下载源代码

函数 boost::algorithm::to_upper_copy() 用于 转换一个字符串为大写形 式，自然也有提供相反功能的函数 —— boost::algorithm::to_lower_copy() 把字符串转换为小写形式。 这两个函数都返回转换过的字符串作为结果。 如果作 为参数传入的字符串自身需要被转换为大（小）写形式，可以使用函数

或

上面的例子使用函数 boost::algorithm::to_upper_copy() 把字符串 "Boris Schäling" 转换为大写形式。 第一次调用时使用的是默认全局区域设置， 第二次调 用时则明确将区域设置为德国文化。

显然后者的转换是正确的， 因为小写字母 'ä' 对应的大写形式 'Ä' 是存在的。 而在 C 区域设置中， 'ä' 是一个未知字符所以不能转换。 为了能得到正确结果，必须明

确传递正确的区域设置参数或者在调用 boost::algorithm::to_upper_copy() 之前改变全局区域设置。

可以注意到，程序使用了定义在头文件 clocale 中的函数 std::setlocale()

为C 函数进行区域设置， 因为 std::cout 使用 C 函数在屏幕上显示信息。 在 设置了正确的区域后，才可以正确显示 'ä' 和 'Ä' 等元音字母。

Boost C++ 库

#include <boost/algorithm/string.hpp> #include <locale>

#include <iostream>

int main()

{

std::locale::global(std::locale("German")); std::string s = "Boris Schäling";

std::cout << boost::algorithm::to_upper_copy(s) << std::endl; std::cout << boost::algorithm::to_upper_copy(s, std::locale("Ger

}

下载源代码

上述程序将全局区域设置设为德国文化，这使得对函数 boost::algorithm::to_upper_copy() 的调用 可以将 'ä' 转换为 'Ä' 。

注意到本例并没有调用函数 std::setlocale() 。 使用函数

std::locale::global() 设置全局区域设置后， 也自动进行了 C 区域设置。 实 际上，C++ 程序几乎总是使用函数 std::locale::global() 进行全局区域设 置， 而不是像前面的例子那样使用函数 std::setlocale() 。

#include <boost/algorithm/string.hpp> #include <locale>

#include <iostream>

int main()

{

std::locale::global(std::locale("German")); std::string s = "Boris Schäling";

std::cout << boost::algorithm::erase_first_copy(s, "i") << std:: std::cout << boost::algorithm::erase_nth_copy(s, "i", 0) << std: std::cout << boost::algorithm::erase_last_copy(s, "i") << std::e std::cout << boost::algorithm::erase_all_copy(s, "i") << std::en std::cout << boost::algorithm::erase_head_copy(s, 5) << std::end std::cout << boost::algorithm::erase_tail_copy(s, 8) << std::end

}

下载源代码

Boost.StringAlgorithms 库提供了几个从字符串中删除单独字母的函数， 可以明确 指定在哪里删除，如何删除。例如，可以使用函数

boost::algorithm::erase_all_copy() 从整个字符串中 删除特定的某个字

符。 如果只在此字符首次出现时删除，可以使用函数

Boost C++ 库

boost::algorithm::erase_first_copy() 。 如果要在字符串头部或尾部删除 若干字符，可以使用函数 boost::algorithm::erase_head_copy() 和

。

#include <boost/algorithm/string.hpp> #include <locale>

#include <iostream>

int main()

{

std::locale::global(std::locale("German")); std::string s = "Boris Schäling"; boost::iterator_range<std::string::iterator> r = boost::algorith std::cout << r << std::endl;

r = boost::algorithm::find_first(s, "xyz"); std::cout << r << std::endl;

}

下载源代码

以下各个不同函数 boost::algorithm::find_first() 、 boost::algorithm::find_last() 、 boost::algorithm::find_nth() 、

boost::algorithm::find_head() 以及 boost::algorithm::find_tail() 可以用于在字符串中查找子串。

所有这些函数的共同点是均返回类型为 boost::iterator_range 类 的一对迭代 器。 此类起源于 Boost C++ 的 Boost.Range 库， 它在迭代器的概念上定义了“范

围”。 因为操作符 << 由 boost::iterator_range 类重载而来， 单个 搜索算法的结果可以直接写入标准输出流。 以上程序将 Boris 作为第一个结果 输出而第二个结果为空字符串。

#include <boost/algorithm/string.hpp> #include <locale>

#include <iostream> #include <vector>

int main()

{

std::locale::global(std::locale("German")); std::vector<std::string> v; v.push_back("Boris"); v.push_back("Schäling");

std::cout << boost::algorithm::join(v, " ") << std::endl;

}

下载源代码

Boost C++ 库

函数 boost::algorithm::join() 接受一个字符串的容器 作为第一个参数， 根 据第二个参数将这些字符串连接起来。 相应地这个例子会输出 Boris Schäling

。

#include <boost/algorithm/string.hpp> #include <locale>

#include <iostream>

int main()

{

std::locale::global(std::locale("German")); std::string s = "Boris Schäling";

std::cout << boost::algorithm::replace_first_copy(s, "B", "D") < std::cout << boost::algorithm::replace_nth_copy(s, "B", 0, "D") std::cout << boost::algorithm::replace_last_copy(s, "B", "D") << std::cout << boost::algorithm::replace_all_copy(s, "B", "D") << std::cout << boost::algorithm::replace_head_copy(s, 5, "Doris") std::cout << boost::algorithm::replace_tail_copy(s, 8, "Becker")

}

下载源代码

Boost.StringAlgorithms 库不但提供了查找子串或删除字母的函数， 而且提供了使 用字符串替代子串的函数，包括

boost::algorithm::replace_first_copy() ， boost::algorithm::replace_nth_copy() ， boost::algorithm::replace_last_copy() ， boost::algorithm::replace_all_copy() ， boost::algorithm::replace_head_copy() 以及

boost::algorithm::replace_tail_copy() 等等。 它们的使用方法同查找和删 除函数是差不多一样的，所不同的是还需要 一个替代字符串作为附加参数。

#include <boost/algorithm/string.hpp> #include <locale>

#include <iostream>

int main()

{

std::locale::global(std::locale("German")); std::string s = "\t Boris Schäling \t";

std::cout << "." << boost::algorithm::trim_left_copy(s) << "." < std::cout << "." <<boost::algorithm::trim_right_copy(s) << "." < std::cout << "." <<boost::algorithm::trim_copy(s) << "." << std:

}

下载源代码

Boost C++ 库

可以使用修剪函数 boost::algorithm::trim_left_copy() ， boost::algorithm::trim_right_copy() 以及

boost::algorithm::trim_copy() 等自动去除字符串中的空格或者字符串的结 束符。 什么字符是空格取决于全局区域设置。

Boost.StringAlgorithms 库的函数可以接受一个附加的谓词参数，以决定函数作用 于字符串的哪些字符。 谓词版本的修剪函数相应地被命名为

boost::algorithm::trim_left_copy_if() ，

boost::algorithm::trim_right_copy_if() 和

。

#include <boost/algorithm/string.hpp> #include <locale>

#include <iostream>

int main()

{

std::locale::global(std::locale("German")); std::string s = "--Boris Schäling--";

std::cout << "." << boost::algorithm::trim_left_copy_if(s, boost std::cout << "." <<boost::algorithm::trim_right_copy_if(s, boost std::cout << "." <<boost::algorithm::trim_copy_if(s, boost::algo

}

下载源代码

以上程序调用了一个辅助函数 boost::algorithm::is_any_of() ， 它用于生成 谓词以验证作为参数传入的字符是否在给定的字符串中存在。使用函数

boost::algorithm::is_any_of 后，正如例子中做的那样，修剪字符串的字符被指定为

Boost.StringAlgorithms 类也提供了众多返回通用谓词的辅助函数。

#include <boost/algorithm/string.hpp> #include <locale>

#include <iostream>

int main()

{

std::locale::global(std::locale("German")); std::string s = "123456789Boris Schäling123456789";

std::cout << "." << boost::algorithm::trim_left_copy_if(s, boost std::cout << "." <<boost::algorithm::trim_right_copy_if(s, boost std::cout << "." <<boost::algorithm::trim_copy_if(s, boost::algo

}

下载源代码

Boost C++ 库

函数 boost::algorithm::is_digit() 返回的谓词在字符为数字时返回布尔值 true 。 检查字符是否为大写或小写的辅助函数分别是

boost::algorithm::is_upper() 和 boost::algorithm::is_lower() 。 所

有这些函数都默认使用全局区域设置，除非在参数中指定其他区域设置。

除了检验单独字符的谓词之外， Boost.StringAlgorithms 库还提供了处理字符串的 函数。

#include <boost/algorithm/string.hpp> #include <locale>

#include <iostream>

int main()

{

std::locale::global(std::locale("German")); std::string s = "Boris Schäling";

std::cout << boost::algorithm::starts_with(s, "Boris") << std::e std::cout << boost::algorithm::ends_with(s, "Schäling") << std:: std::cout << boost::algorithm::contains(s, "is") << std::endl; std::cout << boost::algorithm::lexicographical_compare(s, "Boris

}

下载源代码

函数 boost::algorithm::starts_with() 、

boost::algorithm::ends_with() 、 boost::algorithm::contains() 和 boost::algorithm::lexicographical_compare() 均可以比较两个字符串。

以下介绍一个字符串切割函数。

#include <boost/algorithm/string.hpp> #include <locale>

#include <iostream> #include <vector>

int main()

{

std::locale::global(std::locale("German")); std::string s = "Boris Schäling"; std::vector<std::string> v; boost::algorithm::split(v, s, boost::algorithm::is_space()); std::cout << v.size() << std::endl;

}

下载源代码

Boost C++ 库

在给定分界符后，使用函数 boost::algorithm::split() 可以将一个字符串拆 分为一个字符串容器。 它需要给定一个谓词作为第三个参数以判断应该在字符串的

哪个位置分割。 这个例子使用了辅助函数 boost::algorithm::is_space() 创 建一个谓词，在每个空格字符处分割字符串。

本节中许多函数都有忽略字符串大小写的版本， 这些版本一般都有与原函数相似的 名称，所相差的只是以 'i'.开头。 例如，与函数

boost::algorithm::erase_all_copy() 相对应的是函数 boost::algorithm::ierase_all_copy() 。

最后，值得注意的是类 Boost.StringAlgorithms 中许多函数都支持正则表达式。 以 下程序使用函数 boost::algorithm::find_regex() 搜索正则表达式。

#include <boost/algorithm/string.hpp> #include <boost/algorithm/string/regex.hpp> #include <locale>

#include <iostream>

int main()

{

std::locale::global(std::locale("German")); std::string s = "Boris Schäling"; boost::iterator_range<std::string::iterator> r = boost::algorith std::cout << r << std::endl;

}

下载源代码

为了使用正则表达式，此程序使用了Boost C++ 库中的 boost::regex ， 这将在 下一节介绍。

5.4. 正则表达式库 Boost.Regex

Boost C++ 的正则表达式库 Boost.Regex 可以应用正则表达式于 C++ 。 正则表达 式大大减轻了搜索特定模式字符串的负担，在很多语言中都是强大的功能。 虽然现

在C++ 仍然需要以 Boost C++ 库的形式提供这一功能，但是在将来正则表达式将 进入 C++ 标准库。 Boost.Regex 库有望包括在下一版的 C++ 标准中。

Boost.Regex 库中两个最重要的类是 boost::regex 和 boost::smatch ， 它 们都在 boost/regex.hpp 文件中定义。 前者用于定义一个正则表达式，而后者 可以保存搜索结果。

以下将要介绍 Boost.Regex 库中提供的三个搜索正则表达式的函数。

Boost C++ 库

#include <boost/regex.hpp> #include <locale> #include <iostream>

int main()

{

std::locale::global(std::locale("German")); std::string s = "Boris Schäling"; boost::regex expr("\\w+\\s\\w+");

std::cout << boost::regex_match(s, expr) << std::endl;

}

下载源代码

函数 boost::regex_match() 用于字符串与正则表达式的比较。 在整个字符串 匹配正则表达式时其返回值为 true 。

函数 boost::regex_search() 可用于在字符串中搜索正则表达式。

#include <boost/regex.hpp> #include <locale> #include <iostream>

int main()

{

std::locale::global(std::locale("German")); std::string s = "Boris Schäling"; boost::regex expr("(\\w+)\\s(\\w+)"); boost::smatch what;

if (boost::regex_search(s, what, expr))

{

std::cout << what[0] << std::endl;

std::cout << what[1] << " " << what[2] << std::endl;

}

}

下载源代码

函数 boost::regex_search() 可以接受一个类型为 boost::smatch 的引用的 参数用于储存结果。 函数 boost::regex_search() 只用于分类的搜索， 本例实 际上返回了两个结果， 它们是基于正则表达式的分组。

存储结果的类 boost::smatch 事实上是持有类型为 boost::sub_match 的元 素的容器， 可以通过与类 std::vector 相似的界面访问。 例如， 元素可以通过 操作符 operator[]() 访问。

另一方面，类 boost::sub_match 将迭代器保存在对应于正则表达式分组的位 置。 因为它继承自类 std::pair ，迭代器引用的子串可以使用 first 和

second 访问。如果像上面的例子那样，只把子串写入标准输出流， 那么通过重

Boost C++ 库

载操作符 << 就可以直接做到这一点，那么并不需要访问迭代器。

请注意结果保存在迭代器中而 boost::sub_match 类并不复制它们， 这说明它 们只是在被迭代器引用的相关字符串存在时才可以访问。

另外，还需要注意容器 boost::smatch 的第一个元素存储的引用是指向匹配正 则表达式的整个字符串的，匹配第一组的第一个子串由索引 1 访问。

Boost.Regex 提供的第三个函数是 boost::regex_replace() 。

#include <boost/regex.hpp> #include <locale> #include <iostream>

int main()

{

std::locale::global(std::locale("German")); std::string s = " Boris Schäling "; boost::regex expr("\\s");

std::string fmt("_");

std::cout << boost::regex_replace(s, expr, fmt) << std::endl;

}

下载源代码

除了待搜索的字符串和正则表达式之外， boost::regex_replace() 函数还需要 一个格式参数，它决定了子串、匹配正则表达式的分组如何被替换。如果正则表达 式不包含任何分组，相关子串将被用给定的格式一个个地被替换。这样上面程序输

出的结果为 _Boris_Schäling_ 。

boost::regex_replace() 函数总是在整个字符串中搜索正则表达式，所以这个 程序实际上将三处空格都替换为下划线。

#include <boost/regex.hpp> #include <locale> #include <iostream>

int main()

{

std::locale::global(std::locale("German")); std::string s = "Boris Schäling"; boost::regex expr("(\\w+)\\s(\\w+)"); std::string fmt("\\2 \\1");

std::cout << boost::regex_replace(s, expr, fmt) << std::endl;

}

下载源代码

Boost C++ 库

格式参数可以访问由正则表达式分组的子串，这个例子正是使用了这项技术，交换 了姓、名的位置，于是结果显示为 Schäling Boris 。

需要注意的是，对于正则表达式和格式有不同的标准。 这三个函数都可以接受一个 额外的参数，用于选择具体的标准。 也可以指定是否以某一具体格式解释特殊字符 或者替代匹配正则表达式的整个字符串。

#include <boost/regex.hpp> #include <locale> #include <iostream>

int main()

{

std::locale::global(std::locale("German")); std::string s = "Boris Schäling"; boost::regex expr("(\\w+)\\s(\\w+)"); std::string fmt("\\2 \\1");

std::cout << boost::regex_replace(s, expr, fmt, boost::regex_con

}

下载源代码

此程序将 boost::regex_constants::format_literal 标志作为第四参数传递 给函数 boost::regex_replace() ，从而抑制了格式参数中对特殊字符的处理。 因为整个字符串匹配正则表达式，所以本例中经格式参数替换的到达的输出结果为

\2 \1 。

正如上一节末指出的那样，正则表达式可以和 Boost.StringAlgorithms 库结合使 用。它通过 Boost.Regex 库提供函数如 boost::algorithm::find_regex() 、

boost::algorithm::replace_regex() 、 以及

等等。由于 Boost.Regex 库很有可能成为 即将到来的下一版 C++ 标准的一部分，脱离 Boost.StringAlgorithms 库，熟练地使 用正则表达式是个明智的选择。

5.5. 词汇分割器库 Boost.Tokenizer

Boost.Tokenizer 库可以在指定某个字符为分隔符后，遍历字符串的部分表达式。

Boost C++ 库

#include <boost/tokenizer.hpp> #include <string>

#include <iostream>

int main()

{

typedef boost::tokenizer<boost::char_separator<char> > tokenizer std::string s = "Boost C++ libraries";

tokenizer tok(s);

for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it std::cout << *it << std::endl;

}

下载源代码

Boost.Tokenizer 库在 boost/tokenizer.hpp 文件中定义了模板类 boost::tokenizer ，其模板参数为支持相关表达式的类。 上面的例子中就使用

了boost::char_separator 类作为模板参数，它将空格和标点符号视为分隔

符。

词汇分割器必须由类型为 std::string 的字符串初始化。通过使用 begin()

和end() 方法，词汇分割器可以像容器一样访问。通过使用迭代器，可以得到前 述字符串的部分表达式。模板参数的类型决定了如何达到部分表达式。

因为 boost::char_separator 类默认将空格和标点符号视为分隔符，所以本例

std::ispunct 函数。 () Boost.Tokenizer 库会区分要隐藏的分隔符和要显示的 分隔符。 在默认的情况下，空格会隐藏而标点符号会显示出来，所以这个例子里显 示了两个加号。

如果不需要将标点符号作为分隔符，可以在传递给词汇分割器之前相应地初始化 boost::char_separator 对象。 以下例子正式这样做的。

#include <boost/tokenizer.hpp> #include <string>

#include <iostream>

int main()

{

typedef boost::tokenizer<boost::char_separator<char> > tokenizer std::string s = "Boost C++ libraries"; boost::char_separator<char> sep(" ");

tokenizer tok(s, sep);

for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it std::cout << *it << std::endl;

}

Boost C++ 库

下载源代码

类boost::char_separator 的构造函数可以接受三个参数， 只有第一个是必须

的，它描述了需要隐藏的分隔符。 在本例中， 空格仍然被视为分隔符。

第二个参数指定了需要显示的分隔符。 在不提供此参数的情况下，将不显示任何分 隔符。 执行程序，会显示 Boost 、 C++ 和 libraries 。

如果将加号作为第二个参数，此例的结果将和上一个例子相同。

#include <boost/tokenizer.hpp> #include <string>

#include <iostream>

int main()

{

typedef boost::tokenizer<boost::char_separator<char> > tokenizer std::string s = "Boost C++ libraries"; boost::char_separator<char> sep(" ", "+");

tokenizer tok(s, sep);

for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it std::cout << *it << std::endl;

}

下载源代码

第三个参数决定了是否显示空的部分表达式。 如果连续找到两个分隔符，他们之间 的部分表达式将为空。在默认情况下，这些空表达式是不会显示的。第三个参数可 以改变默认的行为。

#include <boost/tokenizer.hpp> #include <string>

#include <iostream>

int main()

{

typedef boost::tokenizer<boost::char_separator<char> > tokenizer std::string s = "Boost C++ libraries"; boost::char_separator<char> sep(" ", "+", boost::keep_empty_toke tokenizer tok(s, sep);

for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it std::cout << *it << std::endl;

}

下载源代码

执行以上程序，会显示另外两个的空表达式。 其中第一个是在两个加号中间的而第 二个是加号和之后的空格之间的。

Boost C++ 库

词汇分割器也可用于不同的字符串类型。

#include <boost/tokenizer.hpp> #include <string>

#include <iostream>

int main()

{

typedef boost::tokenizer<boost::char_separator<wchar_t>, std::ws std::wstring s = L"Boost C++ libraries"; boost::char_separator<wchar_t> sep(L" ");

tokenizer tok(s, sep);

for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it std::wcout << *it << std::endl;

}

下载源代码

这个例子遍历了一个类型为 std::wstring 的字符串。 为了使用这个类型的字符 串，必须使用另外的模板参数初始化词汇分割器，对 boost::char_separator 类也是如此，他们都需要参数 wchar_t 初始化。

除了 boost::char_separator 类之外， Boost.Tokenizer 还提供了另外两个类 以识别部分表达式。

#include <boost/tokenizer.hpp> #include <string>

#include <iostream>

int main()

{

typedef boost::tokenizer<boost::escaped_list_separator<char> > t std::string s = "Boost,\"C++ libraries\"";

tokenizer tok(s);

for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it std::cout << *it << std::endl;

}

下载源代码

boost::escaped_list_separator 类用于读取由逗号分隔的多个值，这个格式 的文件通常称为 CSV （comma separated values，逗号分隔文件），它甚至还可 以处理双引号以及转义序列。所以本例的输出为 Boost 和 C++ libraries 。

另一个是 boost::offset_separator 类，必须用实例说明。 这个类的对象必须 作为第二个参数传递给 boost::tokenizer 类的构造函数。

Boost C++ 库

#include <boost/tokenizer.hpp> #include <string>

#include <iostream>

int main()

{

typedef boost::tokenizer<boost::offset_separator> tokenizer; std::string s = "Boost C++ libraries";

int offsets[] = { 5, 5, 9 };

boost::offset_separator sep(offsets, offsets + 3); tokenizer tok(s, sep);

for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it std::cout << *it << std::endl;

}

下载源代码

boost::offset_separator 指定了部分表达式应当在字符串中的哪个位置结 束。 以上程序制定第一个部分表达式在 5 个字符后结束，第二个字符串在另 5 个 字符后结束，第三个也就是最后一个字符串应当在之后的 9 个字符后结束。 输出的

结果为 Boost 、 C++ 和 libraries 。

5.6. 格式化输出库 Boost.Format

Boost.Format 库可以作为定义在文件 cstdio 中的函数 std::printf() 的替 代。 std::printf() 函数最初出现在 C 标准中，提供格式化数据输出功能， 但 是它既不是类型安全的有不能扩展。 因此在 C++ 应用中， Boost.Format 库通常是 数据格式化输出的上佳之选。

Boost.Format 库在文件 boost/format.hpp 中定义了类 boost::format 。 与 函数 std::printf 相似的是，传递给() boost::format 的构造函数的参数也 是一个字符串，它由控制格式的特殊字符组成。 实际数据通过操作符 % 相连，在 输出中替代特殊字符，如下例所示。

#include <boost/format.hpp> #include <iostream>

int main()

{

std::cout << boost::format("%1%.%2%.%3%") % 16 % 9 % 2008 << std

}

下载源代码

Boost C++ 库

Boost.Format 类使用置于两个百分号之间的数字作为占位符，占位符稍后通过 % 操作符与实际数据连接。 以上程序使用数字16、9 和 2009 组成一个日期字符串，

以16.9.2008 的格式输出。 如果要月份出现在日期之前，即美式表示，只需交 换占位符即可。

#include <boost/format.hpp> #include <iostream>

int main()

{

std::cout << boost::format("%2%/%1%/%3%") % 16 % 9 % 2008 << std

}

下载源代码

现在程序显示的结果变成 9/16/2008 。

如果要使用C++ 操作器格式化数据，Boost.Format 库提供了函数 boost::io::group() 。

#include <boost/format.hpp> #include <iostream>

int main()

{

std::cout << boost::format("%1% %2% %1%") % boost::io::group(std

}

下载源代码

本例的结果显示为 +99 100 +99 。 因为操作器 std::showpos() 通过

boost::io::group() 与数字 99 连接，所以只要显示 99 ， 在它前面就会自动 加上加号。

如果需要加号仅在 99 第一次输出时显示， 则需要改造格式化占位符。

#include <boost/format.hpp> #include <iostream>

int main()

{

std::cout << boost::format("%|1$+| %2% %1%") % 99 % 100 << std::

}

Boost C++ 库

为了将输出格式改为 +99 100 99 ，不但需要将数据的引用符号由 1$ 变为 1% ，还需要在其两侧各添加一个附加的管道符号，即将占位符 %1% 替换为 %|1$+|。

请注意，虽然一般对数据的引用不是必须的，但是所有占位符一定要同时设置为指 定货非指定。 以下例子在执行时会出现错误，因为它给第二个和第三个占位符设置 了引用但是却忽略了第一个。

#include <boost/format.hpp> #include <iostream>

int main()

{

try

{

std::cout << boost::format("%|+| %2% %1%") % 99 % 100 << std::

}

catch (boost::io::format_error &ex)

{

std::cout << ex.what() << std::endl;

}

}

下载源代码

此程序抛出了类型为 boost::io::format_error 的异常。 严格地说， Boost.Format 库抛出的异常为 boost::io::bad_format_string 。 但是由于所

有的异常类都继承自 boost::io::format_error 类，捕捉此类型的异常会轻松 一些。

以下例子演示了不引用数据的方法。

#include <boost/format.hpp> #include <iostream>

int main()

{

std::cout << boost::format("%|+| %|| %||") % 99 % 100 % 99 << st

}

下载源代码

第二、第三个占位符的管道符号可以被安全地省略，因为在这种情况下，他们并不 指定格式。这样的语法看起来很像 std::printf () 的那种。

Boost C++ 库

#include <boost/format.hpp> #include <iostream>

int main()

{

std::cout << boost::format("%+d %d %d") % 99 % 100 % 99 << std::

}

下载源代码

虽然这看起来就像 std::printf() ，但是 Boost.Format 库有类型安全的优点。 格式化字符串中字母 'd' 的使用并不表示输出数字，而是表示 boost::format 类 所使用的内部流对象上的 std::dec() 操作器，它可以使用某些对

std::printf() 函数无意义的格式字符串，如果使用 std::printf() 会导致 程序在运行时崩溃。

#include <boost/format.hpp> #include <iostream>

int main()

{

std::cout << boost::format("%+s %s %s") % 99 % 100 % 99 << std::

}

下载源代码

尽管在 std::printf() 函数中，字母 's' 只用于表示类型为 const char* 的 字符串，然而以上程序却能正常运行。 因为在 Boost.Format 库中，这并不代表强 制为字符串，它会结合适当的操作器，调整内部流的操作模式。 所以即使在这种情 况下， 在内部流中加入数字也是没问题的。

5.7.练习

You can buy solutions to all exercises in this book as a ZIP file.

1.编写程序，从以下 XML 流中提取并显示数据，包括姓名、生日以及账户余

额。

<person><name>Karl-Heinz Huber</name><dob&g

。

姓、名要分开显示，生日使用 “日.月.年” 的格式，账户余额忽略小数位。 使用 其他 XML 流测试你的程序，如包含多余空白、其他名字、账户余额为负数等 等的 XML 流。

Boost C++ 库

2.编写程序，使得格式与显示的数据记录如下：输入

Munich Hamburg 92.12 8:25 9:45 ， 这条记录表示从 Munich 到 Hamburg 的航班票价为 92.12 欧元，上午 8:25 起飞 9:45 到达目的地。要得

到以下输出 Munich -> Hamburg 92.12 EUR (08:25-09:45) 。

具体地说，城市名称长度为10并且左对齐而票价长度为7并且右对齐，货币在 价格后显示。 起飞与降落时间一起显示在圆括号中，以连字符分隔，不留空 格。对早于10点（上午或下午）的时间，必须在前面补0。 用不同的数据记录 测试你的程序，例如使用长度大于10的城市名。

Boost C++ 库

第 6 章 多线程

目录

6.1 概述

6.2 线程管理

6.3 同步

6.4 线程本地存储

6.5 练习

该书采用 Creative Commons License 授权

6.1.概述

线程就是，在同一程序同一时间内允许执行不同函数的离散处理队列。 这使得一个 长时间去进行某种特殊运算的函数在执行时不阻碍其他的函数变得十分重要。 线程 实际上允许同时执行两种函数，而这两个函数不必相互等待。

一旦一个应用程序启动，它仅包含一个默认线程。 此线程执行 main() 函数。 在

main() 中被调用的函数则按这个线程的上下文顺序地执行。 这样的程序称为单 线程程序。

反之，那些创建新的线程的程序就是多线程程序。 他们不仅可以在同一时间执行多 个函数，而且这在如今多核盛行的时代显得尤为重要。 既然多核允许同时执行多个 函数，这就使得对开发人员相应地使用这种处理能力提出了要求。 然而线程一直被 用来当并发地执行多个函数，开发人员现在不得不仔细地构建应用来支持这种并 发。 多线程编程知识也因此在多核系统时代变得越来越重要。

本章将介绍C++ Boost库 Boost.Thread，它可以开发独立于平台的多线程应用程 序。

6.2.线程管理

在这个库最重要的一个类就是 boost::thread ，它是在 boost/thread.hpp 里定义的，用来创建一个新线程。下面的示例来说明如何运用它。

Boost C++ 库

#include <boost/thread.hpp> #include <iostream>

void wait(int seconds)

{

boost::this_thread::sleep(boost::posix_time::seconds(seconds));

}

void thread()

{

for (int i = 0; i < 5; ++i)

{

wait(1);

std::cout << i << std::endl;

}

}

int main()

{

boost::thread t(thread); t.join();

}

下载源代码

新建线程里执行的那个函数的名称被传递到 boost::thread 的构造函数。 一旦 上述示例中的变量 t 被创建，该 thread() 函数就在其所在线程中被立即执 行。 同时在 main() 里也并发地执行该 thread() 。

为了防止程序终止，就需要对新建线程调用 join() 方法。 join() 方法是一 个阻塞调用：它可以暂停当前线程，直到调用 join() 的线程运行结束。 这就使

得main() 函数一直会等待到 thread() 运行结束。

正如在上面的例子中看到，一个特定的线程可以通过诸如 t 的变量访问，通过这 个变量等待着它的使用 join() 方法终止。 但是，即使 t 越界或者析构了，该 线程也将继续执行。 一个线程总是在一开始就绑定到一个类型为

boost::thread 的变量，但是一旦创建，就不在取决于它。 甚至还存在着一个

叫detach() 的方法，允许类型为 boost::thread 的变量从它对应的线程里

分离。 当然了，像 join() 的方法之后也就不能被调用，因为这个变量不再是一 个有效的线程。

任何一个函数内可以做的事情也可以在一个线程内完成。 归根结底，一个线程只不 过是一个函数，除了它是同时执行的。 在上述例子中，使用一个循环把5个数字写 入标准输出流。 为了减缓输出，每一个循环中调用 wait() 函数让执行延迟了一 秒。 wait() 可以调用一个名为 sleep() 的函数，这个函数也来自于

Boost.Thread，位于 boost::this_thread 名空间内。

Boost C++ 库

sleep() 要么在预计的一段时间或一个特定的时间点后时才让线程继续执行。 通 过传递一个类型为 boost::posix_time::seconds 的对象，在这个例子里我们 指定了一段时间。 boost::posix_time::seconds 来自于 Boost.DateTime 库， 它被 Boost.Thread 用来管理和处理时间的数据。

虽然前面的例子说明了如何等待一个不同的线程，但下面的例子演示了如何通过所 谓的中断点让一个线程中断。

#include <boost/thread.hpp> #include <iostream>

void wait(int seconds)

{

boost::this_thread::sleep(boost::posix_time::seconds(seconds));

}

void thread()

{

try

{

for (int i = 0; i < 5; ++i)

{

wait(1);

std::cout << i << std::endl;

}

}

catch (boost::thread_interrupted&)

{

}

}

int main()

{

boost::thread t(thread); wait(3); t.interrupt(); t.join();

}

下载源代码

在一个线程对象上调用 interrupt() 会中断相应的线程。 在这方面，中断意味 着一个类型为 boost::thread_interrupted 的异常，它会在这个线程中抛出。 然后这只有在线程达到中断点时才会发生。

如果给定的线程不包含任何中断点，简单调用 interrupt() 就不会起作用。 每 当一个线程中断点，它就会检查 interrupt() 是否被调用过。 只有被调用过

了， boost::thread_interrupted 异常才会相应地抛出。

Boost C++ 库

Boost.Thread定义了一系列的中断点，例如 sleep() 函数。 由于 sleep() 在 这个例子里被调用了五次，该线程就检查了五次它是否应该被中断。 然而

sleep() 之间的调用，却不能使线程中断。

一旦该程序被执行，它只会打印三个数字到标准输出流。 这是由于在main里3秒后 调用 interrupt() 方法。 因此，相应的线程被中断，并抛出一个

boost::thread_interrupted 异常。 这个异常在线程内也被正确地捕获， catch 处理虽然是空的。 由于 thread() 函数在处理程序后返回，线程也被终

止。 这反过来也将终止整个程序，因为 main() 等待该线程使用join（）终止该 线程。

Boost.Thread定义包括上述 sleep() 函数十个中断。 有了这些中断点，线程可以 很容易及时中断。 然而，他们并不总是最佳的选择，因为中断点必须事前读入以检

查boost::thread_interrupted 异常。

为了提供一个对 Boost.Thread 里提供的多种函数的整体概述，下面的例子将会再 介绍两个。

#include <boost/thread.hpp> #include <iostream>

int main()

{

std::cout << boost::this_thread::get_id() << std::endl; std::cout << boost::thread::hardware_concurrency() << std::endl;

}

下载源代码

使用 boost::this_thread 命名空间，能提供独立的函数应用于当前线程，比如 前面出现的 sleep() 。 另一个是 get_id() ：它会返回一个当前线程的ID号。 它也是由 boost::thread 提供的。

boost::thread 类提供了一个静态方法 hardware_concurrency() ，它能够 返回基于CPU数目或者CPU内核数目的刻在同时在物理机器上运行的线程数。 在 常用的双核机器上调用这个方法，返回值为2。 这样的话就可以确定在一个多核程 序可以同时运行的理论最大线程数。

6.3.同步

虽然多线程的使用可以提高应用程序的性能，但也增加了复杂性。 如果使用线程在 同一时间执行几个函数，访问共享资源时必须相应地同步。 一旦应用达到了一定规 模，这涉及相当一些工作。 本段介绍了Boost.Thread提供同步线程的类。

Boost C++ 库

#include <boost/thread.hpp> #include <iostream>

void wait(int seconds)

{

boost::this_thread::sleep(boost::posix_time::seconds(seconds));

}

boost::mutex mutex;

void thread()

{

for (int i = 0; i < 5; ++i)

{

wait(1);

mutex.lock();

std::cout << "Thread " << boost::this_thread::get_id() << ": " mutex.unlock();

}

}

int main()

{

boost::thread t1(thread); boost::thread t2(thread); t1.join();

t2.join();

}

下载源代码

多线程程序使用所谓的互斥对象来同步。 Boost.Thread提供多个的互斥

类， boost::mutex 是最简单的一个。 互斥的基本原则是当一个特定的线程拥有 资源的时候防止其他线程夺取其所有权。 一旦释放，其他的线程可以取得所有权。 这将导致线程等待至另一个线程完成处理一些操作，从而相应地释放互斥对象的所 有权。

上面的示例使用一个类型为 boost::mutex 的 mutex 全局互斥对象。

thread() 函数获取此对象的所有权才在 for 循环内使用 lock() 方法写入 到标准输出流的。 一旦信息被写入，使用 unlock() 方法释放所有权。

main() 创建两个线程，同时执行 thread () 函数。 利用 for 循环，每个线 程数到5，用一个迭代器写一条消息到标准输出流。 不幸的是，标准输出流是一个 全局性的被所有线程共享的对象。 该标准不提供任何保证 std::cout 可以安全 地从多个线程访问。 因此，访问标准输出流必须同步：在任何时候，只有一个线程 可以访问 std::cout 。

Boost C++ 库

由于两个线程试图在写入标准输出流前获得互斥体，实际上只能保证一次只有一个 线程访问 std::cout 。 不管哪个线程成功调用 lock() 方法，其他所有线程必 须等待，直到 unlock() 被调用。

获取和释放互斥体是一个典型的模式，是由Boost.Thread通过不同的数据类型支 持。 例如，不直接地调用 lock() 和 unlock() ，使用 boost::lock_guard 类也是可以的。

#include <boost/thread.hpp> #include <iostream>

void wait(int seconds)

{

boost::this_thread::sleep(boost::posix_time::seconds(seconds));

}

boost::mutex mutex;

void thread()

{

for (int i = 0; i < 5; ++i)

{

wait(1);

boost::lock_guard<boost::mutex> lock(mutex);

std::cout << "Thread " << boost::this_thread::get_id() << ": "

}

}

int main()

{

boost::thread t1(thread); boost::thread t2(thread); t1.join();

t2.join();

}

下载源代码

boost::lock_guard 在其内部构造和析构函数分别自动调用 lock() 和 unlock() 。 访问共享资源是需要同步的，因为它显示地被两个方法调用。 boost::lock_guard 类是另一个出现在 第 2 章 智能指针 的RAII用语。

除了 boost::mutex 和 boost::lock_guard 之外，Boost.Thread也提供其他 的类支持各种同步。 其中一个重要的就是 boost::unique_lock ，相比较

boost::lock_guard 而言，它提供许多有用的方法。

Boost C++ 库

#include <boost/thread.hpp> #include <iostream>

void wait(int seconds)

{

boost::this_thread::sleep(boost::posix_time::seconds(seconds));

}

boost::timed_mutex mutex;

void thread()

{

for (int i = 0; i < 5; ++i)

{

wait(1);

boost::unique_lock<boost::timed_mutex> lock(mutex, boost::try_ if (!lock.owns_lock())

lock.timed_lock(boost::get_system_time() + boost::posix_time std::cout << "Thread " << boost::this_thread::get_id() << ": " boost::timed_mutex *m = lock.release();

m->unlock();

}

}

int main()

{

boost::thread t1(thread); boost::thread t2(thread); t1.join();

t2.join();

}

下载源代码

上面的例子用不同的方法来演示 boost::unique_lock 的功能。 当然了，这些 功能的用法对给定的情景不一定适用； boost::lock_guard 在上个例子的用法 还是挺合理的。 这个例子就是为了演示 boost::unique_lock 提供的功能。

boost::unique_lock 通过多个构造函数来提供不同的方式获得互斥体。 这个期 望获得互斥体的函数简单地调用了 lock() 方法，一直等到获得这个互斥体。 所

以它的行为跟 boost::lock_guard 的那个是一样的。

如果第二个参数传入一个 boost::try_to_lock 类型的值，对应的构造函数就会 调用 try_lock() 方法。 这个方法返回 bool 型的值：如果能够获得互斥体则 返回 true ，否则返回 false 。 相比 lock() 函数， try_lock() 会立即返 回，而且在获得互斥体之前不会被阻塞。

Boost C++ 库

上面的程序向 boost::unique_lock 的构造函数的第二个参数传

入boost::try_to_lock 。 然后通过 owns_lock() 可以检查是否可获得互斥 体。 如果不能， owns_lock() 返回 false 。 这也用到 boost::unique_lock 提供的另外一个函数： timed_lock() 等待一定的时间

以获得互斥体。 给定的程序等待长达1秒，应较足够的时间来获取更多的互斥。

其实这个例子显示了三个方法获取一个互斥体： lock() 会一直等待，直到获得 一个互斥体。 try_lock() 则不会等待，但如果它只会在互斥体可用的时候才能 获得，否则返回 false 。 最后， timed_lock() 试图获得在一定的时间内获取 互斥体。 和 try_lock() 一样，返回 bool 类型的值意味着成功是否。

虽然 boost::mutex 提供了 lock() 和 try_lock() 两个方法，但是

boost::timed_mutex 只支持 timed_lock() ，这就是上面示例那么使用的原 因。 如果不用 timed_lock() 的话，也可以像以前的例子那样用

boost::mutex 。

就像 boost::lock_guard 一样， boost::unique_lock 的析构函数也会相应 地释放互斥量。此外，可以手动地用 unlock() 释放互斥量。也可以像上面的例 子那样，通过调用 release() 解除 boost::unique_lock 和互斥量之间的关 联。然而在这种情况下，必须显式地调用 unlock() 方法来释放互斥量，因为 的析构函数不再做这件事情。

boost::unique_lock 这个所谓的独占锁意味着一个互斥量同时只能被一个线程 获取。 其他线程必须等待，直到互斥体再次被释放。 除了独占锁，还有非独占 锁。 Boost.Thread里有个 boost::shared_lock 的类提供了非独占锁。 正如下 面的例子，这个类必须和 boost::shared_mutex 型的互斥量一起使用。

#include <boost/thread.hpp> #include <iostream> #include <vector> #include <cstdlib> #include <ctime>

void wait(int seconds)

{

boost::this_thread::sleep(boost::posix_time::seconds(seconds));

}

boost::shared_mutex mutex; std::vector<int> random_numbers;

void fill()

{

std::srand(static_cast<unsigned int>(std::time(0))); for (int i = 0; i < 3; ++i)

{

boost::unique_lock<boost::shared_mutex> lock(mutex); random_numbers.push_back(std::rand()); lock.unlock();

wait(1);

Boost C++ 库

}

}

void print()

{

for (int i = 0; i < 3; ++i)

{

wait(1);

boost::shared_lock<boost::shared_mutex> lock(mutex); std::cout << random_numbers.back() << std::endl;

}

}

int sum = 0;

void count()

{

for (int i = 0; i < 3; ++i)

{

wait(1);

boost::shared_lock<boost::shared_mutex> lock(mutex); sum += random_numbers.back();

}

}

int main()

{

boost::thread t1(fill); boost::thread t2(print); boost::thread t3(count); t1.join();

t2.join();

t3.join();

std::cout << "Sum: " << sum << std::endl;

}

下载源代码

boost::shared_lock 类型的非独占锁可以在线程只对某个资源读访问的情况下 使用。 一个线程修改的资源需要写访问，因此需要一个独占锁。 这样做也很明 显：只需要读访问的线程不需要知道同一时间其他线程是否访问。 因此非独占锁可 以共享一个互斥体。

在给定的例子， print() 和 count() 都可以只读访问 random_numbers 。 虽然 print() 函数把 random_numbers 里的最后一个数写到标准输

出， count() 函数把它统计到 sum 变量。 由于没有函数修改

random_numbers ，所有的都可以在同一时间用 boost::shared_lock 类型的 非独占锁访问它。

Boost C++ 库

在fill() 函数里，需要用一个 boost::unique_lock 类型的非独占锁，因为 它插入了一个新的随机数到 random_numbers 。 在 unlock() 显式地调用 unlock() 来释放互斥量之后， fill() 等待了一秒。 相比于之前的那个样

子， 在 for 循环的尾部调用 wait() 以保证容器里至少存在一个随机数，可以

被print() 或者 count() 访问。 对应地，这两个函数在 for 循环的开始调 用了 wait() 。

考虑到在不同的地方每个单独地调用 wait() ，一个潜在的问题变得很明显:函数 调用的顺序直接受CPU执行每个独立进程的顺序决定。 利用所谓的条件变量，可以 同步哪些独立的线程，使数组的每个元素都被不同的线程立即添加到

random_numbers 。

Boost C++ 库

#include <boost/thread.hpp> #include <iostream> #include <vector> #include <cstdlib> #include <ctime>

boost::mutex mutex; boost::condition_variable_any cond; std::vector<int> random_numbers;

void fill()

{

std::srand(static_cast<unsigned int>(std::time(0))); for (int i = 0; i < 3; ++i)

{

boost::unique_lock<boost::mutex> lock(mutex); random_numbers.push_back(std::rand()); cond.notify_all();

cond.wait(mutex);

}

}

void print()

{

std::size_t next_size = 1; for (int i = 0; i < 3; ++i)

{

boost::unique_lock<boost::mutex> lock(mutex); while (random_numbers.size() != next_size)

cond.wait(mutex);

std::cout << random_numbers.back() << std::endl; ++next_size;

cond.notify_all();

}

}

int main()

{

boost::thread t1(fill); boost::thread t2(print); t1.join();

t2.join();

}

下载源代码

这个例子的程序删除了 wait() 和 count() 。线程不用在每个循环迭代中等待 一秒，而是尽可能快地执行。此外，没有计算总额；数字完全写入标准输出流。

为确保正确地处理随机数，需要一个允许检查多个线程之间特定条件的条件变量来 同步不每个独立的线程。

Boost C++ 库

正如上面所说， fill() 函数用在每个迭代产生一个随机数，然后放在

random_numbers 容器中。 为了防止其他线程同时访问这个容器，就要相应得使 用一个排它锁。 不是等待一秒，实际上这个例子却用了一个条件变量。 调用

notify_all() 会唤醒每个哪些正在分别通过调用 wait() 等待此通知的线程。

通过查看 print() 函数里的 for 循环，可以看到相同的条件变量被 wait() 函数调用了。 如果这个线程被 notify_all() 唤醒，它就会试图这个互斥量，但 只有在 fill() 函数完全释放之后才能成功。

这里的窍门就是调用 wait() 会释放相应的被参数传入的互斥量。 在调用

notify_all() 后， fill() 函数会通过 wait() 相应地释放线程。 然后它会 阻止和等待其他的线程调用 notify_all() ，一旦随机数已写入标准输出流，这 就会在 print() 里发生。

注意到在 print() 函数里调用 wait() 事实上发生在一个单独 while 循环 里。 这样做的目的是为了处理在 print() 函数里第一次调用 wait() 函数之 前随机数已经放到容器里。 通过比较 random_numbers 里元素的数目与预期值， 发现这成功地处理了把随机数写入到标准输出流。

6.4.线程本地存储

线程本地存储（TLS）是一个只能由一个线程访问的专门的存储区域。 TLS的变量 可以被看作是一个只对某个特定线程而非整个程序可见的全局变量。 下面的例子显 示了这些变量的好处。

Boost C++ 库

#include <boost/thread.hpp> #include <iostream> #include <cstdlib> #include <ctime>

void init_number_generator()

{

static bool done = false; if (!done)

{

done = true;

std::srand(static_cast<unsigned int>(std::time(0)));

}

}

boost::mutex mutex;

void random_number_generator()

{

init_number_generator(); int i = std::rand();

boost::lock_guard<boost::mutex> lock(mutex); std::cout << i << std::endl;

}

int main()

{

boost::thread t[3];

for (int i = 0; i < 3; ++i)

t[i] = boost::thread(random_number_generator);

for (int i = 0; i < 3; ++i) t[i].join();

}

下载源代码

该示例创建三个线程，每个线程写一个随机数到标准输出流。

random_number_generator() 函数将会利用在C++标准里定义的 std::rand() 函数创建一个随机数。 但是用于 std::rand() 的随机数产生器

必须先用 std::srand() 正确地初始化。 如果没做，程序始终打印同一个随机 数。

随机数产生器，通过 std::time() 返回当前时间， 在

init_number_generator() 函数里完成初始化。 由于这个值每次都不同，可以

保证产生器总是用不同的值初始化，从而产生不同的随机数。 因为产生器只要初始

Boost C++ 库

如果程序运行了多次，写入的三分之二的随机数显然就会相同。 事实上这个程序有 个缺陷： std::rand() 所用的产生器必须被各个线程初始化。 因此

init_number_generator() 的实现实际上是不对的，因为它只调用了一次 std::srand() 。使用TLS，这一缺陷可以得到纠正。

#include <boost/thread.hpp> #include <iostream> #include <cstdlib> #include <ctime>

void init_number_generator()

{

static boost::thread_specific_ptr<bool> tls; if (!tls.get())

tls.reset(new bool(false)); if (!*tls)

{

*tls = true;

std::srand(static_cast<unsigned int>(std::time(0)));

}

}

boost::mutex mutex;

void random_number_generator()

{

init_number_generator(); int i = std::rand();

boost::lock_guard<boost::mutex> lock(mutex); std::cout << i << std::endl;

}

int main()

{

boost::thread t[3];

for (int i = 0; i < 3; ++i)

t[i] = boost::thread(random_number_generator);

for (int i = 0; i < 3; ++i) t[i].join();

}

下载源代码

用一个TLS变量 tls 代替静态变量 done ，是基于用 bool 类型实例化的

boost::thread_specific_ptr 。 原则上， tls 工作起来就像 done ：它 可以作为一个条件指明随机数发生器是否被初始化。 但是关键的区别，就是 tls 存储的值只对相应的线程可见和可用。

Boost C++ 库

一旦一个 boost::thread_specific_ptr 型的变量被创建，它可以相应地设 置。 不过，它期望得到一个 bool 型变量的地址，而非它本身。使用 reset() 方法，可以把它的地址保存到 tls 里面。 在给出的例子中，会动态地分配一个

bool 型的变量，由 new 返回它的地址，并保存到 tls 里。 为了避免每次调

用init_number_generator() 都设置 tls ，它会通过 get() 函数检查是否

已经保存了一个地址。

由于 boost::thread_specific_ptr 保存了一个地址，它的行为就像一个普通 的指针。 因此， operator*() 和 operator->() 都被被重载以方便使用。 这个例子用 *tls 检查这个条件当前是 true 还是 false 。 再根据当前的条 件，随机数生成器决定是否初始化。

正如所见， boost::thread_specific_ptr 允许为当前进程保存一个对象的地 址，然后只允许当前进程获得这个地址。 然而，当一个线程已经成功保存这个地 址，其他的线程就会可能就失败。

如果程序正在执行时，它可能会令人感到奇怪：尽管有了TLS的变量，生成的随机 数仍然相等。 这是因为，三个线程在同一时间被创建，从而造成随机数生成器在同 一时间初始化。 如果该程序执行了几次，随机数就会改变，这就表明生成器初始化 正确了。

6.5.练习

You can buy solutions to all exercises in this book as a ZIP file.

1.重构下面的程序用两个线程来计算总和。由于现在许多处理器有两个内核，应 利用线程减少执行时间。

#include <boost/date_time/posix_time/posix_time.hpp> #include <boost/cstdint.hpp>

#include <iostream>

int main()

{

boost::posix_time::ptime start = boost::posix_time::microsec_

boost::uint64_t sum = 0;

for (int i = 0; i < 1000000000; ++i) sum += i;

boost::posix_time::ptime end = boost::posix_time::microsec_cl std::cout << end - start << std::endl;

std::cout << sum << std::endl;

}

下载源代码

Boost C++ 库

2.通过利用处理器尽可能同时执行多的线程，把例1一般化。 例如，如果处理器 有四个内核，就应该利用四个线程。

3.修改下面的程序，在 main() 中自己的线程中执行 thread() 。 程序应该

能够计算总和，然后把结果输入到标准输出两次。 但可以更改

calculate() ， print() 和 thread() 的实现，每个函数的接口仍需保 持一致。 也就是说每个函数应该仍然没有任何参数，也不需要返回一个值。

#include <iostream>

int sum = 0;

void calculate()

{

for (int i = 0; i < 1000; ++i) sum += i;

}

void print()

{

std::cout << sum << std::endl;

}

void thread()

{

calculate();

print();

}

int main()

{

thread();

}

下载源代码

Boost C++ 库

第 7 章 异步输入输出

目录

7.1 概述

7.2 I/O 服务与 I/O 对象

7.3 可扩展性与多线程

7.4 网络编程

7.5 开发 Boost.Asio 扩展

7.6 练习

该书采用 Creative Commons License 授权

7.1.概述

本章介绍了 Boost C++ 库 Asio，它是异步输入输出的核心。 名字本身就说明了一 切：Asio 意即异步输入/输出。 该库可以让 C++ 异步地处理数据，且平台独立。 异步数据处理就是指，任务触发后不需要等待它们完成。 相反，Boost.Asio 会在任 务完成时触发一个应用。 异步任务的主要优点在于，在等待任务完成时不需要阻塞 应用程序，可以去执行其它任务。

异步任务的典型例子是网络应用。 如果数据被发送出去了，比如发送至 Internet， 通常需要知道数据是否发送成功。 如果没有一个象 Boost.Asio 这样的库，就必须 对函数的返回值进行求值。 但是，这样就要求待至所有数据发送完毕，并得到一个 确认或是错误代码。 而使用 Boost.Asio，这个过程被分为两个单独的步骤：第一步 是作为一个异步任务开始数据传输。 一旦传输完成，不论成功或是错误，应用程序 都会在第二步中得到关于相应的结果通知。 主要的区别在于，应用程序无需阻塞至 传输完成，而可以在这段时间里执行其它操作。

7.2. I/O 服务与 I/O 对象

使用 Boost.Asio 进行异步数据处理的应用程序基于两个概念：I/O 服务和 I/O 对 象。 I/O 服务抽象了操作系统的接口，允许第一时间进行异步数据处理，而 I/O 对 象则用于初始化特定的操作。 鉴于 Boost.Asio 只提供了一个名为

boost::asio::io_service 的类作为 I/O 服务，它针对所支持的每一个操作系 统都分别实现了优化的类，另外库中还包含了针对不同 I/O 对象的几个类。 其中， 类 boost::asio::ip::tcp::socket 用于通过网络发送和接收数据，而类

boost::asio::deadline_timer 则提供了一个计时器，用于测量某个固定时间 点到来或是一段指定的时长过去了。 以下第一个例子中就使用了计时器，因为与 Asio 所提供的其它 I/O 对象相比较而言，它不需要任何有关于网络编程的知识。

Boost C++ 库

#include <boost/asio.hpp> #include <iostream>

void handler(const boost::system::error_code &ec)

{

std::cout << "5 s." << std::endl;

}

int main()

{

boost::asio::io_service io_service;

boost::asio::deadline_timer timer(io_service, boost::posix_time: timer.async_wait(handler);

io_service.run();

}

下载源代码

函数 main() 首先定义了一个 I/O 服务 io_service ，用于初始化 I/O 对象

timer 。 就象 boost::asio::deadline_timer 那样，所有 I/O 对象通常都需 要一个 I/O 服务作为它们的构造函数的第一个参数。 由于 timer 的作用类似于

一个闹钟，所以 boost::asio::deadline_timer 的构造函数可以传入第二个参 数，用于表示在某个时间点或是在某段时长之后闹钟停止。 以上例子指定了五秒的 时长，该闹钟在 timer 被定义之后立即开始计时。

虽然我们可以调用一个在五秒后返回的函数，但是通过调用方法 async_wait() 并传入 handler() 函数的名字作为唯一参数，可以让 Asio 启动一个异步操作。 请留意，我们只是传入了 handler() 函数的名字，而该函数本身并没有被调 用。

async_wait() 的好处是，该函数调用会立即返回，而不是等待五秒钟。 一旦闹 钟时间到，作为参数所提供的函数就会被相应调用。 因此，应用程序可以在调用了

async_wait() 之后执行其它操作，而不是阻塞在这里。

象async_wait() 这样的方法被称为是非阻塞式的。 I/O 对象通常还提供了阻塞 式的方法，可以让执行流在特定操作完成之前保持阻塞。 例如，可以调用阻塞式的

wait() 方法，取代 boost::asio::deadline_timer 的调用。 由于它会阻塞 调用，所以它不需要传入一个函数名，而是在指定时间点或指定时长之后返回。

再看看上面的源代码，可以留意到在调用 async_wait() 之后，又在 I/O 服务之 上调用了一个名为 run() 的方法。这是必须的，因为控制权必须被操作系统接 管，才能在五秒之后调用 handler() 函数。

async_wait() 会启动一个异步操作并立即返回，而 run() 则是阻塞的。因此 调用 run() 后程序执行会停止。 具有讽刺意味的是，许多操作系统只是通过阻 塞函数来支持异步操作。 以下例子显示了为什么这个限制通常不会成为问题。

Boost C++ 库

#include <boost/asio.hpp> #include <iostream>

void handler1(const boost::system::error_code &ec)

{

std::cout << "5 s." << std::endl;

}

void handler2(const boost::system::error_code &ec)

{

std::cout << "10 s." << std::endl;

}

int main()

{

boost::asio::io_service io_service;

boost::asio::deadline_timer timer1(io_service, boost::posix_time timer1.async_wait(handler1);

boost::asio::deadline_timer timer2(io_service, boost::posix_time timer2.async_wait(handler2);

io_service.run();

}

下载源代码

上面的程序用了两个 boost::asio::deadline_timer 类型的 I/O 对象。 第一个 I/O 对象表示一个五秒后触发的闹钟，而第二个则表示一个十秒后触发的闹钟。 每 一段指定时长过去后，都会相应地调用函数 handler1() 和 handler2() 。

在main() 的最后，再次在唯一的 I/O 服务之上调用了 run() 方法。 如前所 述，这个函数将阻塞执行，把控制权交给操作系统以接管异步处理。 在操作系统的 帮助下， handler1() 函数会在五秒后被调用，而 handler2() 函数则在十秒 后被调用。

乍一看，你可能会觉得有些奇怪，为什么异步处理还要调用阻塞式的 run() 方 法。 然而，由于应用程序必须防止被中止执行，所以这样做实际上不会有任何问 题。 如果 run() 不是阻塞的， main() 就会结束从而中止该应用程序。 如果应 用程序不应被阻塞，那么就应该在一个新的线程内部调用 run() ，它自然就会仅 仅阻塞那个线程。

一旦特定的 I/O 服务的所有异步操作都完成了，控制权就会返回给 run() 方法， 然后它就会返回。 以上两个例子中，应用程序都会在闹钟到时间后马上结束。

7.3.可扩展性与多线程

Boost C++ 库

用Boost.Asio 这样的库来开发应用程序，与一般的 C++ 风格不同。 那些可能需要 较长时间才返回的函数不再是以顺序的方式来调用。 不再是调用阻塞式的函数， Boost.Asio 是启动一个异步操作。 而那些需要在操作结束后调用的函数则实现为相 应的句柄。 这种方法的缺点是，本来顺序执行的功能变得在物理上分割开来了，从 而令相应的代码更难理解。

象Boost.Asio 这样的库通常是为了令应用程序具有更高的效率。 应用程序不需要 等待特定的函数执行完成，而可以在期间执行其它任务，如开始另一个需要较长时 间的操作。

可扩展性是指，一个应用程序从新增资源有效地获得好处的能力。 如果那些执行时 间较长的操作不应该阻塞其它操作的话，那么建议使用 Boost.Asio. 由于现今的PC 机通常都具有多核处理器，所以线程的应用可以进一步提高一个基于 Boost.Asio 的 应用程序的可扩展性。

如果在某个 boost::asio::io_service 类型的对象之上调用 run() 方法，则 相关联的句柄也会在同一个线程内被执行。 通过使用多线程，应用程序可以同时调 用多个 run() 方法。 一旦某个异步操作结束，相应的 I/O 服务就将在这些线程 中的某一个之中执行句柄。 如果第二个操作在第一个操作之后很快也结束了，则 I/O 服务可以在另一个线程中执行句柄，而无需等待第一个句柄终止。

Boost C++ 库

#include <boost/asio.hpp> #include <boost/thread.hpp> #include <iostream>

void handler1(const boost::system::error_code &ec)

{

std::cout << "5 s." << std::endl;

}

void handler2(const boost::system::error_code &ec)

{

std::cout << "5 s." << std::endl;

}

boost::asio::io_service io_service;

void run()

{

io_service.run();

}

int main()

{

boost::asio::deadline_timer timer1(io_service, boost::posix_time timer1.async_wait(handler1);

boost::asio::deadline_timer timer2(io_service, boost::posix_time timer2.async_wait(handler2);

boost::thread thread1(run); boost::thread thread2(run); thread1.join(); thread2.join();

}

下载源代码

上一节中的例子现在变成了一个多线程的应用。 通过使用在 boost/thread.hpp 中定义的 boost::thread 类，它来自于 Boost C++ 库 Thread，我们在

main() 中创建了两个线程。 这两个线程均针对同一个 I/O 服务调用了 run() 方法。 这样当异步操作完成时，这个 I/O 服务就可以使用两个线程去执行句柄函 数。

这个例子中的两个计时数均被设为在五秒后触发。 由于有两个线程，所以

handler1() 和 handler2() 可以同时执行。 如果第二个计时器触发时第一个 仍在执行，则第二个句柄就会在第二个线程中执行。 如果第一个计时器的句柄已经 终止，则 I/O 服务可以自由选择任一线程。

线程可以提高应用程序的性能。 因为线程是在处理器内核上执行的，所以创建比内 核数更多的线程是没有意义的。 这样可以确保每个线程在其自己的内核上执行，而 没有同一内核上的其它线程与之竞争。

Boost C++ 库

要注意，使用线程并不总是值得的。 以上例子的运行会导致不同信息在标准输出流 上混合输出，因为这两个句柄可能会并行运行，访问同一个共享资源：标准输出流 std::cout 。 这种访问必须被同步，以保证每一条信息在另一个线程可以向标准 输出流写出另一条信息之前被完全写出。 在这种情形下使用线程并不能提供多少好

处，如果各个独立句柄不能独立地并行运行。

多次调用同一个 I/O 服务的 run() 方法，是为基于 Boost.Asio 的应用程序增加 可扩展性的推荐方法。 另外还有一个不同的方法：不要绑定多个线程到单个 I/O 服 务，而是创建多个 I/O 服务。 然后每一个 I/O 服务使用一个线程。 如果 I/O 服务的 数量与系统的处理器内核数量相匹配，则异步操作都可以在各自的内核上执行。

#include <boost/asio.hpp> #include <boost/thread.hpp> #include <iostream>

void handler1(const boost::system::error_code &ec)

{

std::cout << "5 s." << std::endl;

}

void handler2(const boost::system::error_code &ec)

{

std::cout << "5 s." << std::endl;

}

boost::asio::io_service io_service1; boost::asio::io_service io_service2;

void run1()

{

io_service1.run();

}

void run2()

{

io_service2.run();

}

int main()

{

boost::asio::deadline_timer timer1(io_service1, boost::posix_tim timer1.async_wait(handler1);

boost::asio::deadline_timer timer2(io_service2, boost::posix_tim timer2.async_wait(handler2);

boost::thread thread1(run1); boost::thread thread2(run2); thread1.join(); thread2.join();

}

Boost C++ 库

下载源代码

前面的那个使用两个计时器的例子被重写为使用两个 I/O 服务。 这个应用程序仍然 基于两个线程；但是现在每个线程被绑定至不同的 I/O 服务。 此外，两个 I/O 对象

timer1 和 timer2 现在也被绑定至不同的 I/O 服务。

这个应用程序的功能与前一个相同。 在一定条件下使用多个 I/O 服务是有好处的， 每个 I/O 服务有自己的线程，最好是运行在各自的处理器内核上，这样每一个异步 操作连同它们的句柄就可以局部化执行。 如果没有远端的数据或函数需要访问，那 么每一个 I/O 服务就象一个小的自主应用。 这里的局部和远端是指象高速缓存、内 存页这样的资源。 由于在确定优化策略之前需要对底层硬件、操作系统、编译器以 及潜在的瓶颈有专门的了解，所以应该仅在清楚这些好处的情况下使用多个 I/O 服 务。

7.4.网络编程

虽然 Boost.Asio 是一个可以异步处理任何种类数据的库，但是它主要被用于网络编 程。 这是由于，事实上 Boost.Asio 在加入其它 I/O 对象之前很久就已经支持网络 功能了。 网络功能是异步处理的一个很好的例子，因为通过网络进行数据传输可能 会需要较长时间，从而不能直接获得确认或错误条件。

Boost.Asio 提供了多个 I/O 对象以开发网络应用。 以下例子使用了

boost::asio::ip::tcp::socket 类来建立与中另一台PC的连接，并下载 'Highscore' 主页；就象一个浏览器在指向 www.highscore.de 时所要做的。

Boost C++ 库

#include <boost/asio.hpp> #include <boost/array.hpp> #include <iostream> #include <string>

boost::asio::io_service io_service; boost::asio::ip::tcp::resolver resolver(io_service); boost::asio::ip::tcp::socket sock(io_service); boost::array<char, 4096> buffer;

void read_handler(const boost::system::error_code &ec, std::size_t

{

if (!ec)

{

std::cout << std::string(buffer.data(), bytes_transferred) << sock.async_read_some(boost::asio::buffer(buffer), read_handler

}

}

void connect_handler(const boost::system::error_code &ec)

{

if (!ec)

{

boost::asio::write(sock, boost::asio::buffer("GET / HTTP 1.1\r sock.async_read_some(boost::asio::buffer(buffer), read_handler

}

}

void resolve_handler(const boost::system::error_code &ec, boost::a

{

if (!ec)

{

sock.async_connect(*it, connect_handler);

}

}

int main()

{

boost::asio::ip::tcp::resolver::query query("www.highscore.de", resolver.async_resolve(query, resolve_handler); io_service.run();

}

下载源代码

这个程序最明显的部分是三个句柄的使用： connect_handler() 和

read_handler() 函数会分别在连接被建立后以及接收到数据后被调用。 那么为 什么需要 resolve_handler() 函数呢？

Boost C++ 库

互联网使用了所谓的IP地址来标识每台PC。 IP地址实际上只是一长串数字，难以 记住。 而记住象 www.highscore.de 这样的名字就容易得多。 为了在互联网上使用 类似的名字，需要通过一个叫作域名解析的过程将它们翻译成相应的IP地址。 这个 过程由所谓的域名解析器来完成，对应的 I/O 对象

是： boost::asio::ip::tcp::resolver 。

域名解析也是一个需要连接到互联网的过程。 有些专门的PC，被称为DNS服务 器，其作用就象是电话本，它知晓哪个IP地址被赋给了哪台PC。 由于这个过程本 身的透明的，只要明白其背后的概念以及为何需要

boost::asio::ip::tcp::resolver I/O 对象就可以了。 由于域名解析不是发生 在本地的，所以它也被实现为一个异步操作。 一旦域名解析成功或被某个错误中 断， resolve_handler() 函数就会被调用。

因为接收数据需要一个成功的连接，进而需要一次成功的域名解析，所以这三个不 同的异步操作要以三个不同的句柄来启动。 resolve_handler() 访问 I/O 对象 sock ，用由迭代器 it 所提供的解析后地址创建一个连接。 而 sock 也在 connect_handler() 的内部被使用，发送 HTTP 请求并启动数据的接收。 因为 所有这些操作都是异步的，各个句柄的名字被作为参数传递。 取决于各个句柄，需 要相应的其它参数，如指向解析后地址的迭代器 it 或用于保存接收到的数据的

缓冲区 buffer 。

开始执行后，该应用将创建一个类型为

boost::asio::ip::tcp::resolver::query 的对象 query ，表示一个查询， 其中含有名字 www.highscore.de 以及互联网常用的端口80。 这个查询被传递给

async_resolve() 方法以解析该名字。 最后， main() 只要调用 I/O 服务的 run() 方法，将控制交给操作系统进行异步操作即可。

当域名解析的过程完成后， resolve_handler() 被调用，检查域名是否能被解 析。 如果解析成功，则存有错误条件的对象 ec 被设为0。 只有在这种情况下， 才会相应地访问 socket 以创建连接。 服务器的地址是通过类型为

boost::asio::ip::tcp::resolver::iterator 的第二个参数来提供的。

调用了 async_connect() 方法之后， connect_handler() 会被自动调用。 在 该句柄的内部，会访问 ec 对象以检查连接是否已建立。 如果连接是有效的，则 对相应的 socket 调用 async_read_some() 方法，启动读数据操作。 为了保存 接收到的数据，要提供一个缓冲区作为第一个参数。 在以上例子中，缓冲区的类型

是boost::array ，它来自 Boost C++ 库 Array，定义于 boost/array.hpp .

每当有一个或多个字节被接收并保存至缓冲区时， read_handler() 函数就会被

调用。 准确的字节数通过 std::size_t 类型的参数 bytes_transferred 给 出。 同样的规则，该句柄应该首先看看参数 ec 以检查有没有接收错误。 如果是 成功接收，则将数据写出至标准输出流。

请留意， read_handler() 在将数据写出至 std::cout 之后，会再次调用

async_read_some() 方法。 这是必需的，因为无法保证仅在一次异步操作中就 可以接收到整个网页。 async_read_some() 和 read_handler() 的交替调用 只有当连接被破坏时才中止，如当 web 服务器已经传送完整个网页时。 这种情况

Boost C++ 库

下，在 read_handler() 内部将报告一个错误，以防止进一步将数据输出至标准 输出流，以及进一步对该 socket 调用 async_read() 方法。 这时该例程将停 止，因为没有更多的异步操作了。

上个例子是用来取出 www.highscore.de 的网页的，而下一个例子则示范了一个简 单的 web 服务器。 其主要差别在于，这个应用不会连接至其它PC，而是等待连 接。

#include <boost/asio.hpp> #include <string>

boost::asio::io_service io_service; boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4() boost::asio::ip::tcp::acceptor acceptor(io_service, endpoint); boost::asio::ip::tcp::socket sock(io_service);

std::string data = "HTTP/1.1 200 OK\r\nContent-Length: 13\r\n\r\nH

void write_handler(const boost::system::error_code &ec, std::size_

{

}

void accept_handler(const boost::system::error_code &ec)

{

if (!ec)

{

boost::asio::async_write(sock, boost::asio::buffer(data), writ

}

}

int main()

{

acceptor.listen();

acceptor.async_accept(sock, accept_handler); io_service.run();

}

下载源代码

类型为 boost::asio::ip::tcp::acceptor 的 I/O 对象 acceptor - 被初始化 为指定的协议和端口号 - 用于等待从其它PC传入的连接。 初始化工作是通过

endpoint 对象完成的，该对象的类型为

boost::asio::ip::tcp::endpoint ，将本例子中的接收器配置为使用端口80来 等待 IP v4 的传入连接，这是 WWW 通常所使用的端口和协议。

接收器初始化完成后， main() 首先调用 listen() 方法将接收器置于接收状 态，然后再用 async_accept() 方法等待初始连接。 用于发送和接收数据的 socket 被作为第一个参数传递。

Boost C++ 库

当一个PC试图建立一个连接时， accept_handler() 被自动调用。 如果该连接

请求成功，就执行自由函数 boost::asio::async_write() 来通过 socket 发送 保存在 data 中的信息。 boost::asio::ip::tcp::socket 还有一个名为 async_write_some() 的方法也可以发送数据；不过它会在发送了至少一个字节 之后调用相关联的句柄。 该句柄需要计算还剩余多少字节，并反复调用

async_write_some() 直至所有字节发送完毕。 而使用

boost::asio::async_write() 可以避免这些，因为这个异步操作仅在缓冲区的 所有字节都被发送后才结束。

在这个例子中，当所有数据发送完毕，空函数 write_handler() 将被调用。 由 于所有异步操作都已完成，所以应用程序终止。 与其它PC的连接也被相应关闭。

7.5. 开发 Boost.Asio 扩展

虽然 Boost.Asio 主要是支持网络功能的，但是加入其它 I/O 对象以执行其它的异步 操作也非常容易。 本节将介绍 Boost.Asio 扩展的一个总体布局。 虽然这不是必须 的，但它为其它扩展提供了一个可行的框架作为起点。

要向 Boost.Asio 中增加新的异步操作，需要实现以下三个类：

一个派生自 boost::asio::basic_io_object 的类，以表示新的 I/O 对 象。使用这个新的 Boost.Asio 扩展的开发者将只会看到这个 I/O 对象。

一个派生自 boost::asio::io_service::service 的类，表示一个服务， 它被注册为 I/O 服务，可以从 I/O 对象访问它。 服务与 I/O 对象之间的区别是 很重要的，因为在任意给定的时间点，每个 I/O 服务只能有一个服务实例，而 一个服务可以被多个 I/O 对象访问。

一个不派生自任何其它类的类，表示该服务的具体实现。 由于在任意给定的时 间点每个 I/O 服务只能有一个服务实例，所以服务会为每个 I/O 对象创建一个 其具体实现的实例。 该实例管理与相应 I/O 对象有关的内部数据。

本节中开发的 Boost.Asio 扩展并不仅仅提供一个框架，而是模拟一个可用的

boost::asio::deadline_timer 对象。 它与原来的

boost::asio::deadline_timer 的区别在于，计时器的时长是作为参数传递给 wait() 或 async_wait() 方法的，而不是传给构造函数。

Boost C++ 库

#include <boost/asio.hpp> #include <cstddef>

template <typename Service> class basic_timer

: public boost::asio::basic_io_object<Service>

{

public:

explicit basic_timer(boost::asio::io_service &io_service) : boost::asio::basic_io_object<Service>(io_service)

{

}

void wait(std::size_t seconds)

{

return this->service.wait(this->implementation, seconds);

}

template <typename Handler>

void async_wait(std::size_t seconds, Handler handler)

{

this->service.async_wait(this->implementation, seconds, hand

}

};

下载源代码

每个 I/O 对象通常被实现为一个模板类，要求以一个服务来实例化 - 通常就是那个 特定为此 I/O 对象开发的服务。 当一个 I/O 对象被实例化时，该服务会通过父类 boost::asio::basic_io_object 自动注册为 I/O 服务，除非它之前已经注册。

这样可确保任何 I/O 对象所使用的服务只会每个 I/O 服务只注册一次。

在I/O 对象的内部，可以通过 service 引用来访问相应的服务，通常的访问就是 将方法调用前转至该服务。 由于服务需要为每一个 I/O 对象保存数据，所以要为每 一个使用该服务的 I/O 对象自动创建一个实例。 这还是在父类

boost::asio::basic_io_object 的帮助下实现的。 实际的服务实现被作为一 个参数传递给任一方法调用，使得服务可以知道是哪个 I/O 对象启动了这次调用。 服务的具体实现是通过 implementation 属性来访问的。

一般一上谕，I/O 对象是相对简单的：服务的安装以及服务实现的创建都是由父类

boost::asio::basic_io_object 来完成的，方法调用则只是前转至相应的服 务；以 I/O 对象的实际服务实现作为参数即可。

#include <boost/asio.hpp>

#include <boost/thread.hpp>

#include <boost/bind.hpp>

#include <boost/scoped_ptr.hpp>

#include <boost/shared_ptr.hpp>

#include <boost/weak_ptr.hpp>

Boost C++ 库

#include <boost/system/error_code.hpp>

template <typename TimerImplementation = timer_impl> class basic_timer_service

: public boost::asio::io_service::service

{

public:

static boost::asio::io_service::id id;

explicit basic_timer_service(boost::asio::io_service &io_servi : boost::asio::io_service::service(io_service), async_work_(new boost::asio::io_service::work(async_io_servi async_thread_(boost::bind(&boost::asio::io_service::run, &as

{

}

~basic_timer_service()

{

async_work_.reset(); async_io_service_.stop(); async_thread_.join();

}

typedef boost::shared_ptr<TimerImplementation> implementation_

void construct(implementation_type &impl)

{

impl.reset(new TimerImplementation());

}

void destroy(implementation_type &impl)

{

impl->destroy(); impl.reset();

}

void wait(implementation_type &impl, std::size_t seconds)

{

boost::system::error_code ec; impl->wait(seconds, ec); boost::asio::detail::throw_error(ec);

}

template <typename Handler> class wait_operation

{

public:

wait_operation(implementation_type &impl, boost::asio::io_ : impl_(impl),

io_service_(io_service), work_(io_service), seconds_(seconds), handler_(handler)

Boost C++ 库

{

}

void operator()() const

{

implementation_type impl = impl_.lock(); if (impl)

{

boost::system::error_code ec; impl->wait(seconds_, ec); this->io_service_.post(boost::asio::detail::bind_han

}

else

{

this->io_service_.post(boost::asio::detail::bind_han

}

}

private: boost::weak_ptr<TimerImplementation> impl_; boost::asio::io_service &io_service_; boost::asio::io_service::work work_; std::size_t seconds_;

Handler handler_;

};

template <typename Handler>

void async_wait(implementation_type &impl, std::size_t seconds

{

this->async_io_service_.post(wait_operation<Handler>(impl, t

}

private:

void shutdown_service()

{

}

boost::asio::io_service async_io_service_;

boost::scoped_ptr<boost::asio::io_service::work> async_work_; boost::thread async_thread_;

};

template <typename TimerImplementation>

boost::asio::io_service::id basic_timer_service<TimerImplementatio

下载源代码

为了与 Boost.Asio 集成，一个服务必须符合几个要求：

Boost C++ 库

它必须派生自 boost::asio::io_service::service 。 构造函数必须接受 一个指向 I/O 服务的引用，该 I/O 服务会被相应地传给

boost::asio::io_service::service 的构造函数。

任何服务都必须包含一个类型为 boost::asio::io_service::id 的静态公 有属性 id 。在 I/O 服务的内部是用该属性来识别服务的。

必须定义两个名为 construct() 和 destruct() 的公有方法，均要求一

个类型为 implementation_type 的参数。 implementation_type 通常 是该服务的具体实现的类型定义。 正如上面例子所示，在 construct() 中 可以很容易地使用一个 boost::shared_ptr 对象来初始化一个服务实现， 以及在 destruct() 中相应地析构它。 由于这两个方法都会在一个 I/O 对象 被创建或销毁时自动被调用，所以一个服务可以分别使用 construct() 和

destruct() 为每个 I/O 对象创建和销毁服务实现。

必须定义一个名为 shutdown_service() 的方法；不过它可以是私有的。 对于一般的 Boost.Asio 扩展来说，它通常是一个空方法。 只有与 Boost.Asio 集成得非常紧密的服务才会使用它。 但是这个方法必须要有，这样扩展才能编 译成功。

为了将方法调用前转至相应的服务，必须为相应的 I/O 对象定义要前转的方法。 这 些方法通常具有与 I/O 对象中的方法相似的名字，如上例中的 wait() 和

async_wait() 。 同步方法，如 wait() ，只是访问该服务的具体实现去调用一

个阻塞式的方法，而异步方法，如 async_wait() ，则是在一个线程中调用这个 阻塞式方法。

在线程的协助下使用异步操作，通常是通过访问一个新的 I/O 服务来完成的。 上述

例子中包含了一个名为 async_io_service_ 的属性，其类型为

boost::asio::io_service 。 这个 I/O 服务的 run() 方法是在它自己的线程 中启动的，而它的线程是在该服务的构造函数内部由类型为 boost::thread 的

async_thread_ 创建的。 第三个属性 async_work_ 的类型为

boost::scoped_ptr<boost::asio::io_service::work> ，用于避免 run() 方法立即返回。 否则，这可能会发生，因为已没有其它的异步操作在创

建。 创建一个类型为 boost::asio::io_service::work 的对象并将它绑定至该 I/O 服务，这个动作也是发生在该服务的构造函数中，可以防止 run() 方法立即 返回。

一个服务也可以无需访问它自身的 I/O 服务来实现 - 单线程就足够的。 为新增的线 程使用一个新的 I/O 服务的原因是，这样更简单： 线程间可以用 I/O 服务来非常容 易地相互通信。 在这个例子中， async_wait() 创建了一个类型为

wait_operation 的函数对象，并通过 post() 方法将它传递给内部的 I/O 服 务。 然后，在用于执行这个内部 I/O 服务的 run() 方法的线程内，调用该函数 对象的重载 operator()() 。 post() 提供了一个简单的方法，在另一个线程 中执行一个函数对象。