BOOST开发指南

转载 2015年07月09日 10:33:26
第1章 Boost程序库总论
  1. 使用Boost,将大大增强C++的功能和表现力

 

第2章 时间与日期

  1. timer提供毫秒级的计时精度,内部是通过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>
  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++、代码和编程,还有更多的东西值得我们去体味。拥有美好的生活才能够创造出完成的程序。

推荐阅读:
Boost 编译

2011-5-19
    BOOST_SCOPE_EXIT可以在程序退出作用域时自动执行指定的代码段,可以模拟finally。shared_ptr<T> ptr(p, D)也可以实现类似功能,但用BOOST_SCOPE_EXIT意图更明确。
BOOST_SCOPE_EXIT((&connection)) // 此处&为取引用的意思,参数必须被独立的括号包住,多个参数之间空格分隔
{
    connection.Close();
    delete connection;
}
BOOST_SCOPE_EXIT_END;

《Boost程序完全开发指南》

1.3开发环境 由于Boost大量使用了C++高级特性(如模板偏特化、ADL),因此不是所有的编译器都 能够很好地支持Boost。 在VC集成环境中使用嵌入工程编译的方式需要定义宏BOO...

读《Boost程序库完全开发指南》

读《Boost程序库完全开发指南》   2011-05-18 20:47:19|  分类:读书|  标签:|字号大中小 订阅     C++确实很复杂,神一样的0x...
  • dj0379
  • dj0379
  • 2011年11月06日 04:37
  • 1849

《Boost程序库完全开发指南》

[转]读《Boost程序库完全开发指南》 原文: http://dearymz.blog.163.com/blog/static/2056574201141883716608/   第1章 Boo...

boost完全开发指南第2章-处理时间3(日期date)

5、date (1)创建日期 测试代码: #include #include using namespaceboost::gregorian;   void create_date_obj_t...

Boost程序库完全开发指南----第6章 正确性与测试

第6章正确性与测试     测试对于软件开发是非常重要的,程序员——尤其是C++程序员更应该认识到这一点。     但C/C++只提供了很有限的正确性验证/测试支持——assert宏 (没错,它是...
  • tiewen
  • tiewen
  • 2013年03月20日 12:37
  • 2406

《Boost标准库完全开发指南》第三章-内存管理

1、使用boost智能指针只需要引用头文件#include。 2、与auto_ptr不同,scoped_ptr只在本作用域使用,不能转让,auto_ptr在c++11已被声明废弃,改用unique_p...

读《Boost程序库完全开发指南》

读《Boost程序库完全开发指南》   2011-05-18 20:47:19|  分类: 读书|举报|字号 订阅     C++确实很复杂,神...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:BOOST开发指南
举报原因:
原因补充:

(最多只允许输入30个字)