第9章 sequential container
顺序容器: vector 快速随机访问 list快速插入删除 deque双端，随机访问
C<T> c;
C c(c2);
C c(b,e); //迭代器,数组,指针，不要求两个容器类型相同
C<T> c(n,t); //只适用与顺序容器
C<T> c(n); //只适用与顺序容器
char *words[]={"a","b","c"};
list<string>::size_type list_size=sizeof(words)/sizeof(char*);
list<string> slist(words, words+list_size);
容器元素类型必须满足：1) 支持赋值运算(引用不支持) 2)可复制
除IO标准库类型及auto_ptr类型外，其他所有标准库类型都是有效的容器类型。容器本身也满足。
vector<Foo> empty;//ok
vector<Foo> bad(10);// error， Foo无默认构造函数但有int参数的构造函数
vecotr<Foo> ok(10,1);//ok
容器的容器 vector<vector<string> > lines; // >>之间必须有空格
iter->mem等价于 (*iter).mem;
list容器不支持算术运算(iter+n,iter-n,iter+=n,iter-=n), 也不支持关系运算(<=,<,>=,>),
只提供前置后后置自增自减，以及相等不等运算。vector和deque都支持。
list<int> ilist(vec.begin(), vec.end());
ilist.begin()+ilist.size()/2; // error:no addition on list iterators
容器定义的类型别名:
size_type
difference_type//迭代器差值的有符号类型
iterator const_iterator
reverse_iterator const_reverse_iterator
value_type
reference //元素的左值类型，value_type&同义词
const_reference //const value_type&同义词
c.begin(); c.end();
c.rbegin(); //返回reverse_iterator,指向c的最后一个元素
c.rend();//返回reverse_iterator,指向第一个元素前面的位置
容器c为const则返回const_reverse_iterator
c.push_back(t);
c.push_front(t); //只适用于list和deque
c.insert(p,t);//迭代器p前面插入t,返回新元素的迭代器
c.insert(p,n,t);//返回void
c.insert(p,b,e);//返回void
容器的关系运算：容器类型和元素类型都完全相同。
容器大小操作：
c.size(); //返回c::size_type
c.max_size();
c.empty();
c.resize(n);//n<c.size()删除多余，n>c.size(),值初始化新元素
c.resize(n,t);//新元素值为t
c.front();c.back();//返回引用,若c为空则未定义
c[n];c.at(n);// vector,deque
c.erase(p);//返回迭代器，指向被删元素后面的元素,若p指向超出末端的下一位置，则未定义。
c.erase(b,e);//返回迭代器,若e指向超出末端的下一位置,则也返回超出末端的下一位置。
c.clear();//void
c.pop_back();//void,若c为空，则未定义
c.pop_front();//void,若c为空，则未定义，只适用于list或deque
c1=c2;//c1和c2类型要完全相同,类型不同则使用assign
c1.swap(c2);//c1和c2类型要完全相同,速度比赋值快,不会使迭代器失效
c.assign(b,e);//b和e必须不指向c中元素,执行后迭代器失效
c.assign(n,t);
v.capacity();//vector在必须分配新的存储空间前可以存储的元素总数。
v.reverse(n);//预留存储空间大小,改变capacity的值
容器的选择:
1.随机访问:vector,deque
2.在中间位置插入 list
3.只在头部或尾部插入，deque
4.只在读取输入时在容器中间插入元素，然后随机访问，则先list，后复制到vector
5.如果既要随机访问，又要在中间位置插入删除元素，则考虑两者的使用的频率
string支持大部分vector操作，除了栈操作：不能使用front,back,pop_back,pop_front
string s1;
string s2(5,’a’);
string s3(s2);
string s4(s3.begin(), s3.end());
string s5(cp);//cp指向以null结尾的C风格字符串
string s6(cp, n);
string s7(s2, pos2);//从pos2开始
string s8(s2, pos2, len2);//从pos2开始的len2个字符，无论len2值多少，最多只能复制s2.size()-pos2个字符
与容器共有的string操作:
s.insert(p, t);
s.insert(p, n, t);
s.insert(p, b, e);
s.assign(b, e);
s.assign(n, t);
s.erase(p);
s.erase(b, e);
string特有的版本:
s.insert(pos, n, c);
s.insert(pos, s2);
s.insert(pos, s2, pos2, len);
s.insert(pos, cp, len);
s.insert(pos, cp);
s.assign(s2);
s.assign(s2, pos2, len);
s.assign(cp, len);
s.assign(cp);
s.erase(pos, len);
string特有操作
s.substr(pos, n);
s.substr(pos);
s.substr();
s.append(args);//追加,返回引用
s.replace(pos, len, args);//删除，用args替换，返回引用
s.replace(b, e, args);
append和replace的参数args
s2
s2, pos2, len2
cp // cp指向以null结束的数组
cp, len2 // cp指向以null结束的数组
n, c
b2, e2
find操作都返回string::size_type,没找到则返回string::npos
s.find(args);
s.rfind(args);
s.find_first_of(args);
s.find_last_of(args);
s.find_first_not_of(args);
s.find_last_not_of(args);
find操作的参数args
c, pos //从下标pos开始查找字符c，pos默认值为0
s2, pos //从下标pos开始查找string对象上，pos默认值为0
cp, pos //cp指向null结尾的C风格字符串,pos默认值为0
cp, pos, n //pos和n无默认值,从pos开始查找cp指向的前n个字符
string::size_type pos=0;
while ((pos = name.find_first_of(numerics, pos)) != string::npos)
{
//…
++pos;}
s.compare(s2);
s.compare(pos1, n1, s2);
s.compare(pos1, n1 ,s2, pos2, n2);
s.compare(cp); //cp指向以null结尾的字符串
s.compare(pos1, n1, cp);
s.compare(pos1, n1, cp, n2);
顺序容器适配器:stack queue priority_queue有优先级管理的队列
适配器通用操作和类型：
size_type
value_type
container_type
A a;
A a(c);
关系操作符: == != < <= > >=
支持关系运算
覆盖基础容器类型：stack,queue都基于deque，priority_queue基于vector
创建适配器时，通过指定适配器的第二个类型实参覆盖基础容器类型
stack可任意，queue的基础容器要有push_front运算,因此不能建立在vector上
priority_queue需要随机访问，因此可建立在vector和deque上
stack适配器操作
s.empty();
s.size();
s.pop();
s.top();
s.push(item);
队列queue和优先级队列priority_queue支持的操作：
q.empty();
q.size();
q.pop();
q.front(); //只适用于queue
q.back(); //只适用于queue
q.top(); //返回最高优先级的元素值,只适用于priority_queue
q.push(item); //对于queue在队尾压入，对于priority_queue放在优先级比它低的元素前面
第10章 associative container 关联容器
map set
multimap//支持同一个键多次出现的map类型
multiset//支持同一个键多次出现的set类型
#inlcude<ultility> pair类型
pair<T1, T2> p1; //值初始化
pair<T1, T2> p1(v1,v2);
make_pair(v1,v2);
p1 < p2
p1 == p2
p.firist
p.second
关联容器支持的操作:
1.关联容器共享大部分顺序容器操作，但不支持front,back,push_front,pop_front,push_back,pop_back.
2. C<T> c;
C<T> c1(c2);
C<T> c(b,e);
3. 关系运算
4.begin,end,rbegin,rend;
5.容器类型别名: map的value_type是pair类型
6.swap和赋值操作，但不支持assign
7.clear和erase,但关联容器的erase返回void
8.size，max_size,empty,但不支持resize
map<k, v> m;
map<k, v> m(m2);
map<k, v> m(b, e); //元素的类型必须能转换为pair<const k, v>
键类型k必须定义<操作符，严格弱排序 strict weak ordering
map<k, v>::key_type //键类型
map<k, v>::mapped_type //关联的值类型
map<k, v>::value_type //pair<const k,v>类型，即first元素为const map<k,v>::key_type，second元素为map<k,v>::mapped_type.
//值可改，键不可改，对迭代器解引用获得指向value_type的引用
用下标访问不存在的元素将导致在map容器中添加新元素,它的键即为下标值,并对值类型值初始化。
m.insert(e); //若e.first不在m中则插入，反之m不变。返回pair类型对象,包含指向e.first元素的map迭代器,及bool对象表示是否插入了该元素.
m.insert(beg, end);//返回void
m.insert(iter, e); //以iter为起点搜索，查找是否有e.first对应的键元素，如果没有，则插入e。返回一个迭代器，指向具有e.first键的元素
使用insert可避免使用下标操作符带来的副作用:不必要的初始化。
word_count["Anna"]=1; //查找Anna,若没有则创建，值初始化，插入map对象中, 最后读取并将值赋为1
pair<map<string, int>::iterator, bool> ret = word_count.insert(map<string, int>::value_type("Anna",1);
word_cound.insert(make_pair("Anna",1);
查找或读取map中元素,下标会自动插入新元素,考虑使用
m.count(k); //返回k出现的次数,map中只能为0或1
m.find(k); //返回指向k的迭代器,若k不存在则返回超出末端的迭代器
if (word_count.count("foobar")) occurs = word_count["foobar"]; //对元素两次查找
map<string, int>::iterator it = word_count.find("foobar");
if (it != word_count.end()) occurs = it->second; //一次查找
m.erase(k); //返回size_type类型的值,表示删除的元素个数
m.erase(p);//p不能等于m.end(), 返回void
m.erase(b, e);//返回void
set容器支持的操作基本与map容器一致，构造函数，insert count find erase
除了不支持下标操作符,没有定义mapped_type类型，value_type不是pair类型而等价于key_type。
与map一样,带有一个键参数的insert返回pair类型，包含一个指向该键元素的迭代器和是否插入元素的bool。
set的键元素与map一样，不能修改。
mutimap multiset 头文件也是 map和set
带有一个键参数的erase删除拥有该键的所有元素并返回删除的个数。
查找元素:
1)typedef mutimap<string, string>::size_type sz_type;
sz_type entries = authors.count(k);
mutimap<string, string>::iterator iter = authors.find(k);
for (sz_type cnt = 0; cnt != entries; ++cnt, ++iter)
cout <<iter->second << endl;
2)map,set,mutimap,multiset都使用
m.lower_bound(k); //返回指向键不小于k的第一个元素的迭代器
m.upper_bound(k); //返回指向键大于k的第一个元素的迭代器
m.equal_range(k); //返回pair对象，包含两个迭代器，first等价于m.lower_bound(k), second等价于m.upper_bound(k).
typedef multimap<string, string>::iterator author_it;
author_it beg = authors.lower_bound(k), end=authors.upper_bound(k);
while (beg != end){cout<<beg->second<<endl; ++beg;}
pair<author_it, author_it> pos = authors.equal_range(k);
while(p->first != pos->second){cout<<pos.first->second<<endl; ++pos.first;}
第11章 泛型算法 generic algorithm
#include<algorithm>
#include<numeric>
accumulate(v.begin(), v.end(),a); //累加初值a与容器元素类型匹配
fill(v.begin(), v.end(), t); //将t的副本分别写入,要保证输入范围有效
fill_n(v.begin(), n, t); //写入n个t的副本,要保证输入范围有效，n个元素必须已经存在
back_inserter迭代器适配器,back_inserter(container);生成一个绑定在容器上的插入迭代器,
试图通过这个迭代器给元素赋值时,赋值运算将调用push_back来添加元素。
vector<int> ivec; //empty
fill_n (back_inserter(ivec),10,0); //ok
copy (ilst.begin(), ilst.end(), back_inserter(ivec)); //效率差,一般直接vector<int> ivec(ilst.begin(), ilst.end());
replace(ilst.begin(), ilst.end(), a, b);//将所有等于a的元素替换为b
如果不想改变原序列则用replace_copy
vector<int> ivec;
replace_copy(ilst.begin(), ilst.end(), back_inserter(ivec), a, b);
sort(words.begin(), words.end()); //使用<操作符比较,
vector<string>::iterator end_unique =
unique(words.begin(),words.end()); //"删除"相邻的重复元素，把重复的元素移动到序列末尾，返回的迭代器指向超出无重复的元素范围末端的下一位置
words.erase(end_unique,words.end());
stable_sort(words.begin(), words.end(), isShorter); //稳定排序,重复元素相对位置不变,第3个参数使用谓词predicate
// bool isShorter(const string &s1, const string &s2){return s1.size() < s2.size();}
//bool GT6(const string &s){return s.size()>=6;}
vector<string>::size_type wc= count_if (words.begin(), words.end(), GT6); //返回谓词函数返回条件成立的元素个数
插入迭代器
1)back_inserter : push_back实现插入的迭代器
2)front_inserter: push_front实现插入，vector不能用
3)inserter: insert实习插入，第二个实参指向插入起始位置的迭代器
list<int> ilst,ilst2,ilst3;
for (list<int>::size_type i=0; i!=4; ++i) ilst.push_back(i);
copy (ilst.begin(), ilst.end(), front_inserter(ilst2); // 0123
copy(ilst.begin(),ilst.end(), inserter(ilst3, ilst3.begin()); //3210
iostream 迭代器: 自增，解引用，赋值。 istream提供==，！=运算，ostream不提供比较运算
都是类模板，任何定义<<操作符的类型都可以定义istream_iterator,定义>>的类型都可以定义ostream_iterator
istream_iterator<T> in(strm); // 创建从输入流strm中读取T类型对象的istream_iterator对象
istream_iterator<T> in; //istream_iterator对象的超出末端迭代器
ostream_iterator<T> in(strm); //创建将T类型的对象写到输出流strm的ostream_iterator对象, ostream_iterator不提供超出末端迭代器
ostream_iterator<T> in(strm, delim);//创建将T类型的对象写到输出流strm的ostream_iterator对象,在写入过程中使用delim作为元素的分隔符,delim是以空字符结束的字符数组
istream_iterator<int> in_iter(cin);
istream_iterator<int> eof;
while(in_iter != eof) vec.push_back(*in_iter++); //vector<int> vec(in_iter, eof);读cin,直到文件结束或输入的不是int为止
ostream_iterator<string> out_iter(cout,"\n");
istream_iterator<string> in_iter(cin), eof;
while(in_iter !=eof) *out_iter++ = *in_iter++;
一旦给ostream_iterator对象赋值,写入就提交了,没法改变这个值
ostream_iterator没有->操作符
从标准输入读取一些数,将不重复的数写到标准输出
istream_iterator<int> cin_it(cin),eof;
vector<int> ivec(cin_it, eof);
sort(ivec.begin(), ivec.end());
ostream_iterator<int> out_it(cout," ");
unique_copy(ivec.begin(), ivec.end(), out_it);
反向迭代器：需要使用自减操作符，流迭代器没有。
sort(vec.rbegin(), vec.rend()); //实现降序
find(vec.rbegin(),vec.rend(),',');//反向开始搜索
const迭代器
使用时注意迭代器范围
find_first_of(it, roster1.end(), roster2.begin(), roster2.end());
//如果it为const_iterator, 而roster为非const容器end()返回非const迭代器,用来指定迭代器范围的两个迭代器类型不同，将无法编译
迭代器种类：低级别迭代器可使用任意更高级迭代器替代
1.输入迭代器 == != ++ * –> find accumulate istream_iterator
2.输出迭代器 ++ * 只能写一次 copy ostream_iterator
3.前向迭代器:读写指定同期,以一个方向遍历序列，支持输入输出迭代器的所有操作，还支持对同一元素的多次读写 replace
4.双向迭代器: -- reverse 标准库容器提供的迭代器至少达到双向迭代器的要求 list map set
5.随机访问迭代器:关系操作符< <= > >= iter+n, iter-n, iter1-iter2,iter[n] sort vector deque string 所以list不能用sort排序
算法的形参模式
alg (beg, end, other parms);
alg (beg, end, dest, other parms);
alg (beg, end, beg2, other parms); //假定以beg2开始的范围与beg end一样大
alg (beg, end, beg2, end2, other parms);
sort (beg, end); // <操作符
sort (beg, end, cmp);
find (beg, end, val); //==操作符 带谓词形参加_if,因形参个数相同导致二义性
find_if (beg, end, pred);
reverse(beg, end);
reverse_copy(beg, end, dest);
list特有操作：对list容器应优先使用特有的成员版本，而不是泛型算法
lst.merge(lst2);
lst.merge(lst2, comp); //两个版本都要先排序, 合并后lst2为空，返回void
lst.remove(val);
lst.remove_if(unaryPred);//调用lst.erase实现,返回void
lst.reverse();
lst.sort();
lst.sort(comp);
lst.splice(iter, lst2);
lst.splice(iter, lst2, iter2);
lst.splice(iter, beg, end);//将lst2的元素移到lst中迭代器iter指向元素的前面,在lst2中删除移出的元素
lst.unique();
lst.unique(binaryPred);//调用erase删除同一个值的连续副本,第一个用==判断，第二个用指定谓词函数判断
list特有版本与其泛型算法两个重要区别:
1.remove和unique真正删除了指定元素
2.merge和splice会破坏实参
使用merge的泛型算法时将合并的序列写入目标迭代器指向的对象，两个输入序列不变。