深入解析C++ STL中的常用容器

1. 关联容器和顺序容器

　　c++中有两种类型的容器：顺序容器和关联容器，顺序容器主要有：vector、list、deque等。其中vector表示一段连续的内存地址，基于数组的实现；list表示非连续的内存，基于链表实现。deque与vector类似，但是对于首元素提供删除和插入的双向支持。关联容器主要有map和set，map是key-value形式的，set是单值。map和set只能存放唯一的key值，multimap和multiset可以存放多个相同的key值。

容器类自动申请和释放内存，我们无需new和delete操作。

2. 顺序容器的介绍

2.1 vector

        vector是动态数组，在堆中分配内存，元素连续存放，有保留内存，如果减少大小后，内存也不会释放；如果新值大于当前大小时才会重新分配内存。

特点：

• 拥有一段连续的内存空间，并且起始地址不变，因此能够非常好的支持随机存取，即[]操作符，但是由于它的内存空间是连续的，所以在头部和中间进行插入和删除操作会造成内存块的拷贝，另外，当该数组的内存空间不够时，需要重新申请一块足够大得内存并且进行内存的拷贝，这些都大大的影响了vector的效率。
• 对头部和中间进行添加删除元素操作需要移动内存，如果你得元素是结构或类，那么移动的同时还会进行构造和析构操作，所以性能不高。
• 对任何元素的访问时间复杂度都是O(1)，所以常用来保存需要经常进行随机访问的内容，并且不需要经常对中间元素进行添加或删除操作。
• 属性与string差不多，同样可以使用capacity看当前保留的内存，使用swap来减少它使用的内存，如push_back 1000个元素，capacity返回值为16384
• 对最后元素操作最快（在后面添加删除元素最快），此时一般不需要移动内存，只有保留内存不够时才需要。

总结：

• 需要经常随机访问，且不用经常对中间元素插入或删除时使用vector；
• 如果元素是结构或类，最好是将结构或类的指针放入vector中，这样不仅能够节省空间，而且可以避免移动时构造和析构操作；

需要包含头文件#include<vector>，主要的操作有：

    //1.定义和初始化
    vector<int> vec1;        //默认初始化，vec1为空
    vector<int> vec2(vec1);  //使用vec1初始化vec2
    vector<int> vec3(vec1.begin(),vec1.end());//使用vec1初始化vec2
    vector<int> vec4(10);    //10个值为0的元素
    vector<int> vec5(10,4);  //10个值为4的元素
  
    //2.常用操作方法
    vec1.push_back(100);            //尾部添加元素
    int size = vec1.size();         //元素个数
    bool isEmpty = vec1.empty();    //判断是否为空
    cout<<vec1[0]<<endl;            //取得第一个元素
    vec1.insert(vec1.end(),5,3);    //从vec1.back位置插入5个值为3的元素
    vec1.pop_back();                //删除末尾元素
    vec1.erase(vec1.begin(),vec1.begin()+2);//删除vec1[0]-vec1[2]之间的元素，不包括vec1[2]其他元素前移
    cout<<(vec1==vec2)?true:false;  //判断是否相等==、！=、>=、<=...
    vector<int>::iterator iter = vec1.begin();          //获取迭代器首地址
    vector<int>::const_iterator c_iter = vec1.begin();  //获取const类型迭代器
    vec1.clear();                   //清空元素
  
    //3.遍历
    //下标法
    int length = vec1.size();
    for(int i=0;i<length;i++)
    {
        cout<<vec1[i];
    }
    cout<<endl<<endl;

    //迭代器法
    vector<int>::iterator iter = vec1.begin();
    for(;iter != vec1.end();iter++)
    {
       cout<<*iter;
    }

2.2 list

        list是STL实现的双向链表，元素存放在堆中，每个元素都是放在一块内存中，他的内存空间可以是不连续的，通过指针来进行数据的访问，这个特点使得它的随机访问变得非常没有效率，因此它没有提供[]操作符的重载。但是由于链表的特点，它可以很有效率的支持任意地方的删除和插入操作。所以与向量vector想比，它允许快速的插入和删除，但是随机访问却是比较慢。

特点：

• 没有空间预留习惯，所以每分配一个元素都会从内存中分配，每删除一个元素都会释放它占用的内存。
• 在哪里添加/删除元素性能都很高，不需要移动内存，当然也不需要对每个元素都进行构造与析构了，所以常用来做随机插入和删除操作容器。

总结：

• 如果经常进行添加或删除操作，并且不经常随机访问的话，使用list；
• list<指针>完全是性能最低的做法，还不如直接使用list<对象>或使用vector<指针>好，因为指针没有构造与析构，也不占用很大内存；

需要添加头文件#include<list>，主要的操作有：

    //1.定义和初始化
    list<int> lst1;          //创建空list
    list<int> lst2(3);       //创建含有三个元素的list
    list<int> lst3(3,2);     //创建含有三个元素为2的list
    list<int> lst4(lst2);    //使用lst2初始化lst4
    list<int> lst5(lst2.begin(),lst2.end());  //同lst4
 
    //2.常用操作方法
    lst1.assign(lst2.begin(),lst2.end());  //分配值,3个值为0的元素
    lst1.push_back(10);                    //末尾添加值
    lst1.pop_back();                   //删除末尾值
    lst1.begin();                      //返回首值的迭代器
    lst1.end();                        //返回尾值的迭代器
    lst1.clear();                      //清空值
    bool isEmpty1 = lst1.empty();          //判断为空
    lst1.erase(lst1.begin(),lst1.end());   //删除元素
    lst1.front();                      //返回第一个元素的引用
    lst1.back();                       //返回最后一个元素的引用
    lst1.insert(lst1.begin(),3,2);     //从指定位置插入个3个值为2的元素
    lst1.rbegin();                     //返回第一个元素的前向指针
    lst1.remove(2);                    //相同的元素全部删除
    lst1.reverse();                    //反转
    lst1.size();                       //含有元素个数
    lst1.sort();                       //排序
    lst1.unique();                     //删除相邻重复元素
 
    //3.遍历
    //迭代器法
    for(list<int>::const_iterator iter = lst1.begin();iter != lst1.end();iter++)
    {
       cout<<*iter;
    }

2.3 deque
　　deque容器类与vector类似，支持随机访问和快速插入和删除；与vector不同，deque还支持两端操作：push_front（开头位置插入）、push_back（末尾位置插入）、pop_front（开头位置删除）、pop_back（末尾位置删除）。其余的类似vector操作方法的使用。

特点：

支持[]操作符，也就是支持随机存取，具有比较高的随机存取速度，由于deque需要处理内部跳转，因此速度上没有vector快；

deque和vector的比较：

\	deque	vector
组织方式	按页或块来分配存储器的，每页包含固定数目的元素；	分配一段连续的内存来存储内容；
效率	即使在容器的前端也可以提供常数时间的insert和erase操作，而且在体积增长方面也比vector更具有效率；	只是在序列的尾端插入元素时才有效率，但是随机访问速度要比deque快；

总结：

如果既需要随机存取，又需要两端数据插入和删除，则应该使用deque；

2.4 vetcor、list、deque总结

\	vector	list	deque
特点	快速的随机存取，快速的在最后插入删除元素；	可以快速的在任意位置添加删除元素，只能快速的访问最开始和最后面的元素；	在开始和最后添加删除元素一样快，并且提供了随机访问的方法；
适用	需要高效的随机存取，不在于插入删除的效率；	需要大量的插入和删除操作，不关心随机存取；	需要随机存取，也需要高效的在两端进行插入删除操作；

3. 关联容器的介绍

3.1 map的介绍

　　c++map容器提供一个键值对(key/value)容器，map与multimap差别仅仅在于multimap允许一个键对应多个值。需要包含头文件#include<map>。对于迭代器来说，可以修改实值，而不能修改key。map会根据key自动排序。常用操作如下：

    //1.定义和初始化
    map<int,string> map1;                  //空map
   
    //2.常用操作方法
    map1[3] = "demon";                    //添加元素
    map1.insert(map<int,string>::value_type(2,"mdspku"));//插入元素
    map1.insert(make_pair<int,string>(4,"V5"));
    string str = map1[3];                  //根据key取得value，key不能修改
    map<int,string>::iterator iter_map = map1.begin(); //取得迭代器首地址
    int key = iter_map->first;             //取得key
    string value = iter_map->second;       //取得value
    map1.erase(iter_map);                  //删除迭代器数据
    map1.erase(3);                         //根据key删除value
    map1.size();                           //元素个数
    map1.empty();                          //判断空
    map1.clear();                          //清空所有元素
 
    //3.遍历
    for(map<int,string>::iterator iter = map1.begin();iter!=map1.end();iter++)
    {
       int key = iter->first;
       string value = iter->second;
    }

3.2 set集合
        set的含义是集合，它是一个有序的容器，里面的元素都是排序好的支持插入、删除、查找等操作，就像一个集合一样，所有的操作都是严格在log(n)时间内完成，效率非常高。set和multiset的区别是：set插入的元素不能相同，但是multiset可以相同，set默认是自动排序的，使用方法类似list。

void main()
{
    set<int> set1;
    
    //插入元素
    for (int i = 0; i<5; i++) {
        int tmp = rand();
        set1.insert(tmp);
    }
    
    //重复插入元素，会插入失败
    set1.insert(100);
    set1.insert(100);
    
    for (set<int>::iterator it = set1.begin(); it != set1.end(); it++) {
        cout << *it <<" ";
    }
    
    //删除集合
    while(!set1.empty())
    {
        //获取头部
        set<int>::iterator it = set1.begin();
        
        //打印头部元素
        cout << *it << endl;
        
        //从头部删除元素
        set1.erase(set1.begin());
    }   
}

set<int>创建默认的从小到大的int类型的集合；

set<int,less<int>>创建一个从小到大的int类型的集合；

set<int,greater<int>>创建一个从大到小的int类型的集合；

上面的less、greater是仿函数，集合会根据这个仿函数的返回值是否为真类进行排序。

//仿函数的原型，下面是C++提供的默认的greater的仿函数(删除了宏定义后的)
struct greater
{
    bool operator()(const int &left, const int &right) const
    {
        //如果左值>右值，为真。从大到小的排列
        return left > right;
    }
};

3.3 set 和map的比较

\	set	map
共同点	都是无序的保存元素，通过提供的接口对里面的元素进行访问，底层都是采用红黑树实现。 优点：1）查找某一个数的时间复杂度为O(logN)；2）遍历时采用迭代器； 缺点：每次插入值的时候，都需要调整红黑树，效率有一定影响；
不同点	集合，用来判断某一个元素是不是在一个组里面，使用的比较少。	映射，相当于字典，把一个值映射成另一个值，可以创建字典。

4. 几种容器的比较

\	内部数据结构	特点
vector	数组	在末尾增加或者删除元素所需时间与元素数目无关，在中间或者开头增加或者删除元素所需时间是随元素数目呈线性变化
list	双向环状链表	不能随机访问一个元素，可双向遍历，在开头，末尾和中间的任何地方增加或者删除元素所需时间都是常量。
deque	数组	随机访问每个元素，所需要的时间为常量。在开头和末尾增加元素所需时间与元素数目无关，在中间增加或删除所需时间随元素数目呈线性变化；
set	红黑树	键和值相等，键唯一，元素默认按升序排列；
map	红黑树	键唯一，元素默认按键的升序排列；

5. 关于迭代器失效的问题、小心使用STL中的erase

 先看下面一段代码：

#include "stdafx.h"
#include<iostream>
#include<vector>

using namespace std;

int main()
{
    vector<int> vect;
    for(int i = 0; i < 10; i++ )
    {
        vect.push_back(i);
    }

    vector<int>::iterator iter = vect.begin();
    for(; iter != vect.end(); iter++ )
    {
        if( *iter % 2 == 0 )
        {
            vect.erase(iter);
        }
    }

    return 0;
}

        咋一看这一段代码好像没有什么问题，但是运行之后会导致程序crash。

        iter是指向vector这个容器中的某个元素，如果不是在for、while循环中，erase删除元素是没有问题的，但是如果在for、while循环中对容器迭代，删除其中符合条件的所有元素，就可能出现问题。vect.erase(iter)之后，iter及其后面的迭代器已经失效了，不应该再使用这些迭代器了，再执行it++,其行为是未定义的。其它容器也会遇到迭代器失效的问题。

　　对于vector被删除元素的迭代器以及指向后面元素的迭代器全部失效。对于deque在首部或尾部删除元素则只会使指向被删除元素的迭代器失效，任何其它位置的插入和删除操作将使指向该容器元素的所有迭代器失效。

　　对于list仅有指向被删除元素的迭代器失效。为什么不同容器迭代器失效情况有差别呢？这主要与各容器的数据结构有关。

　　那如何在迭代容器时删除其中的元素？各容器通用的做法如下，看下面的例子：

#include "stdafx.h"
#include<iostream>
#include<vector>
#include<map>
#include<deque>
#include<list>

using namespace std;

int main()
{
    vector<int> vect;
    for(int i = 0; i < 10; i++ )
    {
        vect.push_back(i);
    }
    vector<int>::iterator iter = vect.begin();
    for(; iter != vect.end(); )
    {
         if( *iter % 2 == 0 )
         {
             iter = vect.erase(iter); 
         }
         else
         {
             iter++;
         }
    }

    /**********下面是对deque的测试***********/
    deque<int> myDeque;
    for( int i = 0; i < 10; i++ )
    {
        myDeque.push_back(i);
    }
    deque<int>::iterator deiter = myDeque.begin();
    for(; deiter != myDeque.end();)
    {
        if( *deiter % 2 == 0 )
        {
            deiter = myDeque.erase(deiter);
        }
        else
        {
            deiter++;
        }
    }

    /**********下面对list的测试***********/
    list<int> myList;
    for( int i = 0; i < 10; i++ )
    {
        myList.push_back(i);
    }
    list<int>::iterator listiter = myList.begin();
    for(; listiter != myList.end();)
    {
        if( *listiter % 2 == 0 )
        {
            listiter = myList.erase(listiter); 
        }
        else
        {
            listiter++;
        }
    }

    /***********下面是对map的测试***********/
    map<int,int> myMap;
    myMap[0] = 1;
    myMap[1] = 2;
    myMap[2] = 3;
    myMap[3] = 4;
    map<int,int>::iterator it = myMap.begin();
    for(; it != myMap.end(); )
    {
        if( (it->second) % 2 == 0 )
        {
            myMap.erase(it++);
            //it = myMap.erase(it); //对于map这两种方法都可以 c++11 才开始支持返回当前的迭代器，之前的可能没有返回值，所以这种方法不管用
        }
        else
        {
            it++;
        }
    }

    /***********set 跟map一样***********/
    system("pause");
    return 0;
}

6. 其他

6.1 关于容器的sizeof、size()、capacity问题

sizeof是vector本身的大小（sizeof(vector<int>))；

vector::size()操作，才反映了具体数据长度，即元素个数；

Capacity是容器（vector）的容量，指在发生realloc前能允许的最大元素数，即预分配的内存空间；

6.2 STL中hashtable、hashset、hashmap、set、map、unordered_map、unordered_set的区别

1）hashtable、hashset、hashmap、unordered_map、unordered_set与set、map的根本区别在于底层的实现不同，前者底层都是由hashtable来提供的，后者都是由红黑树来提供；前者查询时间虽然是O(1)，但是并不是前者查询时间一定比后者短，因为实际情况中还要考虑到数据量，而且前者的hash函数的构造速度也没那么快，所以不能一概而论，应该具体情况具体分析。后者保证了一个稳定的动态操作时间，查询、插入、删除都是O(logN)，最坏和平均都是。

2）unordered_map、unordered_set在C++11的时候被引入标准库了，而hashset、hashmap没有，所以建议还是使用unordered_map比较好。

3）hashset与set相比较，它里面的元素不一定是经过排序的，而是按照所用的hash函数分派的，它能提供更快的搜索速度（当然跟hash函数有关）。（hashmap与map区别一样）

--------------------- 
参考：https://www.jianshu.com/p/497843e403b4