boost开发指南

时间 2019-11-21

标签 boost 开发指南栏目 C&C++ 繁體版

原文原文链接

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

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

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

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

第1章 Boost程序库总论

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

第2章时间与日期程序员

timer提供毫秒级的计时精度，内部是经过std::clock取时间的
progress_timer自动打印某生命周期的执行时间
原则上程序库的代码是不该该被用户修改的
progress_display能够在控制台上显示程序的执行进度
date_time库能很好的表示日期时间概念，并能和C的时间结构tm进行友好互转
date类提供年月日和星期几的概念。data可经过from_string或from_undelimited_string从字符串解析而来，可经过to_simple_string、to_iso_string、to_extended_iso_string转换为字符串。（精度到天的DateTime）
day_clock是精度到天的时钟
date_duration表示的是天精度的时间间隔概念，别名为days，另外还有years、months、weeks
date_period表示两个date之间的日期区间（精度到天的TimeSpan）
date_iterator、week_iterator、month_iterator和year_iterator是时间的迭代器
boost::greorian::gregorian_calendar中有实用静态方法：is_leap_year、end_of_month_day
time_duration表示微妙或纳秒级的时间概念，几个实用子类：hours、minutes、seconds、millisec/milliseconds、microsec/microseconds、nanosec/nannoseconds
duration_from_string能够从字符串解析time_duration
ptime用来表示时间点，至关于date和time_duration的组合。能够用time_from_string或from_iso_string解析。（TimeSpan）
ptime now1 = second_clock::local_time(); // 获得本地当前秒精度时间
ptime now2 = microsec_clock::universal_time(); // 获得本地当前微秒精度时间
time_period表示两个ptime之间的时间区间。（DateTime）
时间迭代器没有日期迭代器那么多，只有time_iterator一个
（boost时间日期库乱、破碎、过分设计）

第3章内存管理正则表达式

scoped_ptr相似auto_ptr，但其一旦得到对象的管理权，你就没法再从它那里取回来。该智能指针只但愿在本做用域里使用，不但愿被转让。auto_ptr有意设计成全部权的自动转让，scoped_ptr有意设计成全部权的没法转让。scoped_ptr和auto_ptr均不能做为容器元素。
scoped_array包装的是new[]产生的指针，并调用的是delete[]。每每是用来和C代码保持兼容，通常不推荐使用
不管是编译器仍是程序员都很难区分出new[]和new分配的空间，错误的运用delete将致使资源异常
在C++历史上曾经出现过无数的引用计数型智能指针实现，但没有一个比得上boost::shared_ptr，在过去、如今和未来，它都是最好的
shared_ptr支持的转型有：static_pointer_cast<T>、const_pointer_cast<T>、dynamic_pointer_cast<T>，返回的结果是shared_ptr，并能保证这些指针的引用计数正确
用shared_ptr能够消除代码中显示的delete，用make_shared、allocate_shared能够消除代码中显示的new
桥接模式(bridge)是一种结构型设计模式，它把类的具体实现细节对用户隐藏起来，以达到类之间的最小耦合关系。在具体编程实践中桥接模式也被称为pimpl或者handle/body惯用法，它能够将头文件的依赖关系降到最小，减小编译时间，并且能够不使用虚函数实现多态
get_deleter(shared_ptr<T> const& p)能够得到删除器。shared_ptr的删除器在处理某些特殊资源时很是有用，它使得用户能够定制、扩展shared_ptr的行为，使其不只仅可以管理内存资源，而是称为一个“万能”的资源管理工具
对应shared_ptr，也有一个shared_array，scoped_array和shared_array均不对operator[]作下标检测
weak_ptr是为配合shared_ptr而引入的，更像是shared_ptr的一个助手而不是智能指针，其没有重载operator*和->，不具备普通指针的行为。它最大的做用在于协助shared_ptr工做，像旁观者那样观测资源的使用状况
weak_ptr被设计为与shared_ptr共同工做，能够从一个shared_ptr或者另外一个weak_ptr对象构造，得到资源的观测权。但weak_ptr没有共享资源，它的构造不会引发指针引用计数的增长。一样，在weak_ptr析构时也不会致使引用计数的减小，它只是一个静静的观察者
得到this指针的shared_ptr，使对象本身可以产生shared_ptr管理本身：class T : public enable_shared_from_this<T>, then shared_ptr shared_from_this().
intrusive_ptr是一个侵入式的引用计数型指针。当对内存占用的要求很是严格，或现存代码已经有了引用计数机制时能够考虑。通常状况不推荐使用。
pool为固定块大小的相似malloc的原生内存分配器，支持数组式分配，通常状况下没必要对分配的内存调用free()。只分配原生内存，不调用构造函数，回收不调用析构函数，最好不要用于对象。
singleton_pool和pool接口彻底一致，但为单件线程安全，一样要求编译期指定要分配的原生内存块大小
object_pool为特定类型的对象池，不支持数组式分配，支持对象分配和对象原生内存分配
pool_alloc和fast_pool_allocator是boost提供的两个STL分配器。除非有特别需求，咱们应该总使用STL实现自带的内存分配器。使用定制的分配器须要通过仔细的测试，以保证它与容器能够共同工做。
内存管理是C++程序开发中永恒的话题，由于没有GC，当心谨慎的管理内存等系统资源是每个C++程序员都必须面对的问题

第4章实用工具算法

private继承自noncopyable能够编译时禁止对象拷贝语法
C++静态强类型的优势有时候反而是阻碍程序员生产力的“缺陷”
typeof库使用宏模拟了C++0X中的typedef和auto关键字，能够减轻书写繁琐的变量类型声明工做，简化代码。对于用户自定义类型须要手工用宏注册。（语法并没那么好看，不许备使用）
optional<T>使用“容器”语义，包装了“可能产生无效值”的对象，实现了“未初始化”的概念（Nullable<T>）
optional<T> make_optional(bool condition, T const& v)用来简单构建optional对象，但不能处理optional<T&>的状况。(此乃鸡肋)
optional<string> str(in_place("string就地建立"))，而不需拷贝临时对象，避免大对象的拷贝开销
用于初始化的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");
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");
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";
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"))
若是须要将括号与逗号混合使用，则要求最外侧加一个括号，不然编译器没法推导
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")
assign tuple_list_of用户初始化元素类型为tuple的容器
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
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();
assign也支持部分不在STL中的非标准容器slist、hash_map、hash_set，由于其符合标准容器定义，同时也支持大部分boost容器：array、circular_buffer、unordered等
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);
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);
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);
单件boost::details::pool::singleton_default<T>在main以前进行构造，支持继承或非继承形式（最恨main以前的事情了）
单件boost::serialization::singleton<T>在main以前进行构造，支持继承或非继承形式。继承方式更完全一些，非继承方式不影响原有代码
boost::tribool三态bool，indeterminate(tribool)可判断一个三态bool是否处于不肯定状态
选择optional<bool>仍是tribool：若是返回值多是无效的，那么就是optional<bool>，若是返回值老是肯定的，但可能没法肯定其意义，那么就用tribool（最多本身随手定义个enum状态，为了这点需求须要记住这一堆名称和细节！）
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[]
若是只关心类的等价语义，那么就用equivalent，若是想要精确的比较两个对象的值，就是用equality_comprable。相等equivalent基于"=="实现，而equality_comprable基于"<"的"!(x<y)&&!(x>y)"实现。
应该总对异常类是用虚继承
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;
}
从exception派生的异常定义很是简单，没有实现代码，能够很容易创建起一个适合本身程序的、惊喜完整的异常类体系。只要都是用虚继承，类体系能够任意复杂。
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;
enable_error_info<T>(T& e)，能够将已将存在的任意类型包装为boost异常类型
throw_exception(任意异常类型)，能够自动将任意异常类型包装为boost异常，还能保证线程安全
diagnostic_information(e)能够获得任意boost异常的字符串内容描述；在catch块中调用current_exception_diagnostic_information()，则不用传参数e。（何须呢，为少写一两个字母反而要记住一个更长的名字）
catch块内的异常转型用current_exception_cast<T>()
catch块内调current_exception()获得当前异常指针的exception_ptr是线程安全的，rethrow_exception能够从新抛出异常
UUID, Universally Unique Identifier, 128bit(16 Byte)，不须要中央认证机构就能够建立全球惟一的标识符。别名GUID
不是全部的警告均可以忽略的，有的警告预示着可能潜在的错误
BOOST_BINARY(111 00 1)，能够实现编译器的二进制定义，但不能超过8bit

第5章字符串与文本处理

lexical_cast<T>(X)，能够实现字符串和数值类型之间的转换，但不支持高级格式控制。转换失败将抛出bad_lexical_cast异常。lexical_cast底层用C++流实现，要求目标类型支持operator<<、operator>>、无参构造函数和拷贝构造函数
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
format在提供的参数过多或过少的状况下operator<<或str()都会抛出异常
format彻底支持printf的格式化选项方式，同时还增长了新的方式：
1. %|spec|%：与printf格式选项功能相同，但两边增长了竖线分隔，能够更好的区分格式化选项有普通字符
2. %N%：标记第N个参数，至关于占位符，不带任何其余的格式化选项
format由于作了不少安全检查工做，会比printf慢至少2-5倍
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流操纵器以指定格式或输入参数值
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
tokenizer相似string_algo::split，为更专业的token划分工具。tokenizer库提供预约义好的四个分词对象：
1. char_delimiter_separator：使用标点符号分词，是默认的分词函数对象。已被声明废弃
2. char_separator：支持一个字符集合做为分隔符，默认行为与char_delimiter_separator相似
3. escaped_list_separator：用于CSV格式的分词
4. offset_separator：使用偏移量来分词
xpressive，相似boost.regex的正则表达式解析器，同时仍是一个相似于boost.spirit的语法分析器，而且将这两种彻底不相交的文本处理方式完美的融合在了一块儿
xpressive使用regex_token_iterator<>提供了强大的分词迭代器

第6章正确性测试

测试对于软件开发是很是重要的，程序员——尤为是C++程序员更应该认识到这一点
BOOST_ASSERT宏相似于assert宏，提供运行时断言，但功能有所加强。能够经过BOOST_DISABLE_ASSERTS来关闭。当定义BOOST_ENABLE_ASSERT_HANDLER后，断言触发时将会调用boost::assertion_failed回调
BOOST_VERIFY相似BOOST_ASSERT，但断言表达式必定会被求值，Release下仍然会失效（放弃BOOST_VERIFY）
BOOST_STATIC_ASSERT，编译时断言。能够出如今程序的任何位置，而不必定只在函数域内
测试用例是一个包含多个测试断言的函数，它是能够被独立执行测试的最小单元，各个测试用例之间是无关的，发生的错误不会影响到其余测试用例

第7章容器与数据结构编程

array是的C原生数组的STL接口包装
std::vector<bool>是vector对bool的特化，内部保存的实际为bit，支持动态长度。std::bitset大小固定，但支持更多的位运算
boost.dynamic_bitset相似std::vector<bool>能够动态长度，同时提供了丰富的位运算。dynamic_bitset还支持集合相关操做
哈希容器：boost::unordered_map、boost::unordered_set、boost::unordered_multimap、boost::unordered_multiset
boost::bimap，双向映射容器，提供left、right两个试图。支持的集合类型有：set_of、multiset_of、unordered_set_of、unordered_multiset_of、list_of、vector_of、unconstrained_set_of
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)); // 至关于使用右视图
circular_buffer<T>为大小固定的循环缓冲区，circular_buffer_space_optimized<T>相似circular_buffer<T>但只在确实须要时才分配内存，而且当容器内元素减小时自动释放内存
tuple是固定数目非同质元素容器。tuple是std::pair的泛化，能够从函数返回任意数量的值，也能够代替struct组合数据
和std::make_pair对应，也有个make_tuple用来简化tuple的建立
tie()能够生成一个元素类型全是引用的tuple，至关于make_tuple(ref(a), ref(b), ...)，能够用于左值，一般用来接收返回tuple或pair函数的返回值，能够当作是对tuple的解包
element<N, T>::type能够给出T中第N个元素的类型，length<T>::value能够给出T的元素数量
any可以容纳任意类型，能够用any_cast<T>(a)类型安全的取出any中的值（让人联想到Ogre::Any）
any能够持有原始指针，但这样的用法很不安全，会致使内存泄露。应该使用智能指针包装原始指针，这样在any析构时智能指针会自动的调用delete，从而安全的释放资源
若是但愿一种数据结构具备tuple那样的容纳任意类型的能力，又能够在运行时动态变化大小，那么就能够用any做为元素类型搭配容器
variant是对C/C++中union概念的加强和扩展。varinat是有界类型，元素类型范围由用户指定，any是无界类型，能够容纳任意类型
multi_array<int, 3>，至关于int ma[X][Y][Z]的多维数组。multi_array没有异常机制来处理错误，保证数组范围不越界是库用户本身的责任
property_tree是一个保存了多个属性值的树形数据结构，能够用相似路径的简单方式访问任意节点的树形，并且每一个节点均可以用相似STL的风格遍历子节点。property_tree特别适合于应用程序的配置数据处理，能够解析xml、ini、json和info四种格式的文本数据，使用它能减轻本身开发配置管理的工做。

第8章算法json

boost foreach库提供BOOST_FOREACH和BOOST_REVERSE_FOREACH来实现对容器的正向和反向遍历
minmax(a, b)可在一次处理中同时得到最大最小值，执行效率上有很大提升（有提早优化的感受了）
minmax_element算法族能够获得迭代器区间内的最大最小值

第9章数学与数字windows

从纯数学的角度看，程序也不过是一个很是大的整数而已
integer_traits : public std::numeric_limits，提供各类整数类型的编译期最大最小值
<boost/cstdint.hpp>基于C99标准中的<stdint.h>，定义了各类标准的整数
<boost/integer.hpp>与<boost/cstdint.hpp>功能相似，用模板类而不是typedef提供各类整数类型定义
boost.rational表示有理数（分数），rational_cast<R>能够将有理数转换为普通数字
最大公约数gcd()；最小公倍数lcm()
crc_optimal以字节为单位的快速CRC计算，实际经常使用的是crc_32_type的预约义算法
boost random库提供了26个伪随机数发生器
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：球面均匀分布
variate_generator<Engine, Distribution>变量发生器，用于组合随机数发生器和分布器
真随机数没法用纯软件产生，由于计算机自己是个肯定的有限状态自动机

第10章操做系统相关

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
system库使用轻量级的对象封装了操做系统底层的错误代码和错误信息，使调用操做系统功能的程序能够被很容易的移植到其余操做系统
filesystem库中的path和wpath提供了文件路径相关的不少实用操做（相似Path）
portable_posix_name()和windows_name()分别检测文教案名字符串是否符合POSIX和Windows规范。Windows的文件名能够字符范围比POSIX的大。
native()判断文件名是否符合本地文件系统命名规则
为了程序的健壮性，应总使用try-catch来保护文件访问代码
directory_iterator和wdirectory_iterator提供了迭代一个目录下全部文件的功能
recursive_directory_iterator和wrecursive_directory_iterator提供递归遍历目录功能
program_options库提供了强大的命令行参数处理功能，它不只可以分析命令行，也可以从配置文件甚至环境变量中获取参数，实现了很是完善的程序配置选项处理功能
#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; }
}
program_options库的解析程序选项功能由三个基本组件构成，分别是选项描述器、分析器和存储器。选项描述其定义选项及选项的值，分析器依据选项描述器的定义解析命令行或数据文件，存储器则把分析器的结果保存起来以供使用

第11章函数与回调

result_of<Func(T1, T2)>::type肯定一个调用表达式的返回类型，是实现泛型库的底层基本构件
ref()和cref()能够包装对象的引用，在传递参数时消除对象拷贝的代价，或者将不可拷贝的对象变为能够拷贝
bind是对标准库bind1st、bind2nd的泛化和加强，能够适配任意的可调用对象。
bind第一个参数必须是一个可调用对象，包括函数、函数指针、函数对象和成员函数指针
bind也能够绑定到public成员变量，用法与绑定成员函数相似，只须要把成员变量名像一个成员函数同样去使用
bind绑定到仿函数时，要求仿函数typedef xxx result_type;不然就只能用bind<xxx>(functor())的形式
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
变长参数函数、__stdcall、__fastcall、extern "C"等函数bind时须要显式指定返回值类型才行
function是一个函数对象的“容器”，概念上像是C/C++中的函数指针类型的泛化，是一种“智能函数指针”
调用空的function将抛出bad_function_call异常，最好在使用前经过empty()来测试有效性
与原始的函数指针相比，function对象的体积要稍微大一点（3个指针的大小），速度要稍微慢一点（10%左右的性能差距），但这与它带给程序的巨大好处相比是无足轻重的
signals2基于boost中的另外一个库signals，实现了线程安全的观察者模式。在signals2库中，观察者模式被称为信号/插槽(sinals and slots)，它是一种函数回调机制，一个信号关联了多个插槽，当信号发出时，全部关联它的插槽都会被调用
signal是不可拷贝的，若是把signal做为自定义类的成员变量，那么自定义类也将是不可拷贝的，除非用shared_ptr来包装
signal.connection()链接插槽时，会返回一个connection对象，能够用来管理信号和插槽之间的链接关系
signal2库使用slot类提供了自动链接管理的功能，可以自动跟踪插槽的生命周期，但插槽失效时会自动断开链接
较之signals，signals2具备线程安全，可以用于多线程环境，并且不须要编译就可使用

第12章并发编程

thread库提供的互斥量：
1. mutex：独占式互斥量
2. timed_mutex：提供超时锁定功能的独占式互斥量
3. recursive_mutex：递归式互斥量，能够屡次锁定，相应的也要屡次解锁
4. recursive_timed_mutex：提供超时锁定功能的递归式互斥量
5. shared_mutex：multiple-reader/single-writer型的共享互斥量（读写锁）
scoped_lock和scoped_try_lock能够在退出做用域时确保unlock的调用
<boost/detail/atomic_count.hpp>提供了一个原子计数器——atomic_count，使用long进行线程安全的递增递减计数
信号量：condition_variable_any和condition_variable
thread_group提供一个简单的线程池，能够对一组线程统一操做
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
}
为了支持多个future对象的使用，future还提供wait_for_any()和wait_for_all()两个自由函数，他们能够阻塞等待多个future对象，知道任意一个或者全部future对象均可用（is_ready()）
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;
}
thread库提供了两个自由函数lock()和try_lock()，能够一次锁定多个互斥量，而且不会出现死锁
lock(mu1, mu2);
...;
mu1.unlock(); // 逐个解锁
mu2.unlock();
多线程仅执行一次初始化须要使用一个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秒钟
}
barrier（护栏）可用于多个线程同步，当线程执行到barrier时必须等待，直到全部的线程都达到这个点时才能继续执行。
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;
}
this_thread名字空间下提供了at_thread_exit(func)，容许注册一个线程结束回调，不管线程是否被中断。但线程意外终止的状况下，该回调不会被执行
promise和packaged_task都支持回调函数，可让future延后在须要的时候得到值，而没必要主动启动线程计算
asio库基于OS提供的异步机制，采用前摄器设计模式（Proactor）实现了可移植的异步或同步IO操做，并且并不要求使用多线程和锁。目前asio主要关注与网络通讯方面，支持TCP、ICMP、UDP等网络通讯协议，还支持串口读写、定时器、SSL等功能。asio是一个很好的富有弹性的框架，能够扩展到其余有异步操做须要的领域。
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两种可安全用于异步读写的缓冲区
ip::address表示IP地址，能够同时支持ipv4和ipv6两种地址
ip::tcp::endpoint表示ip地址和端口号
同步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();
  }
一般客户端不须要异步通讯
resolver可实现域名解析
interprocess能够处理进程间通讯（IPC）

第13章编程语言支持

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

第14章其余Boost组件

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

第15章 Boost与设计模式

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

第16章结束语

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