1.标准模板库主要包括六大组件：container容器,algorithm算法,iterator迭代器,adapter配接器,functor仿函数,allocator配置器. STL的基本观念就是将数据与操作分离，从而提高代码复用。
2.C++提供关键字explicit，可以阻止不应该允许的经过转换构造函数进行的隐式转换发生．声明为explicit的构造函数不能在隐式转换中使用．
3.big-O表示法将C++程序的运行时间复杂度表示为典型的5种类别：常数型，对数型，线型，n-log-n型，指数型。
4，命名空间的三种使用方法：直接指定标识符(std::cout<<std::hex<<std::endl;)；使用using declaration(using std::cout;cout<<std::hex<<endl;);使用using directive(using namespace std; cout <<hex<<endl;).
5.C++的头文件没有扩展名。
6.auto_ptr所做的事情，就是动态分配对象以及当对象不再需要时自动执行清理。使用std::auto_ptr，要#include <memory>.
7.pair是一个很简单的数组组合而已，但是需要struct定义，它其实只是提供了你把两个类型组队的功能而已。
8.“&”的功能之一是引用，如 const T&max(const T&a,const T&b){},就是定义返回值类型为常量T的引用函数max，其参数为类型为T的引用常量a,b.
9.容器containers，用来管理某类对象的集合。
10.迭代器Iterators,用来在一个对象群集的元素上进行遍历动作。
11.算法Algorithms,用来处理群集内的元素。
12.序列式容器Sequence containers,为可序（ordered)群集，其中每个元素均有固定位置--取决于插入时机和地点，和元素值无关。如vector,deque,list. 而string,array类似。
13.关联式容器Associative containers,为已序（sorted）群集，元素位置取决于特定的排序准则。如set,mutiset,map,multimap.
14.vector将元素置于一个dynamic array中加以管理。
15.迭代器iterator是容器的定义的，故某个迭代器是专用于某个容器的。
16.双向迭代器（Bidirectional iterator),即可以双向行进的迭代器，以递增(increment)运算前进或以递减(decrement)运算后退。list,set,multiset,map,multimap支持此类。
17.随机存取迭代器（Random access iterator),即不但可以双向迭代，还具备随机访问能力。vector,deque,strings支持此类。
18.算法（Algorithms),不是容器类别的成员函数，而是一种搭配迭代器使用的全局函数。但迭代器是作为容器的函数操作的。
19.迭代器适配器（Iterator Adapters），即预先定义的特殊迭代器，常用的为3个，即insert iterators(安插型迭代器),stream iterators(流迭代器),reverse iterators(逆向迭代器).
20.流迭代器（Stream Iterators) 是一种用来读写stream的迭代器。copy(istream_iterator<string>(cin),istream_iterator<string>(),back_inserter(coll));表示连续输入字符，以ctr+z退出，同时后端插入容器coll中。
21pair or make_pair的主要目的是将两个数据合并成一个数据，且两个数据的类型可以不同。
22.更易型算法（Manipulating Algorithms),是指一些可能变更目标区间的内容，甚至会删除元素的算法，即算法中的特殊一类,且适用与序列式容器，而不适用于关联式容器。包括remove,resort,modify.
23.一般情况下，容器的成员函数优先与算法使用。
24.typename用来作为型别之前的标识符号。如typename T::subtype *ptr;T::subtype *ptr;则前面为一个型别指针，后者为一个型别为T的值的指针。
25.PRINT_ELEMENTS(A,B);的第二个参数是可以省略的，但出现时放在打印的内容之前。此函数包含在头文件print.hpp中。
26.for_each(coll.begin(),coll.end(),print);针对前两个参数之间的每个元素调用第三个函数参数。
27.std::transform(coll1.begin(),coll1.end(),std::back_inserter(coll2),square);表示将前两个参数之间的元素通过第四个函数参数的运算后进行第三个参数的操作。
28.Predicates判断式，即返回布尔值boolean的函数。分为一元判断式Unary Predicates和二元判断式Binary Predicates。
29.find_if(coll.begin(),coll.end(),isPrime);表示在前两个参数的区间内寻找符和第三个函数参数的元素。isPrime()判断是否为质数。
30.仿函数（Functors,Function Objects), 传递给算法的“函数型参数”（functional arguments),并不一定得是函数，可以是行为类似函数的对象，这种对象称为function object(函数物件），或称functor(仿函数）。
31.STL容器元素必须满足以下三个基本要求及三个附加要求：第一，必须可通过COPY构造函数进行复制。第二，必须可以通过assignment操作符完成赋值操作。第三，必须可以通过析构函数完成销毁动作。附加一，序列式容器的元素的default构造函数必须可用。附加二，对于某些动作，必须定义operator==以执行相等测试。附加三，关联式容器中，元素必须定义出排序准则，且缺省为operator<,通过仿函数less()被调用。
32.C++程序库的两个特点：对于所有“以节点为实现基础”（node-based)的容器，如lists,sets,multisets,maps和multimaps,如果节点构造失败，容器保持不变。所有“以array为构造基础“（array-based)的容器如vectors和deques,安插元素时如果失败，都不可能做到完全回复。
33.所有的容器都会建立元素副本，并返回该副本。即STL容器提供的是“value”语意，它们所容纳的是你所安插的对象值，而不是对象本身。如此，明白头文件什么意思了吧？
34.1容器类别的共通操作函数。
34.1.1 contType c 产生一个未含任何元素的空容器
34.1.2 contType c1(c2) 产生一个同型容器
34.1.3 contType c(beg,end) 复制区间内的元素作为容器初值
34.1.4 c.~contType() 删除所有元素，释放内存
34.1.5 c.size() 返回容器中的元素数量
34.1.6 c.empty() 判断容器是否为空，相当于c.size()==0;
34.1.7 c.max_size() 返回元素的最大可能数量
34.1.8 c1==c2 判断相等
34.1.9 c1!=c2 判断不等
34.1.10 c1<c2 判断小于
34.1.11 c1>c2 判断大于
34.1.12 c1<=c2 判断小于等于
34.1.13 c1>=c2 判断大于等于
34.1.14 c1=c2 赋值
34.1.15 c1.swap(c2) 交换数据
34.1.16 swap(c1,c2) 交换数据
34.1.17 c.begin() 返回一个迭代器，指向第一个元素
34.1.18 c.end() 返回一个迭代器，指向最后元素的下一个位置
34.1.19 c.rbegin() 返回一个逆向迭代器，指向逆向遍历时的第一个元素
34.1.20 c.rend() 返回一个逆向迭代器，指向逆向遍历时的最后元素的下一个位置
34.1.21 c.insert(pos,elem) 将elem的一份副本安插于pos处，返回值和pos的意义并不相同
34.1.22 c.erase(beg,end) 移除区间内的所有元素，某些容器会返回未被移除的第一个接续元素
34.1.23 c.clear() 移除所有元素，令容器为空
34.1.24 c.get_allocator() 返回容器的内存模型（memory model)
35.1vector操作函数。头文件<vector>.
35.1.1 contType c 产生一个未含任何元素的空容器
35.1.2 contType c1(c2) 产生一个同型容器
35.1.3 contType c(n) 利用default构造函数生成一个大小为n的容器
35.1.4 contType c(n,elem) 产生一个大小为n的容器，每个元素值都是elem
35.1.5 contType c(beg,end) 复制区间内的元素作为容器初值
35.1.6 c.~contType() 删除所有元素，释放内存
35.1.7 c.size() 返回容器中的元素数量
35.1.8 c.empty() 判断容器是否为空，相当于c.size()==0;
35.1.9 c.max_size() 返回元素的最大可能数量
35.1.10 c1==c2 判断相等
35.1.11 c1!=c2 判断不等
35.1.12 c1<c2 判断小于
35.1.13 c1>c2 判断大于
35.1.14 c1<=c2 判断小于等于
35.1.15 c1>=c2 判断大于等于
35.1.16 c1=c2 赋值
35.1.17 c1.swap(c2) 交换数据
35.1.18 swap(c1,c2) 交换数据
35.1.19 c.begin() 返回一个迭代器，指向第一个元素
35.1.20 c.end() 返回一个迭代器，指向最后元素的下一个位置
35.1.21 c.rbegin() 返回一个逆向迭代器，指向逆向遍历时的第一个元素
35.1.22 c.rend() 返回一个逆向迭代器，指向逆向遍历时的最后元素的下一个位置
35.1.23 c.insert(pos,elem) 将elem的一份副本安插于pos处，并返回新元素位置
35.1.24 c.insert(pos,n,elem) 在pos位置插入n个elem副本，无返回值
35.1.25 c.insert(pos,beg,end) 插入区间元素，无返回值
35.1.26 c.push_back(elem) 尾部添加副本
35.1.27 c.pop_back() 移除最后一个元素
35.1.28 c.erase(pos) 移除pos位置的元素，返回下一个元素的位置
35.1.29 c.erase(beg,end) 移除区间内的所有元素，返回未被移除的第一个接续元素
35.1.30 c.resize(num) 将元素数量更改为num，如果数量变大，多出来的部分以default构造函数构造
35.1.31 c.resize(num,elem) 将元素数量更改为num，如果变大，以elem赋值
35.1.32 c.clear() 移除所有元素，令容器为空
35.1.33 vector.capacity() 返回重新分配空间前所能容纳的元素最大数量
35.1.34 vector.reserve() 如果容量不足，扩大之。
35.1.35 vector.assign(n,elem) 复制N个ELEM，赋值给VECTOR
35.1.36 vector.assign(beg,end) 将区间元素赋值
35.1.37 vector.at(idx) 返回索引idx所标识的元素，若越界，抛出范围异常
35.1.38 vector(idx) 返回索引idx所标识的元素，不进行范围检查
35.1.39 vector.front() 返回第一个元素，不检查是否存在
35.1.40 vector.back() 返回最后一个元素，不检查是否存在
35.1.41 c.flip() 将所有bool元素值取反
35.1.42 c[idx].flip() 将索引idx的bit元素取反
35.1.43 c[idx]=val 令索引idx的bit元素值为val
35.1.44 c[idx]=c[idx2] 令索引idx1的bit元素值为索引idx2的bit元素值
36.1deque操作函数。头文件<deque>。
36.1.1 contType c 产生一个未含任何元素的空容器
36.1.2 contType c1(c2) 产生一个同型容器
36.1.3 contType c(n) 利用default构造函数生成一个大小为n的容器
36.1.4 contType c(n,elem) 产生一个大小为n的容器，每个元素值都是elem
36.1.5 contType c(beg,end) 复制区间内的元素作为容器初值
36.1.6 c.~contType() 删除所有元素，释放内存
36.1.7 c.size() 返回容器中的元素数量
36.1.8 c.empty() 判断容器是否为空，相当于c.size()==0;
36.1.9 c.max_size() 返回元素的最大可能数量
36.1.10 c1==c2 判断相等
36.1.11 c1!=c2 判断不等
36.1.12 c1<c2 判断小于
36.1.13 c1>c2 判断大于
36.1.14 c1<=c2 判断小于等于
36.1.15 c1>=c2 判断大于等于
36.1.16 c1=c2 赋值
36.1.17 c1.swap(c2) 交换数据
36.1.18 swap(c1,c2) 交换数据
36.1.19 c.begin() 返回一个迭代器，指向第一个元素
36.1.20 c.end() 返回一个迭代器，指向最后元素的下一个位置
36.1.21 c.rbegin() 返回一个逆向迭代器，指向逆向遍历时的第一个元素
36.1.22 c.rend() 返回一个逆向迭代器，指向逆向遍历时的最后元素的下一个位置
36.1.23 c.insert(pos,elem) 将elem的一份副本安插于pos处，并返回新元素位置
36.1.24 c.insert(pos,n,elem) 在pos位置插入n个elem副本，无返回值
36.1.25 c.insert(pos,beg,end) 插入区间元素，无返回值
36.1.26 c.push_back(elem) 尾部添加副本
36.1.27 c.pop_back() 移除最后一个元素
36.1.28 c.erase(pos) 移除pos位置的元素，返回下一个元素的位置
36.1.29 c.erase(beg,end) 移除区间内的所有元素，返回未被移除的第一个接续元素
36.1.30 c.resize(num) 将元素数量更改为num，如果数量变大，多出来的部分以default构造函数构造
36.1.31 c.resize(num,elem) 将元素数量更改为num，如果变大，以elem赋值
36.1.32 c.clear() 移除所有元素，令容器为空
36.1.33
c.capacity() 返回重新分配空间前所能容纳的元素最大数量--不支持。
36.1.34
c.reserve() 如果容量不足，扩大之。--不支持。
36.1.35 c.assign(n,elem) 复制N个ELEM，赋值给c
36.1.36 c.assign(beg,end) 将区间元素赋值
36.1.37 c.at(idx) 返回索引idx所标识的元素，若越界，抛出范围异常
36.1.38 c(idx) 返回索引idx所标识的元素，不进行范围检查
36.1.39 c.front() 返回第一个元素，不检查是否存在
36.1.40 c.back() 返回最后一个元素，不检查是否存在
36.1.41 c.flip() 将所有bool元素值取反
36.1.42 c[idx].flip() 将索引idx的bit元素取反
36.1.43 c[idx]=val 令索引idx的bit元素值为val
36.1.44 c[idx]=c[idx2] 令索引idx1的bit元素值为索引idx2的bit元素值
36.1.45
c.push_front() 在头部插入一个元素
36.1.46 c.pop_front() 移除头部元素
37.1list操作函数。头文件<list>。
37.1.1 contType c 产生一个未含任何元素的空容器
37.1.2 contType c1(c2) 产生一个同型容器
37.1.3 contType c(n) 利用default构造函数生成一个大小为n的容器
37.1.4 contType c(n,elem) 产生一个大小为n的容器，每个元素值都是elem
37.1.5 contType c(beg,end) 复制区间内的元素作为容器初值
37.1.6 c.~contType() 删除所有元素，释放内存
37.1.7 c.size() 返回容器中的元素数量
37.1.8 c.empty() 判断容器是否为空，相当于c.size()==0;
37.1.9 c.max_size() 返回元素的最大可能数量
37.1.10 c1==c2 判断相等
37.1.11 c1!=c2 判断不等
37.1.12 c1<c2 判断小于
37.1.13 c1>c2 判断大于
37.1.14 c1<=c2 判断小于等于
37.1.15 c1>=c2 判断大于等于
37.1.16 c1=c2 赋值
37.1.17 c1.swap(c2) 交换数据
37.1.18 swap(c1,c2) 交换数据
37.1.19 c.begin() 返回一个迭代器，指向第一个元素
37.1.20 c.end() 返回一个迭代器，指向最后元素的下一个位置
37.1.21 c.rbegin() 返回一个逆向迭代器，指向逆向遍历时的第一个元素
37.1.22 c.rend() 返回一个逆向迭代器，指向逆向遍历时的最后元素的下一个位置
37.1.23 c.insert(pos,elem) 将elem的一份副本安插于pos处，并返回新元素位置
37.1.24 c.insert(pos,n,elem) 在pos位置插入n个elem副本，无返回值
37.1.25 c.insert(pos,beg,end) 插入区间元素，无返回值
37.1.26 c.push_back(elem) 尾部添加副本
37.1.27 c.pop_back() 移除最后一个元素
37.1.28 c.erase(pos) 移除pos位置的元素，返回下一个元素的位置
37.1.29 c.erase(beg,end) 移除区间内的所有元素，返回未被移除的第一个接续元素
37.1.30 c.resize(num) 将元素数量更改为num，如果数量变大，多出来的部分以default构造函数构造
37.1.31 c.resize(num,elem) 将元素数量更改为num，如果变大，以elem赋值
37.1.32 c.clear() 移除所有元素，令容器为空
37.1.33
c.capacity() 返回重新分配空间前所能容纳的元素最大数量--不支持。
37.1.34
c.reserve() 如果容量不足，扩大之。--不支持。
37.1.35 c.assign(n,elem) 复制N个ELEM，赋值给c
37.1.36 c.assign(beg,end) 将区间元素赋值
37.1.37 c.at(idx) 返回索引idx所标识的元素，若越界，抛出范围异常
37.1.38 c(idx) 返回索引idx所标识的元素，不进行范围检查
37.1.39 c.front() 返回第一个元素，不检查是否存在
37.1.40 c.back() 返回最后一个元素，不检查是否存在
37.1.41 c.flip() 将所有bool元素值取反
37.1.42 c[idx].flip() 将索引idx的bit元素取反
37.1.43 c[idx]=val 令索引idx的bit元素值为val
37.1.44 c[idx]=c[idx2] 令索引idx1的bit元素值为索引idx2的bit元素值
37.1.45
c.push_front() 在头部插入一个元素
37.1.46 c.pop_front() 移除头部元素
37.1.47 c.remove(val) 移除所有其值为val的元素
37.1.48 c.remove_if(op) 移除所有造成OP（）结果为TRUE的元素
37.1.49 c.unique() 如果存在若干相邻而数值相等的元素，就移除重复元素，只保留一个
37.1.50 c.unique(op) 如果存在若干相邻元素，都使OP()的结果为真，则移除重复元素，只留一个
37.1.51 c1.splice(pos,c2) 将c2的所有元素都转移到c1，迭代器pos之前
37.1.52 c1.splice(pos,c2,c2pos) 将C2内的c2pos所指元素转移到c1内的pos所指位置之上
37.1.53 c1.splice(pos,c2,c2beg,c2end) 将c2的区间内的元素转移到c1的pos之前
37.1.54 c.sort() 以operator<为准则，对所有元素排序
37.1.55 c.sort(op) 以op为准则排序
37.1.56 c1.merge(c2) 假设c1,c2容器都包含已序元素，将c2的全部元素转移到c1 ，并保证合并后的list仍为已序
37.1.57 c1.merge(c2,op) 假设c1,c2容器都包含op准则的已序元素，将c2的全部元素转移到c1 ，并保证合并后的list仍为op准则已序
37.1.58 c.reverse() 将所有元素反序
38.1 set操作函数。头文件<set>。
38.1.1 contType c 产生一个未含任何元素的空容器
38.1.2 contType c1(c2) 产生一个同型容器
38.1.3 contType c(op) 生成一个按照OP排序的容器
38.1.4 contType c(beg,end,op)在区间内产生一个以OP为准则的容器
38.1.5 contType c(beg,end) 复制区间内的元素作为容器初值
38.1.6 c.~contType() 删除所有元素，释放内存
38.1.7 c.size() 返回容器中的元素数量
38.1.8 c.empty() 判断容器是否为空，相当于c.size()==0;
38.1.9 c.max_size() 返回元素的最大可能数量
38.1.10 c1==c2 判断相等
38.1.11 c1!=c2 判断不等
38.1.12 c1<c2 判断小于
38.1.13 c1>c2 判断大于
38.1.14 c1<=c2 判断小于等于
38.1.15 c1>=c2 判断大于等于
38.1.16 c1=c2 赋值
38.1.17 c1.swap(c2) 交换数据
38.1.18 swap(c1,c2) 交换数据
38.1.19 c.begin() 返回一个迭代器，指向第一个元素
38.1.20 c.end() 返回一个迭代器，指向最后元素的下一个位置
38.1.21 c.rbegin() 返回一个逆向迭代器，指向逆向遍历时的第一个元素
38.1.22 c.rend() 返回一个逆向迭代器，指向逆向遍历时的最后元素的下一个位置
38.1.23 c.insert(pos,elem) 将elem的一份副本安插于pos处，并返回新元素位置
38.1.24 c.insert(elem) 插入一个elem副本，返回新元素位置
38.1.25 c.insert(beg,end) 插入区间元素，无返回值
38.1.26 c.push_back(elem) 尾部添加副本
--不支持
38.1.27 c.pop_back() 移除最后一个元素
--不支持
38.1.28 c.erase(pos) 移除pos位置的元素，返回下一个元素的位置
38.1.29 c.erase(beg,end) 移除区间内的所有元素，返回未被移除的第一个接续元素
38.1.30 c.resize(num) 将元素数量更改为num，如果数量变大，多出来的部分以default构造函数构造
--不支持
38.1.31 c.resize(num,elem) 将元素数量更改为num，如果变大，以elem赋值
--不支持
38.1.32 c.clear() 移除所有元素，令容器为空
38.1.33
c.capacity() 返回重新分配空间前所能容纳的元素最大数量--不支持。
38.1.34
c.reserve() 如果容量不足，扩大之。--不支持。
38.1.35 c.assign(n,elem) 复制N个ELEM，赋值给c
--不支持
38.1.36 c.assign(beg,end) 将区间元素赋值
--不支持
38.1.37 c.at(idx) 返回索引idx所标识的元素，若越界，抛出范围异常
--不支持
38.1.38 c(idx) 返回索引idx所标识的元素，不进行范围检查
--不支持
38.1.39 c.front() 返回第一个元素，不检查是否存在
--不支持
38.1.40 c.back() 返回最后一个元素，不检查是否存在
--不支持
38.1.41 c.flip() 将所有bool元素值取反
--不支持
38.1.42 c[idx].flip() 将索引idx的bit元素取反
--不支持
38.1.43 c[idx]=val 令索引idx的bit元素值为val
--不支持
38.1.44 c[idx]=c[idx2] 令索引idx1的bit元素值为索引idx2的bit元素值
--不支持
38.1.45
c.push_front() 在头部插入一个元素--不支持
38.1.46 c.pop_front() 移除头部元素--不支持
38.1.47 c.remove(val) 移除所有其值为val的元素--不支持
38.1.48 c.remove_if(op) 移除所有造成OP（）结果为TRUE的元素 --不支持
38.1.49 c.unique() 如果存在若干相邻而数值相等的元素，就移除重复元素，只保留一个 --不支持
38.1.50 c.unique(op) 如果存在若干相邻元素，都使OP()的结果为真，则移除重复元素，只留一个 --不支持
38.1.51 c1.splice(pos,c2) 将c2的所有元素都转移到c1，迭代器pos之前 --不支持
38.1.52 c1.splice(pos,c2,c2pos) 将C2内的c2pos所指元素转移到c1内的pos所指位置之上 --不支持
38.1.53 c1.splice(pos,c2,c2beg,c2end) 将c2的区间内的元素转移到c1的pos之前 --不支持
38.1.54 c.sort() 以operator<为准则，对所有元素排序--不支持
38.1.55 c.sort(op) 以op为准则排序--不支持
38.1.56 c1.merge(c2) 假设c1,c2容器都包含已序元素，将c2的全部 元素转移到c1 ，并保证合并后的list仍为已序--不支持
38.1.57 c1.merge(c2,op) 假设c1,c2容器都包含op准则的已序元素，将c2的全部元素转移到c1 ，并保证合并后的list仍为op准则已序--不支持
38.1.58 c.reverse() 将所有元素反序--不支持
38.1.59 c.count(elem) 返回元素值为elem的元素个数
38.1.60 c.find(elem) 返回元素值为elem的第一个元素，如果找不到就返回end()
38.1.61 c.lower_bound(elem) 返回elem的第一个可安插位置，也就是元素值>=elem的第一元素位置
38.1.62 c.upper_bound(elem) 返回elem的最后一个可安插位置，也就是元素值>elem的第一元素位置
38.1.63 c.equal_range(elem) 返回elem的可安插的第一个位置与最后一个位置，也就是元素值=elem的元素区间
39.1 map操作函数。头文件<map>。maps和multimaps将key/value pair键值/实值 对组）当做元素进行管理。根据key的排序自动排序。multimaps允许重复元素，map则不能
39.1.1 contType c 产生一个未含任何元素的空容器
39.1.2 contType c1(c2) 产生一个同型容器
39.1.3 contType c(op) 生成一个按照OP排序的容器
39.1.4 contType c(beg,end,op)在区间内产生一个以OP为准则的容器
39.1.5 contType c(beg,end) 复制区间内的元素作为容器初值
39.1.6 c.~contType() 删除所有元素，释放内存
39.1.7 c.size() 返回容器中的元素数量
39.1.8 c.empty() 判断容器是否为空，相当于c.size()==0;
39.1.9 c.max_size() 返回元素的最大可能数量
39.1.10 c1==c2 判断相等
39.1.11 c1!=c2 判断不等
39.1.12 c1<c2 判断小于
39.1.13 c1>c2 判断大于
39.1.14 c1<=c2 判断小于等于
39.1.15 c1>=c2 判断大于等于
39.1.16 c1=c2 赋值
39.1.17 c1.swap(c2) 交换数据
39.1.18 swap(c1,c2) 交换数据
39.1.19 c.begin() 返回一个迭代器，指向第一个元素
39.1.20 c.end() 返回一个迭代器，指向最后元素的下一个位置
39.1.21 c.rbegin() 返回一个逆向迭代器，指向逆向遍历时的第一个元素
39.1.22 c.rend() 返回一个逆向迭代器，指向逆向遍历时的最后元素的下一个位置
39.1.23 c.insert(pos,elem) 将elem的一份副本安插于pos处，并返回新元素位置
39.1.24 c.insert(elem) 插入一个elem副本，返回新元素位置
39.1.25 c.insert(beg,end) 插入区间元素，无返回值
39.1.26 c.push_back(elem) 尾部添加副本
--不支持
39.1.27 c.pop_back() 移除最后一个元素
--不支持
39.1.28 c.erase(pos) 移除pos位置的元素，返回下一个元素的位置
39.1.29 c.erase(beg,end) 移除区间内的所有元素，返回未被移除的第一个接续元素
39.1.30 c.resize(num) 将元素数量更改为num，如果数量变大，多出来的部分以default构造函数构造
--不支持
39.1.31 c.resize(num,elem) 将元素数量更改为num，如果变大，以elem赋值
--不支持
39.1.32 c.clear() 移除所有元素，令容器为空
39.1.33
c.capacity() 返回重新分配空间前所能容纳的元素最大数量--不支持。
39.1.34
c.reserve() 如果容量不足，扩大之。--不支持。
39.1.35 c.assign(n,elem) 复制N个ELEM，赋值给c
--不支持
39.1.36 c.assign(beg,end) 将区间元素赋值
--不支持
39.1.37 c.at(idx) 返回索引idx所标识的元素，若越界，抛出范围异常
---不支持
39.1.38 c(idx) 返回一个reference,指向键值为key的元素，如果该元素尚未存在，就安插该元素。
39.1.39 c.front() 返回第一个元素，不检查是否存在
--不支持
39.1.40 c.back() 返回最后一个元素，不检查是否存在
--不支持
39.1.41 c.flip() 将所有bool元素值取反
--不支持
39.1.42 c[idx].flip() 将索引idx的bit元素取反
--不支持
39.1.43 c[idx]=val 令索引idx的bit元素值为val
--不支持
39.1.44 c[idx]=c[idx2] 令索引idx1的bit元素值为索引idx2的bit元素值
--不支持
39.1.45
c.push_front() 在头部插入一个元素--不支持
39.1.46 c.pop_front() 移除头部元素--不支持
39.1.47 c.remove(val) 移除所有其值为val的元素--不支持
39.1.48 c.remove_if(op) 移除所有造成OP（）结果为TRUE的元素 --不支持
39.1.49 c.unique() 如果存在若干相邻而数值相等的元素，就移除重复元素，只保留一个 --不支持
39.1.50 c.unique(op) 如果存在若干相邻元素，都使OP()的结果为真，则移除重复元素，只留一个 --不支持
39.1.51 c1.splice(pos,c2) 将c2的所有元素都转移到c1，迭代器pos之前 --不支持
39.1.52 c1.splice(pos,c2,c2pos) 将C2内的c2pos所指元素转移到c1内的pos所指位置之上 --不支持
39.1.53 c1.splice(pos,c2,c2beg,c2end) 将c2的区间内的元素转移到c1的pos之前 --不支持
39.1.54 c.sort() 以operator<为准则，对所有元素排序--不支持
39.1.55 c.sort(op) 以op为准则排序--不支持
39.1.56 c1.merge(c2) 假设c1,c2容器都包含已序元素，将c2的全部 元素转移到c1 ，并保证合并后的list仍为已序--不支持
39.1.57 c1.merge(c2,op) 假设c1,c2容器都包含op准则的已序元素，将c2的全部元素转移到c1 ，并保证合并后的list仍为op准则已序--不支持
39.1.58 c.reverse() 将所有元素反序--不支持
39.1.59 c.count(elem) 返回元素值为elem的元素个数
39.1.60 c.find(elem) 返回元素值为elem的第一个元素，如果找不到就返回end()
39.1.61 c.lower_bound(elem) 返回elem的第一个可安插位置，也就是元素值>=elem的第一元素位置
39.1.62 c.upper_bound(elem) 返回elem的最后一个可安插位置，也就是元素值>elem的第一元素位置
39.1.63 c.equal_range(elem) 返回elem的可安插的第一个位置与最后一个位置，也就是元素值=elem的元素区间
40. 迭代器是一种“能够遍历某个序列（sequence)内的所有元素“的对象。所有容器都定义其各自的迭代器型别（iterator types),所以当你打算使用某种容器的迭代器时，并不需要含入专门的头文件。但逆向（reverse)d迭代器除外，其被定义于头文件<iterator>中。
41.input迭代器只能一次一个向前读取元素，按此顺序一个个传回元素值。主要操作如下：
41.1.1 ×iter 读取实际元素
41.1.2 iter->member 读取实际元素的成员
41.1.3 ++iter 向前步进，传回新位置
41.1.4 iter++ 向前步进，传回旧位置
41.1.5 iter1==iter2 判断两个迭代器是否相等
41.1.6 iter1!=iter2 判断两个迭代器是否不相等
41.1.7 TYPE(iter) 复制迭代器，copy构造函数
42.output迭代器只能一个个写入元素值，且重复写入不一定成功，主要操作如下：
42.1.1 ×iter=value 将数值写到迭代器所指位置
42.1.2 ++iter 向前步进，传回新位置
42.1.3 iter++ 向前步进，传回旧位置
42.1.4 TYPE(iter) 复制迭代器，copy构造函数
43.Forward(前向）迭代器是input和output两个迭代器的组合，具有input迭代器的全部功能和output的大部分功能，且可以对同一个元素多次操作。主要操作如下：
43.1.1 ×iter 存取实际元素
43.1.2 iter->member 存取实际元素的成员
43.1.3 ++iter 向前步进，传回新位置
43.1.4 iter++ 向前步进，传回旧位置
43.1.5 iter1==iter2 判断两个迭代器是否相等
43.1.6 iter1!=iter2 判断两个迭代器是否不相等
43.1.7 TYPE(iter) 复制迭代器，copy构造函数
43.1.8 TYPE() 产生迭代器，default构造函数
43.1.9 iter1=iter2 赋值
44.Bidirectional(双向）迭代器是在forward的基础上增加了回头遍历的能力，即支持递减运算操作。主要操作如下：
44.1.1 ×iter 存取实际元素
44.1.2 iter->member 存取实际元素的成员
44.1.3 ++iter 向前步进，传回新位置
44.1.4 iter++ 向前步进，传回旧位置
44.1.5 iter1==iter2 判断两个迭代器是否相等
44.1.6 iter1!=iter2 判断两个迭代器是否不相等
44.1.7 TYPE(iter) 复制迭代器，copy构造函数
44.1.8 TYPE() 产生迭代器，default构造函数
44.1.9 iter1=iter2 赋值
44.1.10 --iter 向后步进，传回新位置
44.1.11 iter-- 向后步进，传回旧位置
45.Random Access(随机存取）迭代器是在bidirectional的基础上增加了随机存取的能力，主要操作如下：
45.1.1 ×iter 存取实际元素
45.1.2 iter->member 存取实际元素的成员
45.1.3 ++iter 向前步进，传回新位置
45.1.4 iter++ 向前步进，传回旧位置
45.1.5 iter1==iter2 判断两个迭代器是否相等
45.1.6 iter1!=iter2 判断两个迭代器是否不相等
45.1.7 TYPE(iter) 复制迭代器，copy构造函数
45.1.8 TYPE() 产生迭代器，default构造函数
45.1.9 iter1=iter2 赋值
45.1.10 --iter 向后步进，传回新位置
45.1.11 iter-- 向后步进，传回旧位置
45.1.12 iter[n] 存取索引位置为n的元素
45.1.13 iter+=n 向前跳n个元素，n可以为负数，则为后跳
45.1.14 iter-=n 向后跳n个元素
45.1.15 iter+n 传回iter之后的第n个元素
45.1.16 n+iter 传回iter之后的第n个元素
45.1.17 iter-n 传回iter之前的第n个元素
45.1.18 iter1-iter2 传回iter1和iter2之间的距离
45.1.19 iter1<iter2 判断iter1是否在iter2之前
45.1.20 iter1>iter2 判断iter1是否在iter2之后
45.1.21 iter1<=iter2 判断iter1是否不在iter2之后
45.1.22 iter1>=iter2 判断iter1是否不在iter2之前
46.迭代器的三个辅助函数advance(),distance(),iter_swap().
47. 迭代器配接器（Iterator Adapters)是一类特殊的迭代器，从而使算法能够以逆向模式（reverse mode),安插模式(insert mode)进行工作，也可以和流（streams)搭配工作。
47.1逆向迭代器（Reverse) 用于重新定义递增运输和递减运输，使其行为正好倒置。如rbegin(),rend(). 半开原则，即区间不包括起点，但包括终点。
deque<int>::reverse_iterator rpos1(pos1);
47.2安插型迭代器（insert)用来将“赋值新值）操作转换为”安插新值“操作，即安插代替了覆盖。分为back inserter,front inserter,general inserter 三种。其操作特点如下：
*iter,++iter,iter++ 都无实际操作，iter=value 安插value.
47.3Stream(流）迭代器可以把stream当成算法的原点和终点。即一个istream迭代器可用来从input stream中读取元素，而ostream用来对output stream写入。
47.3.1 ostream迭代器的各项操作
47.3.1.1ostream_iterator<T>(ostream) 为ostream产生一个ostream迭代器
47.3.1.2ostream_iterator<T>(ostream,delim) 为ostream产生一个ostream迭代器，各元素间以delim为分隔符，且delim的型别为const char*
47.3.1.3*iter 无实际操作，传回iter
47.3.1.4iter=value 将value写到ostream,像这样ostream<<value.其后再输出一个delim/分隔符
47.3.1.5++iter 无实际操作，传回iter
47.3.1.6iter++ 无实际操作，传回iter
47.3.2 istream迭代器的各项操作
47.3.2.1istream_iterator<T>(istream) 为istream产生一个迭代器
47.3.2.2istream_iterator<T>() 产生一个end-of-stream迭代器
47.3.2.3*iter 传回先前读取的值（如果构造函数并未立刻读取第一个元素值，则本式执行读取任务）
47.3.2.4iter->member 传回先前读取的元素的成员（如果有的话）
47.3.2.5++iter 读取下一个元素，并传回其位置
47.3.2.6iter++ 读取下一个元素，并传回迭代器指向前一个元素
47.3.2.7iter1==iter2 检查iter1和iter2是否相等
47.3.2.8iter1!=iter2 检查iter1和iter2是否不相等
48.所谓仿函数Functors，是一个定义了operator()的对象，其与一般函数不同之处为：其用的是一种更复杂的撰写手段，不是将语句放在函数体中，而是在仿函数类别的operator()体内撰写程序代码。较一般函数有三个优点：拥有状态，拥有型别，速度快。
49.判断式Predicates是返回布尔值（可转换为bool)的一个函数或仿函数。
50.仿函数的头文件为<functional>,预定义的仿函数如下：
50.1 negate<type>() -param
50.2 plus<type>() param1+param2
50.3 minus<type>() param1-param2
50.4 multiplies<type>() param1*param2
50.5 divides<type>() param1/param2
50.6 modulus<type>() param1%param2
50.7 equal_to<type>() param1==param2
50.8 not_equal_to<type>() param1!=param2
50.9 less<type>() param1<param2
50.10greater<type>() param1>param2
50.11less_equal<type>() param1<=param2
50.12greater_equal<type>() param1>=param2
50.13logical_not<type>() !param
50.14logical_and<type>() param1&¶m2
50.15logical_or<type>() param1||param2
51.函数配接器（Function Adapters)是指能够将仿函数和另一个仿函数（或某个值，或某个一般函数）结合起来的仿函数。其亦包含在头文件<functional>中。常用如下：
51.1 bind1st(op,value) op(value,param)
51.2 bind2nd(op,value) op(value,param)
51.3 not1(op) !op(param)
51.4not2(op) !op(param1,param2)
52.成员函数配接器（member functions),即针对群集内的每个元素调用其成员函数。常用如下：
52.1 mem_fun_ref(op) 调用op,那是某对象的一个const成员函数
52.2 mem_fun(op) 调用op,那是某对象指针的一个const成员函数
53.针对一般函数的函数配接器为：prt_fun(op) op(param)/op(param1,param2)
54.为了让自己定义的仿函数能够和函数配接器搭配使用，必须提供一些型别成员来反映其参数和返回值的型别。
55. 算法是被设计用来处理一个或多个迭代器区间的数据的工具，且一般采用覆盖模式包含着头文件<algorithm>或<numeric>中。常用的算法种类包括以下几种：
55.1 非变动性算法（nonmodifying algorithms）既不改变元素次序，也不改动元素值的算法，可作用于所有标准容器身上。常用操作如下：
55.1.1 for_each() 对每个元素执行某操作
55.1.2 count() 返回元素个数
55.1.3 count_if() 返回满足某一准则的元素个数
55.1.4 min_element() 返回最小值元素
55.1.5 max_element() 返回最大值元素
55.1.6 find() 搜索等于某值的第一个元素
55.1.7 find_if() 搜索满足某个准则的第一个元素
55.1.8 search_n() 搜索具有某特性的第一段n个连续元素
55.1.9 search() 搜索某个子区间第一次出现位置 string is find()
55.1.10 find_end() 搜索某个子区间最后一次出现位置 string is rfind()
55.1.11 find_first_of() 搜索等于某数个值之一的第一个元素
55.1.12 adjacent_find() 搜索连续连个相等的元素
55.1.13 equal() 判断两区间是否相等
55.1.14 mismatch() 返回两个序列的各组对应元素中，第一对不相等元素
55.1.15l lexicographical_compart() 判断某一序列中字典顺序下是否小于另一序列
55.2 变动性算法 （modifying algorithms）是指要不直接改变元素值，或者在复制到另一区间的过程中改变元素值。常用的操作如下：
55.2.1 for_each() 针对每个元素执行某项操作
55.2.2 copy() 从第一个元素开始，复制某段区间
55.2.3 copy_backward() 从最后一个元素开始，复制某段区间
55.2.4 transform() 变动（并复制）元素，将两个区间的元素合并
55.2.5 merge() 合并两个区间
55.2.6 awap_ranges() 交换两区间内的元素
55.2.7 fill() 以给定值替换每一个元素
55.2.8 fill_n() 以给定值替换n个元素
55.2.9 generate() 以某项操作的结果替换每一个元素
55.2.10 generate_n() 以某项操作的结果替换n个元素
55.2.11 replace() 将具有某特定值的元素替换为另一个值
55.2.12 replace_if() 将符合某准则的元素替换为另一个值
55.2.13 replace_copy() 复制整个区间，同时并将具有某特定值的元素替换为另一个值
55.2.14 replace_copy_if() 复制整个区间，同时并将符合某准则的元素替换为另一个值
55.3 移除性算法 （removing algorithms）可以移除某区间内的元素，也可以在复制过程中执行移除动作，但只是逻辑上的移除。常用操作如下：
55.3.1 remove() 将等于某特定值的元素全部移除
55.3.2 remove_if() 将满足某准则的元素全部移除
55.3.3 remove_copy() 将不等于某特定值的元素全部复制到它处
55.3.4 remove_copy_if() 将不满足某准则的元素全部复制到它处
55.3.5 unique(0 移除毗邻的重复元素
55.3.6 unique_copy() 移除毗邻的重复元素并复制到它处
55.4 变序性算法 （mutating algorithms）指通过元素值的赋值和交换，改变元素顺序（但不改变元素值).常用算法如下：
55.4.1 reverse() 将元素的次序逆转
55.4.2 reverse_copy() 复制的同时，逆转元素顺序
55.4.3 rotate() 旋转元素次序
55.4.4 rotate_copy() 复制的同时，旋转元素次序
55.4.5 next_permutation() 得到元素下一个排列次序
55.4.6 prev_permutation() 得到元素的上一个排列次序
55.4.7 random_shuffle() 将元素次序随机打乱
55.4.8 partition() 改变元素次序，使符合某准则者移到前面
55.4.9 stable_partition() 与partition()类似，但保持符合准则与不符合准则之各个元素之间的相对位置
55.5 排序算法 （sorting algorithms）是一种特殊的变序性算法，但比一般的变序性算法复杂，花费更多时间。常用操作如下：
55.5.1 sort() 对所有元素排序
55.5.2 stable_sort() 对所有元素排序，并保持相等元素间的相对次序
55.5.3 partial_sort() 排序，直到前n个元素就位
55.5.4 partial_sort_copy() 排序，直到前n个元素就位，结果复制于它处
55.5.5 nth_element() 根据第n个位置进行排序
55.5.6 partition() 改变元素次序，使符合某准则的元素放在前面
55.5.7 stable_partition() 与partition()相同，但保持符合准则和不符合准则的各个元素之间的相对位置
55.5.8 make_heap() 将一个区间转换成一个heap
55.5.9 push_heap() 将元素加入一个heap
55.5.10pop_heap() 从heap移除一个元素
55.5.11sort_heap() 对heap进行排序，（执行后就不在是个heap了）
55.6 已序区间算法（sorted range algorithms）是指所作用的区间在某种排序准则下已序。常用操作如下:
55.6.1 binary_search() 判断某区间内是否包含某个元素
55.6.2 includes() 判断某区间内的每一个元素是否都涵盖于另以区间中
55.6.3 lower_bound() 搜寻第一个大于等于给定值的元素
55.6.4 upper_bound() 搜寻第一个大于给定值的元素
55.6.5 equal_range(0 返回等于给定值的所有元素构成的区间
55.6.6 merge() 将两个区间的元素合并
55.6.7 set_union() 求两个区间的并集
55.6.8 set_intersection() 求两个区间的交集
55.6.9 set_difference() 求位于第一区间但不位于第二区间的所有元素，形成一个已序区间
55.6.10 set_symmetric_difference() 找出只出现于两区间之一的所有元素，形成一个已序区间
55.6.11 inplace_merge() 将两个连续的已序区间合并
55.7 数值算法 （numeric algorithms） 即以不同方式组合数值元素的算法。常用函数如下：
55.7.1 accumulate() 组合所有元素（求总和，求乘积）
55.7.2 inner_product() 组合两区间内的所有元素
55.7.3 adjacent_difference() 将每个元素和其前一元素组合
55.7.4 partial_sum() 将每个元素和其先前的所有元素组合
56.Heap算法，就排序而言，heap是一种特别的元素组织方式，应用于heap排序法。即heap可被视为一个以序列式群集实作而成的而叉树，具有以下两大性质：
第一，第一元素总是最大；第二，总是能够在对数时间内增加或移除一个元素。
57.Stacks(堆栈）可以做为STL的一个特殊容器，包含于头文件<stack>中。其操作如下：
57.1 push() 会将一个元素置入stack内
57.2 top() 会返回stack内的下一个元素
57.3 pop() 会从stack中移除元素
58.Queues(队列）可以做为STL的一个特殊容器，包含于头文件<queue>中。其操作如下：
58.1 push() 会将一个元素置入queue内
58.2 front() 会返回queue内的下一个元素
58.3 back() 会返回queue内的最后一个元素（也就是第一个被插入的元素）
58.4 pop() 会从queue中移除一个元素
59.优先队列（Priority Queues),与queue非常相近，但在top/pop操作“下一个元素”时操作的为优先级最高的元素,包含于头文件<queue>中。
59.1 push() 会将一个元素置入priority queue内
59.2 top() 会返回priority queue内的下一个元素
59.3 pop() 会从priority queue中移除一个元素
60.Bitsets制造出一个内含位（bits)或布尔（boolean)值且大小固定的array.当需要管理各式标志（flags)，并以标志的任意组合来表现变量时，就可运用之，头文件<bitset>.
60.1 size() 返回位的个数
60.2 count() 返回“位值为1”的位个数
60.3 any() 判断是否有任何位被设立数值为1
60.4 none() 判断是否没有任何一个位被设立，亦即所有的位皆为0
60.5 test(size_t idx) 判断idx位置上的位是否被设立为1
60.6 operator==(const bitset<bits>&bits) 判断*this 和bits的所有位是否都相等
60.7 operator!===(const bitset<bits>&bits) 判断*this 和bits之中是否有些位不相等
60.8 set() 将所有的位设为true
60.9 set(size_t idx) 将位置idx上的位设为true
60.10 set(size_t idx,int value) 根据value上的值设定idx位置的位值
60.11 reset() 将所有位设为false
60.12 reset(size_t idx) 将位置idx上的位设为false
60.13 flip() 反转所有位
60.14 flip(size_t idx) 反转idx位置上的位
60.15 operator^=(const bitset<bits>&bits) 对每个位逐一进行exclusive-or运算
60.16 operator!=(const bitset<bits>&bits) 位逐一进行or运算
60.17 operator&=(const bitset<bits>&bits) 位逐一进行and运算
60.18 operator<<=(size_t num) 将所有位向左移动num个位置
60.19 operator>>=(size_t num) 将所有位向右移动num个位置
60.20 operator[] (size_t idx) 返回idx位置上的位值
60.21 operator ~() 产生一个新的bitset并返回；以*this的位反转值作为初值
60.22 operator <<(size_t num) 产生一个新的bitset并返回；以*this的位向左移动num个位置作为初值
60.23 operator >>(size_t num) 产生一个新的bitset并返回；以*this的位向右移动num个位置作为初值
60.24 operator&(const bitset<bits>&bits1,const bitset<bits>&bits2) 对bits1和bits2两者进行各位逐一and运算并返回结果
60.25 operator | (const bitset<bits>&bits1,const bitset<bits>&bits2) 对bits1和bits2两者进行各位逐一or运算并返回结果
60.26 operator^(const bitset<bits>&bits1,const bitset<bits>&bits2) 对bits1和bits2两者进行各位逐一exclusive or运算并返回结果
60.27 to_ulong() 返回bitset所有位所代表的整数
60.28 to_string() 返回一个string,以字符串形式表现该bitset的二进制值
60.29 operator >> (istream&strm,bitset<bits>&bits) 将一个包含0和1的字符序列转换为对应位，读入bits
60.30 operator << (istream&strm,const bitset<bits>&bits) 将bits的二进制形式转换为字符串，成为一个包含0和1的序列
61.C++中string指的是某个字符串型别的对象。而一般的字符串（即char*或const char*），则可以用c-string指代，但并无固定规则。
62.头文件<string>定义了所有的字符串型别和函数。而模板basic_string<>包含string和wstring两个型别。
62.1字符串的各种操作函数如下：
62.1.1 构造函数（constructors） 产生或复制字符串
62.1.2 析构函数（destructors） 销毁字符串
62.1.3 =,assign() 赋以新值
62.1.4 swap() 交换两个字符串的内容
62.1.5 +=,append(),push_back() 添加字符
62.1.6 insert() 插入字符
62.1.7 erase() 删除字符
62.1.8 clear() 移除全部字符（使之为空）
62.1.9 resize() 改变字符数量（在尾端删除或添加字符）
62.1.10 replace() 替换字符
62.1.11 + 串联字符串
62.1.12 ==,!=,<,<=,>,>=,compare() 比较字符串内容
62.1.13 size(),length() 返回字符数量
62.1.14 max_size() 返回字符的最大可能个数
62.1.15 empty() 判断字符串是否为空
62.1.16 capacity() 返回重新分配之前的字符容量
62.1.17 reserve() 保留一定量内存以容纳一定数量的字符
62.1.18 [],at() 存取单一字符
62.1.19 >>,getline() 从stream中读取某值
62.1.20 << 将某值写入stream
62.1.21 copy() 将内容复制为一个c-string
62.1.22 c_str() 将内容以c-string形式返回
62.1.23 data() 将内容以字符数组（character array）形式返回
62.1.24 substr() 返回某个子字符串（substring)
62.1.25 搜寻函数（find functions) 搜寻某个子字符串或字符
62.1.26 begin(),end() 提供正常的（正向）迭代器支持
62.1.27 rbegin(),rend() 提供逆向迭代器支持
62.1.28 ge_allocator() 返回配置器（allocator)
62.2 字符串的参数规格
62.2.1 const string & str 整个str字符串
62.2.2 const string & str,size_type idx,size_type num 大部分情况下是指字符串str中的以idx 开始的num个字符
62.2.3 const char* cstr 整个c-string cstr
62.2.4 const char* chars,size_type len 字符数组chars中的len个字符
62.2.5 char c 字符c
62.2.6 size_type num,char c num个字符c
62.2.7 iterator beg,iterator end 区间[beg;end]内所有字符
62.3字符串的构造函数与析构函数
62.3.1 string s 生产一个空字符串s
62.3.2 string s(str) copy构造函数，生产字符串str的一个复制品
62.3.3 string s(str,stridx) 将字符串str内始于位置stridx的部分，当做字符串s的初值
62.3.4 string s(str,stridx,strlen) 将字符串str内始于位置stridx且长度顶多strlen的部分，当做字符串s的初值
62.3.5 string s(cstr) 以c-string cstr作为字符串s的初值
62.3.6 string s (chars,chars_len) 以c-string cstr的前chars_len个字符作为字符串s的初值
62.3.7 string s (num,c) 生成一个字符串，包含num个c字符
62.3.8 string s (beg,end) 以区间[beg;end]内的字符作为字符串s的初值
62.3.9 s,~string() 销毁所有字符，释放内存
62.4字符串搜寻函数
62.4.1 find() 搜寻第一个与value相等的字符
62.4.2 rfind() 搜寻最后一个与value相等的字符（逆向搜寻）
62.4.3 find_first_of() 搜寻第一个与value中的某值相等的字符
62.4.4 find_last_of() 搜寻最后一个与value中的某值相等的字符
62.4.5 find_first_not_of() 搜寻第一个与value中任何值都不相等的字符
62.4.6 find_last_not_of() 搜寻最后一个与value中任何值都不相等的字符
63.字符串中的元素读取时，下标『』并不检查是否有效，单at()会检查，若无效则抛出异常。
64.在字符串操作中，如果搜寻函数失败，就会返回string::npos，由于npos有固定的型别，故在比较时需要对目标子串进行型别定义，即定义为string::size_type.
65.字符串迭代器是随机存取迭代器，其常用的迭代器操作函数如下（注意end的半开特性）：
65.1 s.begin() 返回一个随机存取迭代器，指向第一个字符
65.2 s.end() 返回一个随机存取迭代器，指向最后一个字符的下一个位置
65.3 s.rbegin() 返回一个逆向迭代器，指向倒数第一个字符，亦即最后一个字符
65.4 s.rend() 返回一个逆向迭代器，指向倒数最后一个字符的下一个位置，亦即第一个字符的前一个位置
65.5 string s(beg,end) 以区间[beg;end]内的所有字符作为string s的初值
65.6 s.append(beg,end) 将区间[beg;end]内的所有字符添加于s尾部
65.7 s.assign(beg,end) 将区间[beg;end]内的所有字符赋值给s
65.8 s.insert(pos,c) 在迭代器pos所指之处插入字符c，并返回新字符的迭代器 位置
65.9 s.insert(pos,num,c) 在迭代器pos所指之处插入num字符c，并返回新字符的迭代器 位置
65.10 s.insert(pos,beg,end) 在迭代器pos所指之处插入区间[beg;end]内的所有字符
65.11 s.erase(pos) 删除迭代器pos所指字符，并返回下一个字符位置
65.12 s.erase(beg,end) 删除区间[beg;end]内的所有字符，并返回下一个字符的下一个位置
65.13 s.replace(beg,end,str) 以string str内的字符替代[beg;end]区间内的所有字符
65.14 s.replace(beg,end,cstr) 以c-string cstr内的字符替代[beg;end]区间内的所有字符
65.15 s.replace(beg,end,cstr,len) 以字符数组str的前len个字符替代 [beg;end]区间内的所有字符
65.16 s.replace(beg,end,num,c) 以num个字符c替代 [beg;end]区间内的所有字符
65.17 s.replace(beg,end,newbeg,newend) 以[newbeg;newend]区间内的所有字符替代 [beg;end]区间内的所有字符
66. C++中头文件<complex>中包含复数及其相关的操作。其构造函数及赋值操作如下：
66.1 complex c 产生一个复数，实部和虚部都为零
66.2 complex c(1.3) 产生一个复数，实部为1.3，虚部为0
66.3 complex c(1.3,4.2) 产生一个复数，实部为1.3，虚部为4.2
66.4 complex c1(c2) 产生一个复数，是c2的一个副本
66.5 polar(4,2) 产生一个极坐标表示法的临时复数，模为4.2，相位角为0.
66.6 polar(4.2,0.75) 产生一个极坐标表示法的临时复数，模为4.2，相位角为0.75
66.7 conj(c) 产生一个临时复数，是c的共轭复数.
66.8 c1=c2 将c2的值赋值给c1
66.9 c1+=c2 将c2的值加入c1
66.10 c1-=c2 将c1的值减去c2
66.11 c1*=c2 将c1的值乘以c2
66.12 c1/=c2 将c1的值除以c2
66.13 c.real() 返回实部值--成员函数
66.14 real(c) 返回实部值--全局函数
66.15 c.imag() 返回虚部值--成员函数
66.16 imag(c) 返回虚部值--全局函数
66.17 abs(c) 返回绝对值
66.18 norm(c) 返回绝对值平方
66.19 arg(c) 返回极坐标相位角
67.复数的超越函数
67.1 pow(c,3) 计算c的3次幂
67.2 pow(c,1.7) 计算c的1.7次幂
67.3 pow(c1,c2) 计算c1的 c2次幂
67.4 pow(1.7,c) 计算1.7的c次幂
67.5 exp(c) 计算以e为底，c为指数的幂次方
67.6 sqrt(c) 计算c的平方根
67.7 log(c) 计算c的自然对数
67.8 log10(c) 计算以10为底的c的对数
67.9 sin(c) 计算c的正弦值
67.10 cos(c) 计算c的余弦值
67.11 tan(c) 计算c的正切值
67.12 sinh(c) 计算c的双曲正弦值
67.13 cosh(c) 计算c的双曲余弦值
67.14 tanh(c) 计算c的双曲正切值
68.Valarrys是个一维数组，元素从零开始计数，它可以针对一个或多个数值数组的全体或部分进行数值处理。其包含于头文件<valarray>中。操作如下：
68.1 valarray::valarray() 缺省构造函数，产生一个空的valarray
68.2 valarray::valarray(size_t num) 产生一个包含num个元素的valarray 初值为0
68.3 valarray::valarray(const T&value,size_t num) 产生一个包含num个元素的valarray 初值为value
68.4 valarray::valarray(const T*array,size_t num) 产生一个包含num个元素的valarray 初值为array中的对应元素
68.5 valarray::valarray(const valarray&va) copy构造函数，产生valarray va的一个复制品
68.6 valarray::~valarray() 析构函数，销毁所有元素，释放内存
68.7 valarray::valarray()
68.8 valarray&valarray::operator=(const valarray&va) 赋值，将valarray va的元素赋值给*this
68.9 valarray&valarray::operator=(const T&value) 赋值，将value的值赋值给*this
68.10 size(),resize(),min(),max(),sum(),shift(),cshift(),apply(T op(T)),[](size_t idx), unary-op(), binary-op(),超越类函数
69. Valarrays的子集类别：Slices(切割),General slices(一般化切割),Masked subsets(屏蔽式子集),Indirect subsets(间接式子集).
70.头文件<cmath>,<cstdlib>包含了全局性数值函数：
70.1<cmath>的函数类别：
70.1.1 pow() 求幂函数
70.1.2 exp() 指数函数
70.1.3 sqrt() 平方根
70.1.4 log() 自然对数
70.1.5 log10() 以10为底的对数
70.1.6 sin() 正弦函数
70.1.7 cos() 余弦函数
70.1.8 tan() 正切函数
70.1.9 sinh() 双曲正弦函数
70.1.10 cosh() 双曲余弦函数
70.1.11 tanh() 双曲正切函数
70.1.12 asin() 反正弦函数
70.1.13 acos() 反余弦函数
70.1.14 atan() 反正切函数
70.1.15 atan2() 商的反正切函数
70.1.16 ceil() 大于某个浮点数的最小整数
70.1.17 floor() 小于某个浮点数的最大整数
70.1.18 fabs() 浮点数的绝对值
70.1.19 fmod() 浮点数相除的余数
70.1.20 frexp() 将一个浮点数转换成小数部分和整数部分
70.1.21 ldexp() 将某个浮点数乘以2的某个整数幂次方
70.1.22 modf() 将浮点数分离为一个带正负号的整数和一个分数
70.2 头文件<cstdlib>的函数类别：
70.2.1 abs() 求某个int的绝对值
70.2.2 labs() 求某个long的绝对值
70.2.3 div() 求int相除的商和余数
70.2.4 ldiv() 求long相除的商和余数
70.2.5 srand() 随机数产生器（种下新的随机数种子）
70.2.6 rand() 随机数产生器（取得一个随机数）
71.所谓stream就是一条数据流，是由某个类别定义出来的具有特定性质的对象。其全局对象包括cin,cout,cerr,clog，wcin,wcout,wcerr,wclog.
72.操控器是专门用来操控stream的对象，常常只会改变输入或格式输出的解释方式。主要类别如下：
72.1 endl 输出‘\n'并刷新output缓冲区
72.2 ends 输出‘\0'
72.3 flush 刷新output缓冲区
72.4 ws 读入并忽略空格
73.stream buffers提供读写时所使用的字符缓冲区，并形成对外部表述的一种抽象概念。
74.stream的常用头文件包括<iosfwd>,<streambuf>,<istream>,<ostream>,<iostream>.
75.streams定义了一些型别为iostate的常数，用以反映stream的状态，包括goodbit,eofbit,failbit,badbit.处理状态的成员函数如下：
75.1 good() 若stream正常无误，返回true(表示goodbit设立）
75.2 eof() 若遭遇end-of-file,返回true(表示eofbit设立）
75.3 fail() 若发生错误，返回true(表示failbit或badbit设立）
75.4 bad() 若发生毁灭性错误，返回true(表示badbit设立）
75.5 rdstate() 返回当前已设立的所有标志
75.6 clear() 清除所有标志
75.7 clear(state) 清除所有标志后，设立state标志
75.8 setstate(state) 加设state标志
75.9 void*() stream是否未出错（相当于！fail())
75.10 !() stream 是否已出错（相当于fail())
75.11 exceptions(flags) 设定会引发异常的标志
75.12 exceptions() 返回引发异常的标志
76.输入用的成员函数
76.1 get(s,num) 不包括new line 或 EOF，最多num-1个字符，需要添加结束符号，返回istream
76.2 get(s,num,t) 不包括t 或 EOF，最多num-1个字符，需要添加结束符号，返回istream
76.3 getline(s,num) 包括new line 或 EOF，最多num-1个字符，需要添加结束符号，返回istream
76.4 getline(s,num,t) 包括t 或 EOF，最多num-1个字符，需要添加结束符号，返回istream
76.5 read(s,num) EOF，最多num个字符，不需要添加结束符号，返回istream
76.6 readsome(s,num) EOF（end-of-file)，最多num个字符，不需要添加结束符号，返回count
77.输出用的成员函数
77.1 put()
77.2 write()
78.g格式标志（Form flags)可以定义诸如数字精度，充填字符，数字进制等格式。访问格式标志的成员函数包括：
78.1 setf(flags) 添设格式标志flags，返回所有标志的原本状态
78.2 setf(flags,mask) 添设格式标志flags(配合掩码mask)，返回所有标志的原本状态
78.3 unsetf(flags) 清除flags
78.4 flags() 返回所有已设立的格式标志
78.5 flags(flags) 将flags设为新的格式标志，返回所有标志的原本状态
78.6 copyfmt(stream) 从stream中复制所有格式定义
79.用于存取格式标志的两个操控器
79.1 setiosflags(flags) 将flags设为格式标志（调用相应stream的setf(flags))
79.2 resetiosflags(mask) 清除mask所标识的一组标志（调用相应stream的setf(0,mask))
79.3 boolalpha /noboolalpha
80.其他函数类操作
80.1 width() 返回当前的字段宽度
80.2 width(val) 设立val为当前字段宽度，并返回先前的字段宽度
80.3 fill() 返回当前的充填字符
80.4 fill(c) 定义c为当前充填字符，并返回先前的充填字符
80.5 掩码及标志adjustfield left/right/internal/None 靠左对齐
80.6 skipws 调用>>读取数值时，自动跳过起始空格
80.7 nounitbuf 每次输出后，清空output缓冲区
144
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
