boost开发指南

客官°小女子只卖身不卖艺 2022-08-13 14:47 290阅读 0赞

C++确实很复杂，神一样的0x不知道能否使C++变得纯粹和干爽？

boost很复杂，感觉某些地方有过度设计和太过于就事论事的嫌疑，对实际开发工作的考虑太过于理想化。学习boost本身就是一个复杂度，有魄力在项目中广泛采用boost复杂度会再加一层，抓狂的编译时间，井喷式的编译错误，运行时崩溃后的咒语式堆栈……

其中好的东西还是值得用的，但凡事有个度。如果将应用做到boost这个级别了，要么你很牛，要么你在装。

用不用，看看还是有好处的。建议中高级以上C++程序员了解boost。

--------------------

第1章 Boost程序库总论

1.  使用Boost，将大大增强C++的功能和表现力

第2章 时间与日期

1.  timer提供毫秒级的计时精度，内部是通过[std::clock][std_clock]取时间的
2.  progress\_timer自动打印某生命周期的执行时间
3.  原则上程序库的代码是不应该被用户修改的
4.  progress\_display可以在控制台上显示程序的执行进度
5.  date\_time库能很好的表示日期时间概念，并能和C的时间结构tm进行友好互转
6.  date类提供年月日和星期几的概念。data可通过from\_string或from\_undelimited\_string从字符串解析而来，可通过to\_simple\_string、to\_iso\_string、to\_extended\_iso\_string转换为字符串。（精度到天的[DateTime][]）
7.  day\_clock是精度到天的时钟
8.  date\_duration表示的是天精度的时间间隔概念，别名为days，另外还有years、months、weeks
9.  date\_period表示两个date之间的日期区间（精度到天的[TimeSpan][]）
10. date\_iterator、week\_iterator、month\_iterator和year\_iterator是时间的迭代器
11. boost::[greorian][]::gregorian\_calendar中有实用静态方法：is\_leap\_year、end\_of\_month\_day
12. time\_duration表示微妙或纳秒级的时间概念，几个实用子类：hours、minutes、seconds、millisec/milliseconds、microsec/microseconds、nanosec/nannoseconds
13. duration\_from\_string可以从字符串解析time\_duration
14. ptime用来表示时间点，相当于date和time\_duration的组合。可以用time\_from\_string或from\_iso\_string解析。（[TimeSpan][]）  
    ptime now1 = second\_clock::local\_time(); // 得到本地当前秒精度时间  
    ptime now2 = microsec\_clock::universal\_time(); // 得到本地当前微秒精度时间
15. time\_period表示两个ptime之间的时间区间。（[DateTime][]）
16. 时间迭代器没有日期迭代器那么多，只有time\_iterator一个
17. （boost时间日期库乱、破碎、过度设计）

第3章 内存管理

1.  scoped\_ptr类似auto\_ptr，但其一旦获得对象的管理权，你就无法再从它那里取回来。该智能指针只希望在本作用域里使用，不希望被转让。auto\_ptr有意设计成所有权的自动转让，scoped\_ptr有意设计成所有权的无法转让。scoped\_ptr和auto\_ptr均不能作为容器元素。
2.  scoped\_array包装的是new\[\]产生的指针，并调用的是delete\[\]。往往是用来和C代码保持兼容，一般不推荐使用
3.  无论是编译器还是程序员都很难区分出new\[\]和new分配的空间，错误的运用delete将导致资源异常
4.  在C++历史上曾经出现过无数的引用计数型智能指针实现，但没有一个比得上boost::shared\_ptr，在过去、现在和将来，它都是最好的
5.  shared\_ptr支持的转型有：static\_pointer\_cast<T>、const\_pointer\_cast<T>、dynamic\_pointer\_cast<T>，返回的结果是shared\_ptr，并能保证这些指针的引用计数正确
6.  用shared\_ptr可以消除代码中显示的delete，用make\_shared、allocate\_shared可以消除代码中显示的new
7.  桥接模式(bridge)是一种结构型设计模式，它把类的具体实现细节对用户隐藏起来，以达到类之间的最小耦合关系。在具体编程实践中桥接模式也被称为pimpl或者handle/body惯用法，它可以将头文件的依赖关系降到最小，减少编译时间，而且可以不使用虚函数实现多态
8.  get\_deleter(shared\_ptr<T> const& p)可以获得删除器。shared\_ptr的删除器在处理某些特殊资源时非常有用，它使得用户可以定制、扩展shared\_ptr的行为，使其不仅仅能够管理内存资源，而是称为一个“万能”的资源管理工具
9.  对应shared\_ptr，也有一个shared\_array，scoped\_array和shared\_array均不对operator\[\]做下标检测
10. weak\_ptr是为配合shared\_ptr而引入的，更像是shared\_ptr的一个助手而不是智能指针，其没有重载operator\*和->，不具有普通指针的行为。它最大的作用在于协助shared\_ptr工作，像旁观者那样观测资源的使用情况
11. weak\_ptr被设计为与shared\_ptr共同工作，可以从一个shared\_ptr或者另一个weak\_ptr对象构造，获得资源的观测权。但weak\_ptr没有共享资源，它的构造不会引起指针引用计数的增加。同样，在weak\_ptr析构时也不会导致引用计数的减少，它只是一个静静的观察者
12. 获得this指针的shared\_ptr，使对象自己能够产生shared\_ptr管理自己：class T : public enable\_shared\_from\_this<T>, then shared\_ptr shared\_from\_this().
13. intrusive\_ptr是一个侵入式的引用计数型指针。当对内存占用的要求非常严格，或现存代码已经有了引用计数机制时可以考虑。一般情况不推荐使用。
14. pool为固定块大小的类似malloc的原生内存分配器，支持数组式分配，一般情况下不必对分配的内存调用free()。只分配原生内存，不调用构造函数，回收不调用析构函数，最好不要用于对象。
15. singleton\_pool和pool接口完全一致，但为单件线程安全，同样要求编译期指定要分配的原生内存块大小
16. object\_pool为特定类型的对象池，不支持数组式分配，支持对象分配和对象原生内存分配
17. pool\_alloc和fast\_pool\_allocator是boost提供的两个STL分配器。除非有特别需求，我们应该总使用STL实现自带的内存分配器。使用定制的分配器需要经过仔细的测试，以保证它与容器可以共同工作。
18. 内存管理是C++程序开发中永恒的话题，因为没有GC，小心谨慎的管理内存等系统资源是每一个C++程序员都必须面对的问题

第4章 实用工具

1.  private继承自noncopyable可以编译时禁止对象拷贝语法
2.  C++静态强类型的优点有时候反而是阻碍程序员生产力的“缺陷”
3.  typeof库使用宏模拟了C++0X中的typedef和auto关键字，可以减轻书写繁琐的变量类型声明工作，简化代码。对于用户自定义类型需要手工用宏注册。（语法并没那么好看，不准备使用）
4.  optional<T>使用“容器”语义，包装了“可能产生无效值”的对象，实现了“未初始化”的概念（[Nullable<T>][Nullable_T]）
5.  optional<T> make\_optional(bool condition, T const& v)用来简单构建optional对象，但不能处理optional<T&>的情况。(此乃鸡肋)
6.  optional<string> str(in\_place("string就地创建"))，而不需拷贝临时对象，避免大对象的拷贝开销
7.  用于初始化的assign库（仅限于STL标准容器，通过重载“+=”和“,”运算符实现）：  
    \#include <boost/assign.hpp>  
    using namespace boost;  
    vector<int> v; v += 1,2,3,4,5,6\*6;  
    set<string> s; s += "cpp", "java";  
    map<int, string> m; m += make\_pair(1, "one"), make\_pair(2, "2");
8.  assign还支持insert()、push\_front()、push\_back()（通过重载“()”实现）：  
    vector<int> v; push\_back(v)(1)(2)(3)(4)(5);  
    list<string> l; push\_front(l)("cpp")("java");  
    set<double> s; insert(s)(3.14)(0.618)(1.732);  
    map<int, string> m; insert(m)(1, "one")(2, "two");
9.  assign也可以将“()”和“,”混用：  
    vector<int> v;  
    push\_back(v), 1, 2, 3, 4, 5;  
    push\_back(v)(6), 7, 64 / 8, (9), 10;  
    deque<string> d;  
    push\_front(d)() = "cpp", "java";
10. assign list\_of()函数：  
    vector<int> v = list\_of(1)(2)(3);  
    deque<string> d = (list\_of("cpp")("java"));  
    set<int> s = (list\_of(10), 20, 30, 40);  
    map<int, string> m = list\_of(make\_pair(1, "one")) (make\_pair(2, "two"))  
    如果需要将括号与逗号混合使用，则要求最外侧加一个括号，否则编译器无法推导
11. assign map\_list\_of/pair\_list\_of函数：  
    map<int, int> m1 = map\_list\_of(1, 2)(3, 4)(5, 6)  
    map<int, string> m2 = map\_list\_of(1, "one")(2, "two")
12. assign tuple\_list\_of用户初始化元素类型为tuple的容器
13. assign repeat()可以重复生成值，repeat\_fun()可以重复无参函数或仿函数，range()则可以从序列中取出部分或全部：  
    vector<int> v = list\_of(1).repeat(3, 2)(3)(4)(5); // v = 1,2,2,2,3,4,5  
    multiset<int> ms; insert(ms).repeat\_fun(5, &ran).repeat(2, 1), 10; // ms = x,x,x,x,x,1,1,10  
    deque<int> d; push\_front(d).range(v.begin(), v.begin() + 5); // d=3,2,2,2,1
14. assign支持8个STL标准容器（vector、string、deque、list、set、multiset、map、multimap），对容器适配器（stack、queue、priority\_queue）则需要通过to\_adapter()：  
    stack<int> stk = (list\_of(1), 2, 3).to\_adapter();  
    queue<string> q = (list\_of("cpp")("java")).repeat(2, "C\#").to\_adapter();  
    priority\_queue<double> pq = (list\_of(1.414), 1.732).to\_adapter();
15. assign也支持部分不在STL中的非标准容器slist、hash\_map、hash\_set，因为其符合标准容器定义，同时也支持大部分boost容器：array、circular\_buffer、unordered等
16. assign list\_of()嵌套：  
    vector<vector<int>> v = list\_of(list\_of(1)(2)) list\_of(list\_of(3)(4));  
    v += list\_of(5)(6), list\_of(7)(8);
17. assign ref\_list\_of()、cref\_list\_of()、ptr\_push\_back()、ptr\_list\_of()还支持以引用或指针来构造初始化：  
    int a = 1, b = 2, c = 3;  
    vector<int> v = ref\_list\_of<3>(a)(b)(c);
18. boost::swap是对std::swap的增强，并且扩充了对数组的支持：  
    int a1\[10\]; std::fill\_n(a1, 10, 5);  
    int a2\[10\]; std::file\_n(a2, 10, 20);  
    boost::swap(a1, a2);
19. 单件boost::details::pool::singleton\_default<T>在main之前进行构造，支持继承或非继承形式（最恨main之前的事情了）
20. 单件boost::serialization::singleton<T>在main之前进行构造，支持继承或非继承形式。继承方式更彻底一些，非继承方式不影响原有代码
21. boost::tribool三态bool，indeterminate(tribool)可判断一个三态bool是否处于不确定状态
22. 选择optional<bool>还是tribool：如果返回值可能是无效的，那么就是optional<bool>，如果返回值总是确定的，但可能无法确定其意义，那么就用tribool（最多自己随手定义个enum状态，为了这点需求需要记住这一堆名称和细节！）
23. using namespace std::rel\_ops; 则一旦为类定义了operator==和<，则自动具有!=、>、<=和>=的功能。boost operators库提供了对该功能的增强，使用时只需继承自这些类并提供指定的operator重载即可获得附送的重载：
    
    1.  equality\_comparable<T>：要求提供==，可自动实现!=，相等语义
    2.  less\_than\_comparable<T>：要求提供<，可自动实现>、<=、>=
    3.  addable<T>：要求提供+=，可自动实现+
    4.  subtractable<T>：要求提供-=，可自动实现-
    5.  incrementable<T>：要求提供前置++，可自动实现后置++
    6.  decrementable<T>：要求提供前置--，可自动实现后置--
    7.  equivalent<T>：要求提供<，可自动实现==，等价语义
    8.  totally\_ordered：全序概念，组合了equality\_comparable和less\_than\_comparable
    9.  additive：可加减概念，组合了addable和subtractable
    10. multiplicative：可乘除概念，组合了multipliable和diviable
    11. arithmetic：算术运算概念，组合了additive和multiplicative
    12. unit\_stoppable：可步进概念，组合了incrementable和decrementable
    13. public dereferenceable<T, P, (B)>：解引用操作符，要求提供operator\*，可自动实现operator->。P为operator->返回类型，一般为T\*
    14. public indexable<T, I, R, (B)>：下标操作符，I为下标类型，要求能够与类型T做加法操作，通常为int；R是operator\[\]的返回值类型，通常是一个类型的引用。要求提供operator+(T, I)，将自动实现operator\[\]
24. 如果只关心类的等价语义，那么就用equivalent，如果想要精确的比较两个对象的值，就是用equality\_comprable。相等equivalent基于"=="实现，而equality\_comprable基于"<"的"!(x<y)&&!(x>y)"实现。
25. 应该总对异常类是用虚继承
26. struct my\_exception :  
    virtual std::exception, // 兼容C++标准异常  
    virtual boost::exception  
    \{\};  
      
    typedef boost::error\_info<struct tag\_err\_no, int> err\_no;  
    typedef boost::error\_info<struct tag\_err\_str, string> err\_str;  
      
    \#include <boost/exception/all.hpp>  
    try \{ throw my\_exception() << err\_no(10); \}  
    catch(my\_exception& e)  
    \{  
    cout << \*get\_error\_info<err\_no>(e) << endl;  
    cout << e.what() << endl;  
    e << err\_str("向异常追加信息，还可再次抛出");  
    cout << \*get\_error\_info<err\_str>(e) << endl;  
    \}
27. 从exception派生的异常定义非常简单，没有实现代码，可以很容易建立起一个适合自己程序的、惊喜完整的异常类体系。只要都是用虚继承，类体系可以任意复杂。
28. boost库预定义的异常类型：  
    typedef error\_info<struct errinfo\_api\_function\_, char const\*> errinfo\_api\_function;  
    typedef error\_info<struct errinfo\_at\_line\_, int> errinfo\_at\_line;  
    typedef error\_info<struct errinfo\_file\_handle\_, weak\_ptr<FILE>> errinfo\_file\_handle;  
    typedef error\_info<struct errinfo\_file\_name\_, std::string> errinfo\_file\_name;  
    typedef error\_info<struct errinfo\_file\_open\_mode\_, std::string> errinfo\_file\_open\_mode;  
    typedef error\_info<struct errinfo\_type\_info\_name\_, std::string> error\_info\_type\_info\_name;  
      
    typedef error\_info<struct throw\_function\_, char const\*> throw\_function;  
    typedef error\_info<struct throw\_file\_, char const\*> throw\_file;  
    typedef error\_info<struct throw\_line\_, ine> throw\_line;
29. enable\_error\_info<T>(T& e)，可以将已将存在的任意类型包装为boost异常类型
30. throw\_exception(任意异常类型)，可以自动将任意异常类型包装为boost异常，还能保证线程安全
31. diagnostic\_information(e)可以得到任意boost异常的字符串内容描述；在catch块中调用current\_exception\_diagnostic\_information()，则不用传参数e。（何必呢，为少写一两个字母反而要记住一个更长的名字）
32. catch块内的异常转型用current\_exception\_cast<T>()
33. catch块内调current\_exception()得到当前异常指针的exception\_ptr是线程安全的，rethrow\_exception可以重新抛出异常
34. UUID, Universally Unique Identifier, 128bit(16 Byte)，不需要中央认证机构就可以创建全球唯一的标识符。别名GUID
35. 不是所有的警告都可以忽略的，有的警告预示着可能潜在的错误
36. BOOST\_BINARY(111 00 1)，可以实现编译器的二进制定义，但不能超过8bit

第5章 字符串与文本处理

1.  lexical\_cast<T>(X)，可以实现字符串和数值类型之间的转换，但不支持高级格式控制。转换失败将抛出bad\_lexical\_cast异常。lexical\_cast底层用C++流实现，要求目标类型支持operator<<、operator>>、无参构造函数和拷贝构造函数
2.  cout << format("%s:%d+%d=%d\\n") %"sum" %1 %2 %(1+2); // sum:1+2=3  
    format fmt("(%1% + %2%) \* %2% = %3%\\n");  
    fmt %2 %5;  
    fmt %((2+5)\*5);  
    cout << fmt.str(); // (2 + 5) \* 5 = 35
3.  format在提供的参数过多或过少的情况下operator<<或str()都会抛出异常
4.  format完全支持printf的格式化选项方式，同时还增加了新的方式：
    
    1.  %|spec|%：与printf格式选项功能相同，但两边增加了竖线分隔，可以更好的区分格式化选项有普通字符
    2.  %N%：标记第N个参数，相当于占位符，不带任何其他的格式化选项
5.  format因为做了很多安全检查工作，会比printf慢至少2-5倍
6.  format相关的高级功能：
    
    1.  basic\_format& bind\_arg(int argN, const T& val) 把格式化字符串第argN位置的输入参数固定为val，即使调用clear()也保持不变，除非调用clear\_bind()或clear\_binds()
    2.  basic\_format& clear\_bind(int argN) 取消格式化字符串第argN位置的参数绑定
    3.  basic\_format& clear\_binds()
    4.  basic\_format& modify\_item(int itemN, T manipulator) 设置格式化字符串第itemN位置的格式化选项，manipulator是一个boost::io::group()返回的对象
    5.  boost::io::group(T1 a1, ..., Var const& var) 是一个最多支持10个参数的模板函数，可以设置IO流操纵器以指定格式或输入参数值
7.  string\_algo库包括：
    
    1.  to\_upper, to\_lower, starts\_with, ends\_with, contains, equals, lexicographical\_compare
    2.  all(检测字符串中的所有元素是否满足给定的判断式)
    3.  仿函数is\_equal, is\_less, is\_not\_greater
    4.  is\_space, is\_alnum, is\_alpha, is\_cntrl, is\_digit(十进制数字), is\_graph, is\_lower, is\_print, is\_punct(是否是标点符号), is\_upper, is\_xdigit(字符是否为十六进制数字), is\_any\_of(字符是否是参数字符序列中的任意数字), if\_from\_range(字符是否位于指定的区间\[c1,c2\]内)
    5.  trim\_left、trim\_right、trim
    6.  find\_first、find\_last、find\_nth、find\_head、find\_tail
    7.  replace/erase\_first、replace/erase\_last、replace/erase\_nth、replace/erase\_all、replace/erase\_head、replace/erase\_tail
    8.  find\_all、split、find\_iterator、split\_iterator、join
8.  tokenizer类似string\_algo::split，为更专业的token划分工具。tokenizer库提供预定义好的四个分词对象：
    
    1.  char\_delimiter\_separator：使用标点符号分词，是默认的分词函数对象。已被声明废弃
    2.  char\_separator：支持一个字符集合作为分隔符，默认行为与char\_delimiter\_separator类似
    3.  escaped\_list\_separator：用于CSV格式的分词
    4.  offset\_separator：使用偏移量来分词
9.  xpressive，类似boost.regex的正则表达式解析器，同时还是一个类似于boost.spirit的语法分析器，并且将这两种完全不相交的文本处理方式完美的融合在了一起
10. xpressive使用regex\_token\_iterator<>提供了强大的分词迭代器

第6章 正确性测试

1.  测试对于软件开发是非常重要的，程序员——尤其是C++程序员更应该认识到这一点
2.  BOOST\_ASSERT宏类似于assert宏，提供运行时断言，但功能有所增强。可以通过BOOST\_DISABLE\_ASSERTS来关闭。当定义BOOST\_ENABLE\_ASSERT\_HANDLER后，断言触发时将会调用boost::assertion\_failed回调
3.  BOOST\_VERIFY类似BOOST\_ASSERT，但断言表达式一定会被求值，Release下仍然会失效（放弃BOOST\_VERIFY）
4.  BOOST\_STATIC\_ASSERT，编译时断言。可以出现在程序的任何位置，而不一定只在函数域内
5.  测试用例是一个包含多个测试断言的函数，它是可以被独立执行测试的最小单元，各个测试用例之间是无关的，发生的错误不会影响到其他测试用例

第7章 容器与数据结构

1.  array是的C原生数组的STL接口包装
2.  std::vector<bool>是vector对bool的特化，内部保存的实际为bit，支持动态长度。std::bitset大小固定，但支持更多的位运算
3.  boost.dynamic\_bitset类似std::vector<bool>可以动态长度，同时提供了丰富的位运算。dynamic\_bitset还支持集合相关操作
4.  哈希容器：boost::unordered\_map、boost::unordered\_set、boost::unordered\_multimap、boost::unordered\_multiset
5.  boost::bimap，双向映射容器，提供left、right两个试图。支持的集合类型有：set\_of、multiset\_of、unordered\_set\_of、unordered\_multiset\_of、list\_of、vector\_of、unconstrained\_set\_of
6.  bimap的左右视图还可以通过标签访问：  
    bimap<tagged<int, struct id>, tagged<string, struct name>> bm;  
    bm.by<id>().insert(make\_pair(1, "C++")); // 相当于使用左视图  
    bm.by<name>().insert(make\_pair("java", 2)); // 相当于使用右视图
7.  circular\_buffer<T>为大小固定的循环缓冲区，circular\_buffer\_space\_optimized<T>类似circular\_buffer<T>但只在确实需要时才分配内存，并且当容器内元素减少时自动释放内存
8.  tuple是固定数目非同质元素容器。tuple是std::pair的泛化，可以从函数返回任意数量的值，也可以代替struct组合数据
9.  和std::make\_pair对应，也有个make\_tuple用来简化tuple的创建
10. tie()可以生成一个元素类型全是引用的tuple，相当于make\_tuple(ref(a), ref(b), ...)，可以用于左值，通常用来接收返回tuple或pair函数的返回值，可以看成是对tuple的解包
11. element<N, T>::type可以给出T中第N个元素的类型，length<T>::value可以给出T的元素数量
12. any能够容纳任意类型，可以用any\_cast<T>(a)类型安全的取出any中的值（让人联想到Ogre::Any）
13. any可以持有原始指针，但这样的用法很不安全，会导致内存泄露。应该使用智能指针包装原始指针，这样在any析构时智能指针会自动的调用delete，从而安全的释放资源
14. 如果希望一种数据结构具有tuple那样的容纳任意类型的能力，又可以在运行时动态变化大小，那么就可以用any作为元素类型搭配容器
15. variant是对C/C++中union概念的增强和扩展。varinat是有界类型，元素类型范围由用户指定，any是无界类型，可以容纳任意类型
16. multi\_array<int, 3>，相当于int ma\[X\]\[Y\]\[Z\]的多维数组。multi\_array没有异常机制来处理错误，保证数组范围不越界是库用户自己的责任
17. property\_tree是一个保存了多个属性值的树形数据结构，可以用类似路径的简单方式访问任意节点的树形，而且每个节点都可以用类似STL的风格遍历子节点。property\_tree特别适合于应用程序的配置数据处理，可以解析xml、ini、json和info四种格式的文本数据，使用它能减轻自己开发配置管理的工作。

第8章 算法

1.  boost foreach库提供BOOST\_FOREACH和BOOST\_REVERSE\_FOREACH来实现对容器的正向和反向遍历
2.  minmax(a, b)可在一次处理中同时获得最大最小值，执行效率上有很大提高（有提前优化的感觉了）
3.  minmax\_element算法族可以得到迭代器区间内的最大最小值

第9章 数学与数字

1.  从纯数学的角度看，程序也不过是一个非常大的整数而已
2.  integer\_traits : public std::numeric\_limits，提供各种整数类型的编译期最大最小值
3.  <boost/cstdint.hpp>基于C99标准中的<stdint.h>，定义了各种标准的整数
4.  <boost/integer.hpp>与<boost/cstdint.hpp>功能类似，用模板类而不是typedef提供各种整数类型定义
5.  boost.rational表示有理数（分数），rational\_cast<R>可以将有理数转换为普通数字
6.  最大公约数gcd()；最小公倍数lcm()
7.  crc\_optimal以字节为单位的快速CRC计算，实际常用的是crc\_32\_type的预定义算法
8.  boost random库提供了26个伪随机数发生器
9.  random库提供的随机数分布器：
    
    1.  uniform\_smallint：在小整数域内的均匀分布
    2.  uniform\_int：在整数域上的均匀分布
    3.  uniform\_01：在区间\[0,1\]上的实数连续均匀分布
    4.  uniform\_real：在区间\[min,max\]上的实数连续均匀分布
    5.  bernoulli\_distribution：伯努利分布
    6.  binomial\_distribution：二项分布
    7.  cauchy\_distribution：柯西（洛伦兹）分布
    8.  gamma\_distribution：伽马分布
    9.  poisson\_distribution：泊松分布
    10. geometric\_distribution：几何分布
    11. triangle\_distribution：三角分布
    12. exponential\_distribution：指数分布
    13. normal\_distribution：正态分布
    14. lognormal\_distribution：对数正态分布
    15. uniform\_on\_sphere：球面均匀分布
10. variate\_generator<Engine, Distribution>变量发生器，用于组合随机数发生器和分布器
11. 真随机数无法用纯软件产生，因为计算机本身是个确定的有限状态自动机

第10章 操作系统相关

1.  io\_state\_savers库可以简化恢复流状态的工作，它能够保存流的当前状态，自动恢复流的状态或者由程序员控制恢复的时机
    
    1.  基本的标准属性保存器：ios\_flags\_saver、ios\_width\_saver
    2.  增强的标准属性保存器：ios\_iostate\_saver、ios\_rdbuf\_saver
    3.  自定义的属性保存器：ios\_iword\_saver、ios\_pword\_saver
    4.  组合的属性保存器：ios\_all\_saver
2.  system库使用轻量级的对象封装了操作系统底层的错误代码和错误信息，使调用操作系统功能的程序可以被很容易的移植到其他操作系统  
    filesystem库中的path和wpath提供了文件路径相关的很多实用操作（类似Path）
3.  portable\_posix\_name()和windows\_name()分别检测文教案名字符串是否符合POSIX和Windows规范。Windows的文件名可以字符范围比POSIX的大。
4.  native()判断文件名是否符合本地文件系统命名规则
5.  为了程序的健壮性，应总使用try-catch来保护文件访问代码
6.  directory\_iterator和wdirectory\_iterator提供了迭代一个目录下所有文件的功能
7.  recursive\_directory\_iterator和wrecursive\_directory\_iterator提供递归遍历目录功能
8.  program\_options库提供了强大的命令行参数处理功能，它不仅能够分析命令行，也能够从配置文件甚至环境变量中获取参数，实现了非常完善的程序配置选项处理功能
9.  \#include <boost/program\_options.hpp>  
    using namespace boost::program\_options;  
    int main(int argc, char\* argv\[\])  
    \{  
    options\_description opts("demo options");  
    opts.add\_options()  
    ("help", "just a help info")  
    ("filename", value<string>(), "to find a file");  
    variables\_map vm;  
    store(parse\_command\_line(argc, argv, opts), vm);  
    // 解析完成，实现选项处理逻辑  
    if(vm.count("help"))  
    \{  
    cout << opts << endl;  
    return 0;  
    \}  
    if(vm.count("filename"))  
    \{ cout << "find" << vm\["filename"\].as<string>() << endl; \}  
    if(vm.size() == 0)  
    \{ cout << "no options" << endl; \}  
    \}
10. program\_options库的解析程序选项功能由三个基本组件构成，分别是选项描述器、分析器和存储器。选项描述其定义选项及选项的值，分析器依据选项描述器的定义解析命令行或数据文件，存储器则把分析器的结果保存起来以供使用

第11章 函数与回调

1.  result\_of<Func(T1, T2)>::type确定一个调用表达式的返回类型，是实现泛型库的底层基本构件
2.  ref()和cref()可以包装对象的引用，在传递参数时消除对象拷贝的代价，或者将不可拷贝的对象变为可以拷贝
3.  bind是对标准库bind1st、bind2nd的泛化和增强，可以适配任意的可调用对象。
4.  bind第一个参数必须是一个可调用对象，包括函数、函数指针、函数对象和成员函数指针
5.  bind也可以绑定到public成员变量，用法与绑定成员函数类似，只需要把成员变量名像一个成员函数一样去使用
6.  bind绑定到仿函数时，要求仿函数typedef xxx result\_type;否则就只能用bind<xxx>(functor())的形式
7.  bind重载了比较操作符和逻辑非操作符，可以把多个bind绑定式组合起来，形成一个复杂的逻辑表达式，配合标准库算法可以实现语法简单但语义复杂的操作：  
    using namespace boost::assign;  
    typedef rational<int> ri; // 有理数类  
    vector<ri> v = list\_of((ri(1, 2)) (ri(3, 4)) (ri(5, 6))); // 初始化  
    // 删除所有分子为1的有理数  
    remove\_if(v.begin(), b.end(), bind(&ri::numerator, \_1) == 1);  
    assert(v\[0\].numerator() == 3); // 有理数1/2被删除  
    // 使用find\_if算法查找分子是1的有理数，不不存在  
    assert(find\_if(v.begin(), b.end(), bind(&ri::numerator, \_1) == 1) == v.end());  
    // 查找分子大于3且分母小于8的有理数  
    BOOST\_AUTO(pos, find\_if(v.begin(), b.end(), bind(&ri::numerator, \_1) > 3 && bind(&ri::denominator, \_1) < 8));  
    cout << \*pos << endl; // 输出5/6
8.  变长参数函数、\_\_stdcall、\_\_fastcall、extern "C"等函数bind时需要显式指定返回值类型才行
9.  function是一个函数对象的“容器”，概念上像是C/C++中的函数指针类型的泛化，是一种“智能函数指针”
10. 调用空的function将抛出bad\_function\_call异常，最好在使用前通过empty()来测试有效性
11. 与原始的函数指针相比，function对象的体积要稍微大一点（3个指针的大小），速度要稍微慢一点（10%左右的性能差距），但这与它带给程序的巨大好处相比是无足轻重的
12. signals2基于boost中的另一个库signals，实现了线程安全的观察者模式。在signals2库中，观察者模式被称为信号/插槽(sinals and slots)，它是一种函数回调机制，一个信号关联了多个插槽，当信号发出时，所有关联它的插槽都会被调用
13. signal是不可拷贝的，如果把signal作为自定义类的成员变量，那么自定义类也将是不可拷贝的，除非用shared\_ptr来包装
14. signal.connection()连接插槽时，会返回一个connection对象，可以用来管理信号和插槽之间的连接关系
15. signal2库使用slot类提供了自动连接管理的功能，能够自动跟踪插槽的生命周期，但插槽失效时会自动断开连接
16. 较之signals，signals2具有线程安全，能够用于多线程环境，而且不需要编译就可以使用

第12章 并发编程

1.  thread库提供的互斥量：
    
    1.  mutex：独占式互斥量
    2.  timed\_mutex：提供超时锁定功能的独占式互斥量
    3.  recursive\_mutex：递归式互斥量，可以多次锁定，相应的也要多次解锁
    4.  recursive\_timed\_mutex：提供超时锁定功能的递归式互斥量
    5.  shared\_mutex：multiple-reader/single-writer型的共享互斥量（读写锁）
2.  scoped\_lock和scoped\_try\_lock可以在退出作用域时确保unlock的调用
3.  <boost/detail/atomic\_count.hpp>提供了一个原子计数器——atomic\_count，使用long进行线程安全的递增递减计数
4.  信号量：condition\_variable\_any和condition\_variable
5.  thread\_group提供一个简单的线程池，可以对一组线程统一操作
6.  thread库使用future范式提供异步操作线程返回值的方法，因为这个返回值在线程开始执行时开始不可用的，是一个“未来”的“期望值”，所以被称为future（期货）。future使用packaged\_task和promise两个模板类来包装异步调用，用unique\_future和shared\_future来获取异步调用的结果  
    int fab(int n) // 递归计算斐波那契数列  
    \{  
    if(n == 0 || n == 1) return 1;  
    return fab(n - 1) + fab(n - 2);  
    \}  
    int main()  
    \{  
    packaged\_task<int> pt(bind(fab, 10)); // 声明packaged\_task对象，用模板参数指明返回值的类型，packaged\_task只接受无参函数，因此需要使用bind  
    unique\_future<int> uf = pt.get\_future(); // 声明unique\_future对象，接受packaged\_task的future值，同样要用模板参数指明返回值类型  
    thread(boost::move(pt)); // 启动线程计算，必须使用boost::move()来转移packaged\_task对象，因为packaged\_task是不可拷贝的  
    uf.wait(); // unique\_future等待计算结果  
    assert(uf.is\_ready() && uf.has\_value());  
    cout << uf.get() << endl; // 输出计算结果89  
    \}
7.  为了支持多个future对象的使用，future还提供wait\_for\_any()和wait\_for\_all()两个自由函数，他们可以阻塞等待多个future对象，知道任意一个或者所有future对象都可用（is\_ready()）
8.  packaged\_task通过包装函数获得异步调用返回值，而promise通过包装函数输出参数获得返回值。在线程中用set\_value()设置promise返回值，用get\_future()获得值  
    void fab2(int n, promise<int>\* p) \{ p->set\_value(fab(n)); \}  
    int main()  
    \{  
    promise<int> p; // promise变量  
    unique\_future<int> uf = p.get\_future(); // 赋值future对象  
    thread(fab2, 10, &p); // 启动计算线程  
    uf.wait(); // 等待future计算结果  
    cout << uf.get() << endl;  
    \}
9.  thread库提供了两个自由函数lock()和try\_lock()，可以一次锁定多个互斥量，并且不会出现死锁  
    lock(mu1, mu2);  
    ...;  
    mu1.unlock(); // 逐个解锁  
    mu2.unlock();
10. 多线程仅执行一次初始化需要使用一个once\_flag对象，并把它初始化为BOOST\_ONCE\_INIT，然后使用call\_once()来调用初始化函数，完成仅执行一次的初始化  
    once\_flag of = BOOST\_ONCE\_INIT; // 一次初始化标志  
    void call\_func() \{ call\_once(of, init\_count); \} // 执行一次初始化  
    int main()  
    \{  
    (thread(call\_func)); // 必须用括号括住临时对象，否则编译器会认为这是个空thread对象声明  
    (thread(call\_func));  
    this\_thead::sleep(posix\_time::seconds(1)); // 等待1秒钟  
    \}
11. barrier（护栏）可用于多个线程同步，当线程执行到barrier时必须等待，直到所有的线程都达到这个点时才能继续执行。
12. thread\_specific\_ptr实现可移植的线程本地存储机制(thread local storage, TLS)或线程专有存储(thread specific storage, TSS)，可以简化多线程应用，提高性能  
    void printing()  
    \{  
    thread\_specific\_ptr<int> pi; // 线程本地存储一个整数  
    pi.reset(new int()); // 直接用reset()函数赋值  
    \++(\*pi); // 递增  
    mutex::scoped\_lock lock(io\_mu); // 锁定io流操作  
    cout << "thread v=" << \*pi << endl;  
    \}
13. this\_thread名字空间下提供了at\_thread\_exit(func)，允许注册一个线程结束回调，无论线程是否被中断。但线程意外终止的情况下，该回调不会被执行
14. promise和packaged\_task都支持回调函数，可以让future延后在需要的时候获得值，而不必主动启动线程计算
15. asio库基于OS提供的异步机制，采用前摄器设计模式（Proactor）实现了可移植的异步或同步IO操作，而且并不要求使用多线程和锁。目前asio主要关注与网络通信方面，支持TCP、ICMP、UDP等网络通信协议，还支持串口读写、定时器、SSL等功能。asio是一个很好的富有弹性的框架，可以扩展到其他有异步操作需要的领域。
16. asio库基于前摄器模式（Proactor）封装了OS的select、poll/epoll、kqueue、overlapped I/O等机制，实现了异步IO模型。它的核心类是io\_service，相当于前摄器模式中的Proactor角色，asio的任何操作都需要有io\_service的参数与。
    
    1.  在同步模式下，程序发起一个IO操作，向io\_service提交请求，io\_service把操作转交给OS，同步的等待。当IO操作完成时，OS通知io\_service，然后io\_service再把结果发回给程序，完成整个同步流程。
    2.  异步模式下，程序出了要发起IO操作，还要定义一个用于回调的完成处理函数。io\_service同样把IO操作转交给操作系统执行，但它不同步等待，而是立即返回。调用io\_service的run()成员函数可以等待异步操作完成，当异步操作完成时io\_service从OS获取操作结果，调用完成处理函数
    3.  asio不直接使用OS提供的线程，而是定义了strand以保证在多线程环境中无需使用互斥量。io\_service::strand::wrap()可以包装一个函数在strand中执行
    4.  asio提供了mutable\_buffer和const\_buffer两种可安全用于异步读写的缓冲区
17. ip::address表示IP地址，可以同时支持ipv4和ipv6两种地址
18. ip::tcp::endpoint表示ip地址和端口号
19. 同步socket示例：
    
    1.  Server：  
        int main()  
        \{  
        try  
        \{  
        cout << "server start" << endl;  
        io\_service ios; // asio程序必需的io\_service对象  
        ip::tcp::acceptor acceptor(ios, ip::tcp::endpoint(ip::tcp::v4(), 6688);  
        cout << acceptor.local\_endpoint().address() << end;  
        while(true)  
        \{  
        ip::tcp::socket sock(ios);  
        acceptor.accept(sock); // 阻塞等待socket连接  
        cout << "client:" << sock.remote\_endpoint().address() << endl;  
        sock.write\_some(buffer("hello asio")); // 发送数据。不能直接把数组、vector等容器用做asio的读写参数，必须通过buffer()函数包装  
        \}  
        \}  
        catch(std::exception& e) \{ cout << e.what() << endl; \}  
        \}
    2.  Client：  
        void client(io\_service& ios)  
        \{  
        try  
        \{  
        cout << "client start" << endl;  
        ip::tcp::socket sock(ios); // 创建socket对象  
        ip::tcp::endpoint ep(ip::address::from\_string("127.0.0.1"), 6688); // 创建连接端点  
        sock.connect(ep);  
        vector<char> str(100, 0);  
        sock.read\_some(buffer(str)); // 使用buffer包装缓冲区接收数据  
        cout << "receive from " << sock.remote\_endpoint().address() << &str\[0\] << endl;  
        \}  
        catch(std::exception& e) \{ cout << e.what() << endl; \}  
        \}  
        int main()  
        \{  
        io\_service ios;  
        a\_timer at(ios, 5, bind(client, ref(ios))); // 启动定时器  
        ios.run();  
        \}
20. 通常客户端不需要异步通信
21. resolver可实现域名解析
22. interprocess可以处理进程间通信（IPC）

第13章 编程语言支持

1.  任何程序开发语言都不可能独当一面、包打天下，总有它的长处与短处
2.  python库能够在C++中调用Python语言，但它更重要的功能在于用C++编写Python扩展模块，嵌入到Python解释器中调用，提高Python的执行效率
3.  C++中的构造函数不同于普通的成员函数，不能取其地址

第14章 其他Boost组件

1.  regex：需要编译才能使用的正则库
2.  sprit：面向对象的递归下降解析器生成框架，使用EBNF语法
3.  gil：有Adobe赞助开发的通用图像库。为像素、色彩、通道等图像处理概念提供了泛型的、STL式的容器和算法，可以对图像做灰度化、梯度、均值、选装等运算。支持jpg、png、tiff等格式
4.  graph：处理离散数学中的图结构，并提供图、矩阵等数据结构上的泛型算法。可以看做是STL在非线性容器领域的扩展。
5.  intrusive：侵入式容器。STL为非侵入式容器，不需要对容器内的元素类型做修改即可容纳
6.  pointer container：提供了与STL类似的若干种指针容器，性能较好且异常安全。用STL+shared\_ptr也可以做变通。
7.  multi\_index：实现具有多个STL兼容访问接口（索引）的容器
8.  iterators：定义一组基于STL的新迭代器概念、构造框架和游泳的适配器，能够用来更轻松的实现迭代器模式
9.  range：基于STL迭代器提出的“范围”概念，是一个容器的半开区间，使用range可以让代码更加简单漂亮
10. lambda：引入lambda表达式和函数式编程，可以就地创建小型的函数对象，避免函数定义离调用点太远，更方便代码维护。lambda表达式是一种新的编程范式，但其语法十分复杂，如果使用的不好很容易写出过于晦涩难懂的代码，使程序难以维护。
11. signals：观察者模式。功能和用法与signals2基本相同，非线程安全，需要编译。如果没有什么特殊理由，应该使用signals2库
12. enable\_if：允许模板函数或者模板类在偏特化时仅针对某些特定类型有效，依赖于SFINAE(substitution failure is not an error)原则
13. call\_traits：封装了可能是最好的传递参数给函数的方式，它会自动推导出最高效的传递参数传递类型
14. type\_traits：提供一组trait类，用以在编译器确定类型是否具有某些特征。使用type\_traits可以编写出更好更高效的泛型代码
15. concept check：编译器检查模板函数或模板类的模板参数是否符合某个概念，是否运行进行模板参数推演。主要用来编写泛型算法或实现泛型库
16. function\_types：提供对函数、函数指针、函数引用和成员指针等类型进行分类、分解和合并的功能
17. in\_place\_factory：直接构造对象而不需要一个临时对象的拷贝
18. proto：允许在C++中构建专用领域嵌入式语言，基于表达式模板技术定义小型专用语言的“编译器”
19. property map：提供key-value映射的属性概念定义
20. fusion：提供基于tuple的容器和算法，是模板元编程的强大工具，可以与mpl很好的协同工作
21. mpl：模板元编程框架，包含有编译期的算法、容器和函数等完整的元编程工具。运用mpl，很多运行时的工作都可以在编译期完成，甚至编译结束就意味着程序的运行结束
22. preprocessor：预处理元编程工具，类似于模板元编程，但发生在编译之前的预处理阶段。preprocessor改变了以往人们对预处理器的看法，令人们认识到预处理也是一种强大的编程工具。preprocessor可以和模板元编程很好的配合，从而发挥更大的作用
23. interporcess：可移植的进程间通信（IPC）功能，包括共享内存、内存映射文件、信号量、文件锁、消息队列等现代操作系统的IPC机制，并提供了简洁易用的STL风格接口，大大简化了IPC编程工作
24. MPI：高性能分布式并行计算应用开发，封装了标准的MPI（消息传递接口）以更好的支持现代C++编程风格。需要有底层MPI实现的支持，如Open MPI、MPICH等
25. accumulators：用于增量统计的库，也是一个用于增量计算的可扩展的累加器框架，可以看做是std::accumulate算法的扩展
26. interval：处理“区间”相关的数学问题，把一般的算术运算和集合运算扩展到区间上
27. math：包含大量数学领域的模板类和算法，如复数的反三角函数、最大公约数和最小公倍数、四元数、八元数、拉格朗日多项式、椭圆积分、X方分布、伯努利分布等
28. uBLAS：用于线性代数的数学库，优于std::valarray。STL风格，容易使用并且效率很高
29. iostreams：扩展C++标准库流处理的框架。定义了Source、Sink、Filter等流处理概念，使得编写流处理更容易
30. serialization：实现C++数据结构的持久化，可以把任意的C++对象序列化为字节流或文本。并且支持STL容器
31. compressed\_pair：与std::pair类似，使用空基类优化技术。当两个成员之一是空类，则编译器就会“压缩”compressed\_pair的大小以节约空间
32. base\_from\_member：将成员移动到辅助基类，使用模板技术来进行成员初始化，实现子类初始化基类字段
33. vonversion：增强C++转型操作，提供多态对象转型的polymorphic\_cast<>、polymorphic\_downcast<>和字面量转换的lexical\_cast<>
34. flyweight：实现享元模式，享元对象是不可修改但可赋值的。
35. numeric conversion：提供用于安全数字转型的的一组工具，包括numeric\_cast<>、bounds<>和converter<>等
36. scope\_exit：使用preprocessor库的预处理技术实现在退出作用域时的资源自动释放，也可以执行任意的代码
37. statechart：一个功能完善且强大的优先状态自动机框架，完全支持UML语义，可以从UML模型很方便的转换为C++代码。比起手工构建的状态机，可以极大的缩短开发周期，并有足够的性能保证
38. units：实现物理学的量纲处理，包括长度、质量、时间、电流、温度、质量和发光强度等。使用了模板元编程技术（MPL），支持国际标准量纲，也支持其他常用的非标准量纲。所有量纲运算都在编译时，无运行时开销
39. value\_initialized：用于保证变量在声明时被正确的初始化，拥有零值或缺省值
40. utility：noncopyable、BOOST\_BINARY、BOOST\_CURRENT\_FUNCTION等
    
    1.  checked\_delete：编译期保证delete或delete\[\]操作删除的是一个完整类定义，以避免运行时出现未定义行为
    2.  next()和prior()：为迭代器提供后向和前向的通用处理方式
    3.  addressof：获得变量的真实地址，是取址符&的增强版本，对重载operator&免疫

第15章 Boost与设计模式

1.  创建型模式
    
    1.  抽象工厂（Abstract Factory）：抽象工厂模式就是把对象的创建封装在一个类中，这个类的唯一任务就是按需生产各种对象，通过派生子类的方式抽象工厂可以产生不同系列的、整套的对象。工厂类通常是单间，以保证在系统的任何地方都可以访问，其中的每个方法都是工厂方法。在较小的软件系统中，抽象工厂有时候会退化成一个没有子类的简单工厂
    2.  生成器（Builder）：生成器模式分解了复杂对象的创建过程，创建过程可以被子类改变，使同样的过程可以生产出不同的对象。生成器与抽象工厂不同，它不是一次性的创建出产品，而是分步骤逐渐的装配出对象，因为可以对创建过程进行更精细的控制
    3.  工厂方法（Factory Method）：工厂方法把对象的创建封装在一个方法中，子类可以改变工厂方法的生产行为生产不同的对象。工厂方法所属的类不一定是一个工厂类。
    4.  原型（Prototype）：使用类的实例通过拷贝的方式创建对象，具体的拷贝行为可以定制。最常见的用法是实现一个clone成员函数，该函数创建一个与原型形同或相似的新对象。因C++不能高效的返回一个对象，因此实践中很少有完全实现的原型模式，可以通过提供拷贝构造函数和operator=部分的实现原型模式
    5.  单件（Singleton）：保证类有且仅有一个实例，并且提供一个全局的访问点。通常的全局变量技术虽然也可以提供类似的功能，但不能防止用户创建多个实例。单件的基本原理很简单，但有很多实现的变化
2.  结构型模式
    
    1.  适配器（Adapter）：把一个类的接口转换（适配）为另一个接口，从而在不改变原有代码的基础上复用原代码。其别名wrapper更清晰的说明了它的实现结构：包装原有对象，再给出一个新的接口
    2.  桥接（Bridge）：分离了类的抽象和实现，使它们可以彼此独立的变化而互不影响。适配器模式关心的是接口不匹配的问题，不关心接口的实现，只要求对象能够协同工作；桥接模式的侧重点是接口的实现，通常接口是稳定的，桥接解决实现的变化问题
    3.  组合（Composite）：将小对象组合成树形结构，使用户操作组合对象如同操作一个单个对象。组合模式定义了“部分-整体”的层次结构，基本对象可以被组合成更大的对象，这些组合对象与基本对象拥有相同的接口。组合是透明的，用法完全一致。
    4.  装饰（Decorator）：可以在运行时动态的给对象增加功能。改变了对象的能力范围，而且可以递归组合。通过生成子类的方式也可以为对象增加功能，但它是静态的，而且大量的功能组合很容易产生“子类爆炸”现象。装饰模式可以动态、透明的给对象增加职责，并且在不需要的时候很容易去除，使用派生子类的方式无法达到这种灵活程度。
    5.  外观（Facade）：为系统中的大量对象提供一个一致的对外接口，以简化系统的时候。外观是另一种形式的wrapper，但不是包装一个对象，而是包装一组对象，简化了这组对象间的通信关系，给出一个高层次的易用接口。外观并不屏蔽系统里的对象，如果需要，用户完全可以越过外观的包装使用底层对象以获得更灵活的功能
    6.  享元（Flyweight）：使用共享的方式节约内存的使用，可以支持大量细粒度的对象。将对象的内部状态与外部状态分离，配合工厂模式生成仅有内部状态的小对象，工厂内部保持小对象的引用计数从而实现共享，外部状态可以通过计算得到。
    7.  代理（Proxy）：包装并控制对象。外界不能直接访问对象，必须通过代理才能与被包装的对象通信。
3.  行为模式
    
    1.  职责链（Chain of Responsibility）：把对象串成链，使链上每个对象都有机会处理请求。职责链把请求的发送者和接收者解耦，使两者都互不知情，而且职责链中的对象可以动态的增减，从而增强了处理请求的灵活性
    2.  命令（Command）：把请求封装成一个对象，使请求能够存储更多的信息拥有更多的能力。命令模式同样能够把请求的发送者和接收者解耦，但并不关心请求将以何种方式被处理。命令模式经常与职责链模式和组合模式一起使用：职责链模式处理命令模式封装的对象，组合模式可以把简单的命令对象组合成复杂的命令对象。
    3.  解释器（Interpreter）：用于实现小型语言解释器的体系。与组合模式相似，而且常常利用组合模式来实现语法树的构建
    4.  迭代器（Iterator）：将按某种顺序访问集合中元素的方式封装在一个对象中，从而无须知道集合的内部表示就可以访问集合
    5.  中介者（Mediator）：用一个中介对象封装一系列对象的交互联系，使他们不需要相互了解就可以协同工作。中介者模式在存在大量需要相互通信对象的系统中特别有用，因为对象数量的增加会使对象间的联系非常复杂，整个系统变得难以理解难以改动。这时中介者可以把这些对象解耦，每个对象只需要与中介对象通信，中介对象集中控制逻辑，降低了系统的通信复杂度。中介者模式如果使用不当很容易导致中介对象过度复杂，抵消了模式带来的好处
    6.  备忘录（Memento）：捕获一个对象的内部状态，并在对象之外保存该状态，在之后可以随时把对象恢复到之前保存的状态
    7.  观察者（Observer）：观察者模式定义了对象间一对多的联系，当一个对象的状态发生变化时，所有与它有联系的观察者对象都会得到通知。观察者模式将被观察者的目标和观察者解耦，一个目标可以有任意多的观察者，观察者也可以观察任意多的目标，构成复杂的联系，而每个观察者都不知道其他观察者的存在
    8.  状态（State）：允许对象在状态发生变化时行为也同时发生改变。状态转换通常的做法是对象内部有一个值当前的状态，根据状态的不同使用分支来执行不同的功能。这样会使类中存在大量结构类似的分支语句，变得难以维护和理解。状态模式消除了分支语句，把状态处理分散到各个状态子类，每个子类集中处理一种状态，使状态的转换清晰明确
    9.  策略（Strategy）：策略模式封装了不同的“算法”。使他们可以在运行时相互替换。策略模式改变类的行为内核，而装饰模式改变类的行为外观。如果类的接口很庞大，那么装饰模式的实现代价就过高，而策略模式仅改变类的内核，可能很小。
    10. 模板方法（Template Method）：在父类中定义操作的主要步骤，但并不实现，而是留给子类去实现。常见的用法是“钩子操作”，父类定义了所有的公开方法，在公开方法中调用保护的钩子方法，子类实现通过不同的钩子方法来扩展父类的行为
    11. 访问者（Visitor）：访问者模式分离了类的内部元素与访问他们的操作，可以在不改变内部元素的情况下增加作用于它们的新操作。如果一个类有很多内部数据，因此也就有很多访问操作，这样会使它的接口非常庞大，难以变动难以学习。访问者模式可以做到数据的存储与使用分离，不同的访问者可以集中不同类别的操作，并且可以随时增加新的访问者或者新方法来增加新的操作
4.  其他模式
    
    1.  空对象（Null Object）：空对象模式又称哑对象模式（Dumb Object），扩展了空指针的含义，给空指针一个默认的、可接受的行为，通常是空操作，可以说是一个“智能空指针”。使用空对象模式，程序就可以不必用条件语句专门处理空指针或类似的概念，所有的对象都会有一致的、可理解的行为。空对象模式可以和许多行为模式配合，充当“哨兵”的角色。
    2.  包装外观（Wrapper Facade）：包装外观模式很类似外观模式，但包装的目标不是一个面向对象子系统，而是底层的API。包装外观模式把大量的原始C接口分类整理，给外界一个统一的、面向对象的易用接口，增强了原始底层接口的内聚性。包装外观模式可以屏蔽系统底层的细节，有利于外界不受平台变化的影响，增强可移植性。
    3.  前摄器模式（Proactor）：前摄器模式是应用于异步调用的设计模式，其核心是前摄器、异步的操作处理器、异步的事件多路分离器和完成事件队列，可以不使用线程完成异步操作。前摄器创建一个完成处理器，用于在异步调用完成后的回调，然后发起一个异步操作，交给操作处理器异步执行，当异步操作完成时操作处理器将把时间放入完成事件队列。前摄器调用多路分离器从完成事件队列中获得事件，分派事件回调完成处理器执行所需的后续操作。前摄器模式用于异步调用有很多好处，封装了并发机制，将并发机制与线程的执行解耦，简化了功能代码的编写，不需要考虑多线程的同步问题，能够提供高性能的异步操作。缺点是模式比较复杂，处理流程难以理解和调试。

第16章 结束语

1.  程序员是一个很特殊的职业，更多是用头脑而不是用双手来创造财富
2.  有两种编程的方式：一种是把代码写的非常复杂，以至于看不出明显的错误；另一种是把代码写的非常简单，以至于明显看不出错误
3.  注重单元测试
4.  不要重复发明轮子
5.  不能仅了解一门编程语言，这样很容易僵化解决问题的思路
6.  方法学很重要。不一定某种方法学适合你，但可以从中汲取有用的只是，帮助你在更高的层次上看待问题进而解决问题
7.  使用好的开发工具。易用的、高效率的开发工具可以节约程序员大量宝贵的时间，把精力集中在需要处理的问题上，而不是其他易分心的事情
8.  生活中不只有C++、代码和编程，还有更多的东西值得我们去体味。拥有美好的生活才能够创造出完成的程序。