一、概述

        内容

                容器、算法、迭代器，共计13个头文件algorithm、deque、functional、iterator、vector、list、map、memory、numeric、queue、set、stack、utility

        优势                 

                                ①不需要额外安装

                                ②数据结构和算法分离（不需要考虑实现过程）

        特点

                高可重用性、高性能、高移植性、跨平台

        用法

                        容器-->用于容纳数据

                        迭代器-->可以当成指针使用（实际上是一个封装了指针的类）

                        算法-->略

二、容器

        1.string容器

                特性：     string封装了char*，是一个char*型容器

                                定义了很多方法：find、copy、delete、replace、insert

                                不需要考虑内存释放和越界

                                char*和string可以通过c_str()方法互转

const char* cstr = str.c_str();    //string转cahr*
 
string sstr(s);    //char*转string（其中s为char*变量）

                成员函数操作

//构造
    string s1;    //无参构造
    string s2(10,'a');
    string s3("abcdef");
    string s4(s3);    //拷贝构造
 
//赋值
    s1 = "abcde";
    s1 = s2;
    s1.assign("wdnmd");
 
//成员函数
    s1.at(i);    //访问指定位置字符
        //与s1[i]最大的不同是at函数一旦越界会抛出out_of_range异常
 
    
    s1+=s2;    //拼接
    s1.append(s2,pos,n);    //将s2从pos开始的n个字符连接到s1，pos和n即可缺省
 
    s1.find(s2, pos);    //从pos开始查找s2，pos可缺省
    s1.rfind(s2,pos);    //从pos开始倒序查找pos
 
    s1.replace(pos,n,s2)    //将s1从pos开始的n个字符替换成s
 
    s1.compare(s2);    //将s1和s2进行比较
 
    s1.substr(pos,n);    //从s1中pos开始的位置提取n个字符组成子串
 
    s1.insert(pos,s2);    //从pos开始插入s2
    s1.insert(pos,10,'c');    //从pos开始插入10个c
 
 
    s1.erase(pos,n);    //删除pos开始的n个字符

        2.vector容器

                单口容器。

                其提供了迭代器v.begin() / v.rend()--栈底和v.end() / v.rbegin()--栈顶。

                动态增长的原理：若出现内存不足，vetor会重新申请更大的内存，将原有的内容移入（包含拷贝到新空间和释放旧空间）新空间中。

//构造 & 赋值
    vector<int> v1;    //使用模板类构造（默认构造）
    vector<int> v2(arr, arr+sizeof(arr)/sizeof(int));    //将arr[]中的元素拷贝给自身
    vector<int> v3(v2.begin(),v2.end());    //将v2拷贝给v3
    vector<int> v4(v3);    //拷贝构造
    vector<int> v5(10,'1');    //构造10个1
 
    vector<int> v6 = v5;    //通过=赋值
    v6.assign(v1.begin().v1.end());    //通过assign成员赋值
 
//循环展示
    for(vector<int>::iterator it = v.begin(); it!=v.end(); it++)
        cout<<*it<<endl;
 
//成员操作
    
    v1.swap(v2);    //交换v1和v2
 
    v1.size();    //获取元素个数
    v1.capacity();    //获取容量
    v1.empty();    //判断是否为空  
    v1.resize(n);    //将v1的大小重新调整为4（多出的部分会被强制截断）
    v1.reserve(10);    //预留空间
 
    v1.at(n);    //访问第n个元素
    v1[n];    //访问第n个元素，区别同string
    v1.front();    //返回第一个元素
    v1.back();    //返回最后一个元素
 
    v1.insert(pos,count,elem);    //从pos位置开始插入n个elem
        //pos的类型为迭代器const_iterator
    v1.push_back(elem);    //尾部插入elem
    v1.pop_back();    //删除最后元素
 
    v1.erase(start,end);    //删除从start到end的元素,类型均为const_iterator
    v1.erase(pos);    //删除pos位置的元素，类型为const_iterator
    v1.clear();    //清空

                使用过swap()收缩空间

                        原因：vector会自动增长，但是删除元素/resize()时不会自动缩减

vector<int> (v).swap(v);

        3.deque容器

                双口容器，包含push_back()、pop_back()、push_front()、pop_front()四种基本操作（而vector仅push_back()和pop_back）提供了迭代器v.begin() / v.rend()和v.end() / v.rbegin()。

                特性：①双端插入和删除元素效率高

                           ②指定位置插入会导致元素移动、降低效率

                           ③可随机存取、效率高

//初始化
    deque<int> d1;    //默认构造
    deque<int> d2(10,5);    //构造后向内填充10个5
    deque<int> d3(d2.begin(),d2.end());    //将d2赋值给d3
    deque<int> d4(d3);    //拷贝构造
 
//赋值
    d4=d3;    //重载等号
    d4.assign(10,5);    //赋值10个5
    d4.assign(d3.begin(),d3.end());    //拷贝d3
 
//循环展示
    for(deque<int>::iterator it = d4.begin(); it!=d4.end(); it++)
        cout<< *it <<endl;    //*it可以代替d4.at(it);或d4[it];
 
//成员操作
    d1.swap(d2);    //交换
 
    d1.size();    //获取元素个数
    d1.empty();    //判断是否为空
    d1.resize(10);    //重定义大小（超出部分会被截断）
    d1.resize(100,elem);    //重定义大小（后面的用elem填充）
 
    d1.push_front(elem);    //头插elem
    d1.push_back(elem);    //尾插elem
    d1.pop_back();    //删除队尾元素
    d1.pop_front();    //删除队首元素
 
    d1.front();    //获取头元素
    d1.back();    //获取尾元素
 
 
    d1.insert(pos,n,elem);    //从pos开始，插入n个elem
    d1.insert(pos,beg,end);    //在pos区间插入begin和end之间的数据
 
    d1.erase(pos);    //单点删除
    d1.erase(begin,end);    //删除区间[begin,end]

                实践，使用sort进行排序

#include<algorithm>
 
sort(d1.begin(),d1.end());    //对d1进行排序

        4.stack容器

                栈容器，先进后出。

                特点：不能遍历（不提供迭代器），不支持随机存取，只能通过top从栈顶获取/删除元素

//初始化
    stack<int> s1;    //默认构造
    stack<int> s2(s1);    //赋值构造
 
//操作
    s1.push(elem);    //压栈
    s2.pop();    //删除栈顶
    s1.top();    //获取栈顶元素
 
    s1.empty();    //是否为空
    s1.size();    //返回栈大小

        5.queue容器

                队列容器，先进先出

                特点：不能遍历（不提供迭代器），不支持随机存取

//初始化
    queue<int> q1;    //默认构造
    queue<int> q2(q1);    //拷贝构造
 
//成员函数操作
    q1.push(elem);    //入队
    q1.pop();    //删除队首元素
    
    q1.size();    //获取元素个数
    q.front();    //获取队头

        6.list容器

                链表容器

                特点：     ①非连续，添加删除元素不需要移动其他元素，效率高

                                ②链表仅在需要的时候才分配内存

                                ③链表需要额外的空间保存结点关系（前驱、后继关系）

//初始化
    list<int> l1;    //默认构造
    list<int> l2(n,elem);    //构造n个elem给list
    list<int> l3(l2);    //拷贝构造
    list<int> l4(l1.begin(),l2.end());    //将区间内值复制给l4
 
//成员操作
    l1.push_back();    //尾插
    l1.pop_back();    //尾删
    l1.push_front(elem);    //头插
    l1.pop_front();    //头删除
    l1.insert(pos,elem);    //pos位置插入elem
    l1.insert(pos,n,elem);    /pos位置插入n个elem
    
    l1.clear();    //清空
    l1.erase(begin,end);    //删除区间[begin,end]
    l1.erase(pos);    //删除pos位置
    l1.remove(elem);    //删除所有elem成员
 
    l1.size();    //获取元素个数
    l1.empty();    //判断是否为空
    l1.resize(n);    //将长度重定义为n
 
 
    l1.swap(l2);    //交换
    l1.reverse();    //反转
    l1.sort();    //排序

        7.set/multiset容器

                特点：        所有元素会根据值自动进行排序，set基于红黑树，查找效率高

                                   set不允许重复元素,multiset允许重复元素

                                   不能利用迭代器更改set集合的值

//构造
    set<int> st1;    //默认构造
    multiset<int> st2;    //默认构造2
    set<int> st3(st2);    //拷贝构造
 
    st2=st1;    //赋值
 
    st1.insert(7);    //插值
    st1.swap(st2);    //交换
    st1.size();    //获取元素个数
    st1.empty();    //判断是否为空
 
    st1.clear();    //清空
    st1.erase(pos);    //定点删除
    st1.erase(begin,end);    //区间清除
 
    st1.find(key);    //查找
    st1.lower_bound(keyelem);    //返回第一个key>=keyelem的迭代器
    st1.upper_bound(keyelem);    //返回第一个key>keyelem的迭代器
    st1.equal(keyelem);    //返回相等的上下限迭代器
            //pair<set<int>::iterator,set<int>::iterator>    使用s.first;和s.second进行识别

                对组pair

                        一个对组中的数据类型可以不同，使用两个共有函数first和second进行访问

pair<string,int> p1(string("Alice"),18);    //创建对组
 
cout<<p1.first<<p1.second;    //输出
 
pair<string,int> p2 = p1;    //赋值

        8.map/multimap容器

                与set区别，map具有键值和实值，根据键值进行排序；以红黑数为底层实现机制。

                map不允许key值重复,multimap则允许

//构造
    map<int,string> m1;    //默认构造
    map<int,string> m2(m1);    //拷贝构造
    
    m1=m2;    //赋值
    m1.swap(m2);    //交换
 
    m1.size();
    m1.empty();    
 
    m1.insert(pair<int,string>(1,string("Alice")));    //插入
    m1.insert(make_pair(1,string("Alice")));
    m1.insert(map<int,string>::value_type(1,string("Alice")));
    m1[2] = "Tom";    //直插