《C++ Primer》 Part II（Containers and Algorithms）

容器的构造函数：

C<T> c;　　　　　//默认构造函数，通用　　　
C<T> c(c2);　　　　  //创建容器 c2 的副本，通用
C<T> c(b, e);　　　　//根据迭代器 b, e 的范围(不包括e)生成容器，通用
C<T> c(n, t);　　　　//使用 n 个值为 t 的元素生成容器，只适用于顺序容器
C<T> c(n);　　　　　//创建 n 个初始化元素的容器，只适用于顺序容器。采用这种类型的初始化，元素类型必须是内置或复合类型，或者是提供了默认构造函数的类类型。如果元素类型没有默认构造函数，则必须显式指定其元素初始化式。

我们知道指针就是迭代器，因此允许通过使用内置数组中的一对指针初始化容器也就不奇怪了：

char *words[] = {"stately", "plump", "buck", "mulligan"};
size_t words_size = sizeof(words)/sizeof(char *);
list<string> words2(words, words + words_size);

第二个指针提供停止复制的条件，其所指向的位置上存放的元素并没有复制。

 

容器内元素的类型约束：

支持复制和赋值功能是容器元素类型的最低要求。此外，关联容器的键类型还需满足其他的约束；

引用不支持一般意义的赋值运算，IO 库类型不支持复制或赋值。因此，不能创建引用类型或IO类型对象的容器。

此外，auto_ptr 类型也不支持。

 

将一个容器复制给另一个容器时，类型必须匹配：容器类型和元素类型都必须相同。

list<int> lt(3,10);
list<int> lt2(lt);        //OK
//vector<int> vect(lt);   //Error!
vector<int> vect(lt.begin(),lt.end());  //OK
for(vector<int>::const_iterator it = vect.begin();it != vect.end();it++)
{
    cout<<*it<<endl;
}

 

只有vector 和 deque 类型迭代器支持的操作：

iter + n  , iter -n

iter1 - iter2

>, >=, <, <=

因为只有这种两种容器为其元素提供快速、随机的访问，它们确保可根据元素位置直接有效地访问指定的容器元素。

list<int> lt(3,10);
vector<int> vect(3,10);

//cout<<*(lt.begin()+1)<<endl;    //Error
cout<<*(vect.begin()+1)<<endl;

//cout<<lt.end()-lt.begin()<<endl;   //Error
cout<<vect.end()-vect.begin()<<endl;
/*    //Error
if(lt.end() >= lt.begin())
{
    cout<<"true"<<endl;
}
*/
if(vect.end() >= vect.begin())
{
    cout<<"true"<<endl;
}

list 容器的迭代器只提供前置和后置的自增、自减运算以及相等（不等）运算。

所有容器都支持的类型名称：

size_type   //无符号整型，足以存储此容器类型的最大可能容器长度
iterator      //此容器类型的迭代器类型
const_iterator    //元素的只读迭代器类型
reverse_iterator    //按逆序寻址元素的迭代器
const_reverse_iterator   //元素的只读（不能写）逆序迭代器
difference_type   //足够存储两个迭代器差值的有符号整型，可为负数
value_type     //元素类型
reference        //元素的左值类型，是 value_type& 的同义词
const_reference     //元素的常量左值类型，等效于 const value_type&

最后三种类型使程序员无须直接知道容器元素的真正类型，就能使用它。需要使用元素类型时，只要用 value_type 即可。如果要引用该类型，则通过 reference 和 const_reference 类型实现。在程序员编写自己的泛型程序（第十六章）时，这些元素相关类型的定义非常有用。

 

容器的 begin 和 end 操作：

c.begin()        //返回一个迭代器，它指向容器 c 的第一个元素
c.end()           //返回一个迭代器，它指向容器 c 的最后一个元素的下一位置
c.rbegin()       //返回一个逆序迭代器，它指向容器 c 的最后一个元素
c.rend()          //返回一个逆序迭代器，它指向容器 c 的第一个元素前面的位置

上述每个操作都有两个不同版本：取决于容器是否为 const。如果容器不是 const，则这些操作返回 iterator 或 reverse_iterator 类型。如果容器是 const，则其返回类型是 const_iterator 和 const_reverse_iterator 类型。

 

容器元素都是副本，添加元素的时候，是将元素值复制到容器里。就是说容器中存放的是原始元素的副本。被复制的原始值与新容器中的元素各不相关，此后，容器内元素值发生变化时，被复制的原值不会受到影响，反之亦然。

vector<string> vect;
string s = "hello";
vect.push_back(s);
vect[0] = "df";
cout<<vect[0]<<endl;    //"df"
cout<<s<<endl;             //"hello"

 

在顺序容器中添加元素的操作：

c.push_back(t)    //只适用于 list 和 deque 容器类型.
c.push_front(t)    //在容器 c 的前端添加值为 t 的元素。返回 void 类型。<只适用于 list 和 deque 容器类型>
c.insert(p,t)         //在迭代器 p 所指向的元素前面插入值为 t 的新元素。返回指向新添加元素的迭代器
c.insert(p,n,t)      //在迭代器 p 所指向的元素前面插入 n 个值为 t 的新元素。返回 void 类型
c.insert(p,b,e)     //在迭代器 p 所指向的元素前面插入 n 个值为 t 的新元素。返回 void 类型

insert(p,t) 函数返回指向新插入元素的迭代器，可使用该返回值在容器中的指定位置重复插入元素：

list<string> lst;
list<string>::iterator iter = lst.begin();
while (cin >> word)
    iter = lst.insert(iter, word);   // same as calling push_front

任何 insert 或 push 操作都可能导致迭代器失效。当编写循环将元素插入到 vector 或 deque 容器中时，程序必须确保迭代器在每次循环后都得到更新。

不要存储 end 操作返回的迭代器。添加或删除 deque 或 vector 容器内的元素都会导致存储的迭代器失效。

 

容器类型和元素类型相同的容器支持用关系操作符进行比较，规则如下：

如果两个容器具有相同的长度而且所有元素都相等，那么这两个容器就相等；否则，它们就不相等。

如果两个容器的长度不相同，但较短的容器中所有元素都等于较长容器中对应的元素，则称较短的容器小于另一个容器。

如果两个容器都不是对文的初始子序列，则它们的比较结果取决于所比较的第一个不相等的元素。

但如果元素类型没有定义关系运算，则此类容器也不能进行关系运算。

 

顺序容器的大小操作：

c.size()                //返回容器 c 中的元素个数。返回类型为 c::size_type
c.max_size()            //返回容器 c 可容纳的最多元素个数，返回类型为 c::size_type
c.empty()               // 返回标记容器大小是否为 0 的布尔值
c.resize(n)             //调整容器 c 的长度大小，使其能容纳 n 个元素，如果 n < c.size()，则删除多出来的元素；否则，添加采用值初始化的新元素
c.resize(n,t)           //调整容器 c 的长度大小，使其能容纳 n 个元素。所有新添加的元素值都为 t

resize 操作可能会使迭代器失效。在 vector 或 deque 容器上做 resize操作有可能会使其所有的迭代器都失效。

对于所有的容器类型，如果 resize 操作压缩了容器，则指向已删除的元素迭代器失效。

 

访问元素：

c.front()        //返回容器 c 的第一个元素的引用。如果 c 为空，则该操作未定义
c.back()        //返回容器 c 的最后一个元素的引用。如果 c 为空，则该操作未定义
c[n]              //返回下标为 n 的元素的引用。如果 n <0 或 n >= c.size()，则该操作未定义。<只适用于 vector 和 deque 容器>
c.at(n)         //同上  <只适用于 vector 和 deque 容器>

使用front() 或 back() 方法，请务必保证容器不为空。另外，可以使用begin() 和end()-1 方法解引用来得到同样的结果。

vector<int> vect;
for(int i= 0;i<5;i++)
    vect.push_back(i);
if(vect.size()>0)
{
    cout<<vect.front()<<endl;     //第一个元素
    cout<<*(vect.begin())<<endl;   //第一个元素
    cout<<vect.back()<<endl;    //最后一个元素
    cout<<*(vect.end()-1)<<endl;   //最后一个元素
}  

删除顺序容器内的元素：

c.pop_front()        //删除容器 c 的第一个元素。返回 void。如果 c 为空容器，则该函数未定义。  <只适用于 list 或 deque 容器>
c.pop_back()        //删除容器 c 的最后一个元素。返回 void。如果 c 为空容器，则该函数未定义
c.erase(p)        //删除迭代器 p 所指向的元素。返回一个迭代器，它指向被删除元素后面的元素。如果 p 指向容器内的最后一个元素，则返回的迭代器指向容器的超出末端的下一位置。如果 p 本身就是指向超出末端的下一位置的迭代器，则该函数未定义
c.erase(b,e)      //删除迭代器 b 和 e 所标记的范围内所有的元素。返回一个迭代器，它指向被删除元素段后面的元素。如果 e 本身就是指向超出末端的下一位置的迭代器，则返回的迭代器也指向容器的超出末端的下一位置
c.clear()             //删除容器 c 内的所有元素。返回 void

 pop_front 操作通常与 front 操作配套使用，实现以栈的方式处理容器：

while (!ilist.empty()) {
         process(ilist.front()); // do something with the current top of ilist
         ilist.pop_front();      // done; remove first element
     }

这个循环非常简单：使用 front 操作获取要处理的元素，然后调用 pop_front 函数从容器 list 中删除该元素。

顺序容器的赋值操作：

c1 = c2        //删除容器 c1 的所有元素，然后将 c2 的元素复制给 c1。c1 和 c2 的类型（包括容器类型和元素类型）必须相同

c1.swap(c2)     //交换两个容器，事实上两个容器内的元素并没有移动，只是容器名交换了。
c.assign(b,e)    //重新设置 c 的元素：将迭代器 b 和 e 标记的范围内所有的元素复制到 c 中。
//书上说：b 和 e 必须不是指向 c 中元素的迭代器。但测试是可以的！

c.assign(n,t)    //将容器 c 重新设置为存储 n 个值为 t 的元素

由于 assign 操作首先删除容器中原来存储的所有元素，因此，传递给 assign 函数的迭代器不能指向调用该函数的容器内的元素。

但是，代码中却是可以，WHY?

第三种方法比第一种方法通用性更广，如可通过 assign 操作实现将 vector 容器中一段 char* 类型的元素赋给 string 类型 list 容器。

swap操作可以节省删除元素的成本：该操作不会删除或插入任何元素，而且保证在常量时间内实现交换。由于容器内没有移动任何元素，因此迭代器不会失效。它们指向同一元素，就像没作 swap 运算之前一样。虽然，在 swap 运算后，这些元素已经被存储在不同的容器之中了。例如，在做 swap 运算之前，有一个迭代器 iter 指向 svec1[3] 字符串；实现 swap 运算后，该迭代器则指向 svec2[3] 字符串（这是同一个字符串，只是存储在不同的容器之中而已）。

 

vector 容器的自增长

vector 元素是连续存储的，我们可能会认为，在添加新元素时，vector 会重新分配存储空间，用来存放原来的元素和以及新增的元素，最后辙销旧的存储空间。但事实上，为了使 vector 容器实现快速的内存分配，其实际分配的容量要比当前所需的空间多一些。vector 容器预留了这些额外的存储区，用于存放新添加的元素。于是，不必为每个新元素重新分配容器。所分配的额外内存容量的确切数目因库的实现不同而不同。比起每添加一个新元素就必须重新分配一次容器，这个分配策略带来显著的效率。事实上，其性能非常好，因此在实际应用中，比起 list 和 deque 容器，vector 的增长效率通常会更高。

那么，vector 预留的空间是多大呢？可以通过其成员函数 capacity() 来查看。那么，如果不满意这个预留大小怎么办呢？可以通过其成员函数 reserve(int i) 来设置。

默认情况下，当 vector 增长达到预留空间大小后，分配新的存储空间时，会以加倍当前容量的分配策略实现重新分配。

 

标准库提供了三种顺序容器适配器：queue、priority_queue 和 stack

使用适配器时，必须包含相关的头文件：

#include <stack>    // stack adaptor
#include <queue>    // both queue and priority_queue adaptors

所有适配器都定义了两个构造函数：默认构造函数用于创建空对象，而带一个容器参数的构造函数将参数容器的副本作为其基础值。

stack<int> stk1();          

deque<int> deq(10,3);
stack<int> stk2(deq);    

默认的 stack 和 queue 都基于 deque 容器实现，而 priority_queue 则在 vector 容器上实现。那如果要用 stack 适配 vector 怎么办呢？可以在创建适配器时，通过将一个顺序容器指定为适配器的第二个类型实参，来覆盖其关联的基础容器类型：

vector<int> vect(10,3);
//stack<int> stk(vect);    //Error!
stack<int,vector<int> > stk(vect);

对于给定的适配器，其关联的容器还必须满足一定的约束条件。stack 适配器所关联的基础容器可以是任意一种顺序容器类型。因此，stack 栈可以建立在 vector、list 或者 deque 容器之上。而 queue 适配器要求其关联的基础容器必须提供 pop_front 运算，因此只能建立在 list、deque 容器上，而不能建立在 vector 容器上。priority_queue 适配器要求提供随机访问功能，因此可建立在 vector 或 deque 容器上，但不能建立在 list 容器上。

vector<int> vect(10,3);
queue<int,vector<int> > que(vect);     //这一步不报错
//que.pop();    //这一步就会报错了，没有pop_front()方法

 

栈容器适配器（stack）支持的操作：

s.empty()   //如果栈为空，则返回 true，否则返回 stack
s.size()      //返回栈中元素的个数
s.pop()       //删除栈顶元素的值，但不返回其值
s.push(item)        //在栈顶压入新元素
s.top()        //返回栈顶元素的值，但不删除该元素

 

22、队列（queue）和优先队列适配器（priority_queue）支持的操作：

q.empty()     //如果队列为空，则返回 true，否则返回 false
q.size()        //返回队列中元素的个数
q.pop()        //删除队首元素，但不返回其值
q.push(item)        //对于 queue，在队尾压入一个新元素，对于 priority_quue，在基于优先级的适当位置插入新元素
q.front()        //返回队首元素的值，但不删除该元素<该操作只适用于队列>
q.back()        //返回队尾元素的值，但不删除该元素<该操作只适用于队列>
q.top()        //返回具有最高优先级的元素值，但不删除该元素<该操作只适用于优先级队列>

 

23、使用 pair 类型需要引入头文件： #include <utility>

pair<int,string> p1;    //默认构造函数会对其成员采取值初始化，此处为： p1.first = 0;  p1.second = "";
p1.first = 3;    //分别赋值
p1.second = "hello";   //分别赋值
p1 = make_pair(4,"hi");   //一起赋值。make_pair(first,second) 可以返回一个与元素类型相应的 pair 对象

pair<int,string> p2(10,"world");

typedef pair<int,string> Pair;  //使用 typedef 简化写法
Pair p3(1,"a");
Pair p4(2,"b");

 

map 的 value_type 是存储元素键值的 pair 类型，且键为 const 。如上面的 m 的 value_type 就是 pair<const string, string> 类型。

map 的键类型为 key_type ，值类型为 mapped_type 。

如：cout<<typeid(map<string,string>::mapped_type).name()<<endl;

另外 map 的构造函数只有那三种容器通用的：map<k, v> m;  map<k, v> m(m2);    map<k, v> m(b, e);

 

使用下标给map某一项赋值时，如果不存在此键值，则添加；如果存在，则更新。

使用 insert 方法：

m.insert(e)        //e 是一个用在 m 上的 value_type 类型的值。如果键（e.first）不在 m 中，则插入一个值为 e.second 的新元素；如果该键在 m 中已存在，则保持 m 不变。该函数返回一个 pair 类型对象，包含指向键为 e.first 的元素的 map 迭代器，以及一个 bool 类型的对象，表示是否插入了该元素

m.insert(beg, end)       //beg 和 end 是标记元素范围的迭代器，其中的元素必须为 m.value_type 类型的键－值对。对于该范围内的所有元素，如果它的键在 m 中不存在，则将该键及其关联的值插入到 m。返回 void 类型

m.insert(iter, e)      //e 是一个用在 m 上的 value_type 类型的值。如果键（e.first）不在 m 中，则创建新元素，并以迭代器 iter 为起点搜索新元素存储的位置。返回一个迭代器，指向 m 中具有给定键的元素

下标赋值和insert方法赋值最大的差别就是，当键已存在时，前者会更新对应的值，后者会忽略，不做任何操作。另外，后者显得更紧凑。

m.insert(map<string, string>::value_type("aaa","AAA"));
m.insert(make_pair("aaa","AAA"));
//或者：
typedef map<string,string>::value_type valType;
m.insert(valType("aaa","AAA"));

insert 方法返回值：

//insert(e)：返回的是一个 pair 对象，其 first 为所插入键在map中最终键值对的迭代器，second 为插入是否成功。
pair<map<string,string>::iterator, bool> ret = m.insert(make_pair("aaa","AAA"));    
cout<<(ret.first)->first<<endl;  //必为 "aaa"
cout<<(ret.first)->second<<endl;   //如果map中原本没有"aaa"这个键，则这里为新插入的 "AAA"；如果map中原本有这个键，则这里为这个键对应的值。
cout<<ret.second<<endl;   //插入成功返回1，失败返回0。影响成功的因素：该键是否已存在。

//m.insert(beg, end)：返回 void。

//m.insert(iter, e)：貌似 iter 就是返回之前定义的 iter 所对应的键值的新的迭代器。即键值还那个，只是迭代器可能变化了，因为可能成功插入一个新的键值对。还是尽量不用它了~~

++ret.first->second; 这个优先级是怎样的呢？实际上就是 ++((ret.first)->second);    还是要把运算符优先级表好好研究一下啊~~

 

使用下标访问map中的数据很危险，因为如果该键不存在的话，会插入新的键值对。无论是赋值还是读取~~

map<string,string> m;
m.insert(make_pair("aaa","aaa"));
string str = m["bbb"];   //会插入 make_pair("bbb","")
cout<<m["ccc"];    //会插入 make_pair("ccc","")

count(key) 方法来检测某个键是否存在，find(key) 方法可以返回某个键的迭代器，如果不存在则返回 end 迭代器。

if(m.count("ddd"))
{
    cout<<m["ddd"]<<endl;
}
//如果只是为了读取某个键的值，上面不是一个好方法，因为它查找了两次，可以直接使用 find(key) 方法，找到之后用迭代器来操作即可
map<string,string>::iterator it = m.find("ddd");
if(it != m.end())
{
    cout<<it->second<<endl;
}

除非你真的非常确定你需要使用到下标操作的效果，否则请使用 find(key)方法。

 

删除 map 中的元素：

m.erase(k)   //删除某一个键值对应的元素，如果存在的话。返回size_type 类型的值，表示删除的元素个数。
m.erase(p)   //删除某个迭代器指向的元素，请确保该迭代器合法。返回 void
m.erase(b, e)  //同上，只是这里删除两个迭代器之间的元素。返回 void

 

set 的构造函数还是那通用的三种，不说了~~

set 跟 map 一样，其键是 const 的，不可改变。

set 也支持 cout(key) 和 find(key) 方法。

插入元素，可以使用 insert(key)  和  insert(b,e)  ，前者直接插入某 key ，后者插入迭代器对之间的 key。

set<string> iset;
iset.insert("key");
set<string>::iterator set_it = iset.find("key");
*set_it = "key1";               // error

 

multimap 和 multiset 所支持的操作分别与 map 和 set 的操作相同，只有一个例外：multimap 不支持下标运算。不能对 multimap 对象使用下标操作，因为在这类容器中，某个键可能对应多个值。而因此特性，一些方法上会有一些小区别：

insert 总是会成功的。

erase 会删除对应键的所有元素，并返回删除元素的个数。而带有一个或一对迭代器参数的版本只删除指定的元素，并返回 void 类型。

关联容器 map 和 set 的元素是按顺序存储的，而 multimap 和 multset 也一样。因此，在 multimap 和 multiset 容器中，如果某个键对应多个实例，则这些实例在容器中将相邻存放。

查找某个键对应的值时，count 函数求出某键出现的次数，而 find 操作则返回第一个查找到的键的实例。

multimap<string,string> mmap;
mmap.insert(make_pair("aaa","aaa"));
mmap.insert(make_pair("bbb","bbb"));
mmap.insert(make_pair("ccc","ccc"));
mmap.insert(make_pair("bbb","BBB"));
int count = mmap.count("bbb");
multimap<string,string>::const_iterator it = mmap.find("bbb");
for(int i = 0;i != count; it++,i++)
{
    cout<<it->first<<"\t"<<it->second<<endl;
}

此外，还有一个优雅简洁的方法：

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)

上述操作适用于所有的关联容器，也可用于普通的 map 和 set 容器，但更常用于 multimap 和 multiset。

在同一个键上调用 lower_bound 和 upper_bound，将产生一个迭代器范围，指示出该键所关联的所有元素。lower_bound 返回的迭代器指向该键关联的第一个实例，而 upper_bound 返回的迭代器则指向最后一个实例的下一位置。如果该键不在 multimap 中，这两个操作将返回同一个迭代器，指向依据元素的排列顺序该键应该插入的位置。

lower_bound 返回的迭代器不一定指向拥有特定键的元素。如果该键不在容器中，则 lower_bound 返回在保持容器元素顺序的前提下该键应被插入的第一个位置。

multimap<string,string>::const_iterator it1 = mmap.lower_bound("bbb"),it2 = mmap.upper_bound("bbb");
while(it1 != it2)
{
    cout<<it1->first<<"\t"<<it1->second<<endl;
    it1++;
}

 或使用 equal_range(k) 方法如下：

pair<multimap<string,string>::iterator,multimap<string,string>::iterator> p = mmap.equal_range("bbb");
    while(p.first != p.second)
    {
        cout<<p.first->first<<"\t"<<p.first->second<<endl;
        p.first++;
    }

 

find(b,e,v) 查找迭代器 b 到 e (不包括e)之间的等于 v 的值，如果找到则返回v对应的迭代器，找不到则返回e。该方法同样可用于数组：

int ia[6] = {1,2,3,4,5,6};
int i = 7;
int *result = find(ia,ia+sizeof(ia),i);
cout<<(result != ia+sizeof(ia) ? "yes":"no")<<endl;

 

使用泛型算法和泛化的算术算法，需要分别引入头文件：

#include <algorithm>
#include <numeric>

只读算法：

accumulate(b,e,v);  //依次累加 v 和 b到e之间值，并返回。可用于数值计算，也可用于拼接字符串
find_first_of(b1,e1,b2,e2); //在第一段范围内查找与第二段范围中任意元素匹配的元素，然后返回一个迭代器，指向第一个匹配的元素。如果找不到元素，则返回第一个范围的 end 迭代器。
fill(b,e,v);  //fill 带有一对迭代器形参，用于指定要写入的范围，而所写的值是它的第三个形参的副本。执行时，将该范围内的每个元素都设为给定的值。如果输入范围有效，则可安全写入。这个算法只会对输入范围内已存在的元素进行写入操作。
fill_n(b,n,v);  //参数包括：一个迭代器、一个计数器以及一个值。该函数从迭代器指向的元素开始，将指定数量的元素设置为给定的值。

back_inserter 函数是迭代器适配器。迭代器适配器使用一个对象作为实参，生成一个绑定在该容器上的插入迭代器。在试图通过这个迭代器给元素赋值时，赋值运算将调用 push_back 在容器中添加一个具有指定值的元素。

//Error!
vector<int> vect;
fill_n(vect.begin(),10,0);

//OK
vector<int> vect;
fill_n(back_inserter(vect),10,0);

copy(b,e,it);  在it前一个位置开始复制 b与e之间的数据，但如果it是插入迭代器，则如下：

vector<int> vect;
list<int> lt(5);
vect.push_back(1);
vect.push_back(2);
vect.push_back(3);
copy(vect.begin(),vect.end(),lt.begin());
//copy(vect.begin(),vect.end(),back_inserter(lt));  //如果这里是这样写的话，那最后输出应该是：0,0,0,0,0,1,2,3
list<int>::iterator it = lt.begin();
while(it != lt.end())
{
    cout<<*it<<endl;  //1,2,3,0,0
        it++;
}

replace(b,e,oldvalue,newvalue);  //将序列中特定的值替换为新的值。

replace_copy (b,e,back_inserter(ivec), oldvalue, newvalue);   //这个算法接受第三个迭代器实参，指定保存调整后序列的目标位置。这样原容器则没有改变。

unique(b,e);  //去除重复元素。unique 返回的迭代器指向超出无重复的元素范围末端的下一位置。其实该函数并没有“删除”元素，而是将无重复的元素复制到序列的前端，从而覆盖相邻的重复元素。

lt.sort();   //list容器直接调用sort()方法

stable_sort(b,e,fun);  //第三个形参：比较元素所使用的谓词函数的名字。这个谓词函数必须接受两个实参，实参的类型必须与元素类型相同，并返回一个可用作条件检测的值。

bool fun(string str1,string str2)
{
    return str1.size() > str2.size();  //如果这里是 < 号，则排序相反
}

int main()
{
    vector<string> vect;
    vect.push_back("aa");
    vect.push_back("a");
    vect.push_back("aaa");
    stable_sort(vect.begin(),vect.end(),fun);  //"aaa","aa","a"
}

count_if(b,e,fun);  //count_if 算法返回使谓词函数返回条件成立的元素个数。

int fun(string str)
{
    return str.size() < 3;
}

int main()
{
    vector<string> vect;
    vect.push_back("aa");
    vect.push_back("a");
    vect.push_back("aaa");
    cout<<count_if(vect.begin(),vect.end(),fun);   //2
}

 

另外三种迭代器：都在 iterator 头文件中定义。

插入迭代器：这类迭代器与容器绑定在一起，实现在容器中插入元素的功能。

iostream 迭代器：这类迭代器可与输入或输出流绑定在一起，用于迭代遍历所关联的 IO 流。

反向迭代器：这类迭代器实现向后遍历，而不是向前遍历。所有容器类型都定义了自己的 reverse_iterator 类型，由 rbegin 和 rend 成员函数返回。

 

back_inserter 函数是一种插入器。插入器是一种迭代器适配器，带有一个容器参数，并生成一个迭代器，用于在指定容器中插入元素。三种插入器如下：

back_inserter，创建使用 push_back 实现插入的迭代器。

front_inserter，使用 push_front 实现插入。不适用于vector

inserter，使用 insert 实现插入操作。除了所关联的容器外，inserter 还带有第二个参数是迭代器，表示从该迭代器前插入。

 

三目运算符的第二个和第三个运算表达式必须为同一类型：

#include <list>
#include <iostream>
#include <algorithm>

int main()
{
    std::list<int> lt = {1,2,3,4};
    auto it = std::find_if(lt.begin(),lt.end(),[&](int ele){
        return ele == 3;
    });

    it != lt.end() ? lt.erase(it) : it;  //奇怪的 it，只为保持跟前面是同一类型

    std::for_each(lt.begin(),lt.end(),[&](int ele){
        std::cout<<ele<<std::endl;
    });
}

 

 34、11.3节~11.5节待续。