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：顺序容器的介绍

1):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个值为0的元素
     vector<int> vec5(,);  //10个值为4的元素

     //2.常用操作方法
     vec1.push_back();            //尾部添加元素
     int size = vec1.size();         //元素个数
     bool isEmpty = vec1.empty();    //判断是否为空
     cout<<vec1[]<<endl;        //取得第一个元素
     vec1.insert(vec1.end(),,);    //从vec1.back位置插入5个值为3的元素
     vec1.pop_back();              //删除末尾元素
     vec1.erase(vec1.begin(),vec1.begin()+);//删除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=;i<length;i++)
     {
        cout<<vec1[i];
     }
     cout<<endl<<endl;
     //迭代器法
    vector<int>::iterator iter = vec1.begin();
     for(;iter != vec1.end();iter++)
     {
        cout<<*iter;
     }

2)list,list是stl实现的双向链表，与向量vector想比，它允许快速的插入和删除，但是随机访问却是比较慢，需要添加头文件#include<list>

主要的操作

  //1.定义和初始化
    list<int> lst1;          //创建空list
    list<int> lst2();       //创建含有三个元素的list
    list<int> lst3(,); //创建含有三个元素为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();                    //末尾添加值
    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的元素
    lst1.rbegin();                         //返回第一个元素的前向指针
    lst1.remove();                        //相同的元素全部删除
    lst1.reverse();                        //反转
    lst1.size();                       //含有元素个数
    lst1.sort();                       //排序
    lst1.unique();                         //删除相邻重复元素

    //3.遍历
    //迭代器法
    for(list<int>::const_iterator iter = lst1.begin();iter != lst1.end();iter++)
    {
       cout<<*iter;
    }

3):deque
　　deque容器类与vector类似，支持随机访问和快速插入和删除，与vector不同，deque还支持从开始端插入数据：push_front。其余的类似vector操作方法的使用.

3:关联容器的介绍

1）map的介绍

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

常用操作如下：

  //1.定义和初始化
    map<int,string> map1;                  //空map

    //2.常用操作方法
    map1[] = "Saniya";                    //添加元素
    map1.insert(map<int,string>::value_type(,"Diyabi"));//插入元素
    //map1.insert(pair<int,string>(1,"Siqinsini"));
    map1.insert(make_pair<int,string>(,"V5"));
    string str = map1[];                  //根据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();                         //根据key删除value
    map1.size();                       //元素个数
    map1.empty();                       //判断空
    map1.clear();                      //清空所有元素

    //3.遍历
    for(map<int,string>::iterator iter = map1.begin();iter!=map1.end();iter++)
    {
       int keyk = iter->first;
       string valuev = iter->second;
    }

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

4：几种容器的比较

1)vector

内部数据结构：数组。

在末尾增加或者删除元素所需时间与元素数目无关，在中间或者开头增加或者删除元素所需时间是随元素数目呈线性变化。

2):deque

内部数据结构是：数组

随机访问每个元素，所需要的时间为常量。在开头和末尾增加元素所需时间与元素数目无关，在中间增加或删除所需时间随元素数目呈线性变化。

3)list

内部数据结构：双向环状链表

不能随机访问一个元素，可双向遍历，在开头，末尾和中间的任何地方增加或者删除元素所需时间都是常量。

4)set

键和值相等。

键唯一

元素默认按升序排列、

5)map

键唯一，

元素默认按键的升序排列

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

先看下面一段代码：

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

 using namespace std;

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

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

     return ;
 }

咋一看这一段代码好像没有什么问题
但是运行之后的结果为:

程序直接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 = ; i < ; i++ )
     {
         vect.push_back(i);
     }
     vector<int>::iterator iter = vect.begin();
     for(; iter != vect.end(); )
     {
          if( *iter %  ==  )
          {
             //vect.erase(iter++); //测试 使用vect.erase(iter++) 行不通，我看网上有些人写到这种方式也可行？表示奇怪。
              iter = vect.erase(iter);
          }
          else
          {
              iter++;
          }
     }

    //////////////////////////////下面是对deque的测试////////////////////////////
     deque<int> myDeque;
     for( int i = ; i < ; i++ )
     {
         myDeque.push_back(i);
     }
     deque<int>::iterator deiter = myDeque.begin();
     for(; deiter != myDeque.end();)
     {
         if( *deiter %  ==  )
         {
             //myDeque.erase(deiter++); //同样这里vect.erase(iter++) 行不通
             deiter = myDeque.erase(deiter);
         }
         else
         {
             deiter++;
         }
     }

     //////////////////////////////下面对list的测试//////////////////////
     list<int> myList;
     for( int i = ; i < ; i++ )
     {
         myList.push_back(i);
     }
     list<int>::iterator listiter = myList.begin();
     for(; listiter != myList.end();)
     {
         if( *listiter %  ==  )
         {
             //myList.erase(listiter++);
             listiter = myList.erase(listiter); //对于list这两种方式都可以的.因为对于list来说仅有指向被删除元素的迭代器失效，并不会导致所有的迭代器失效.
         }
         else
         {
             listiter++;
         }
     }
     //////////////////////下面是对map的测试/////////////////////////////
     map<int,int> myMap;
     myMap[] = ;
     myMap[] = ;
     myMap[] = ;
     myMap[] = ;
     map<int,int>::iterator it = myMap.begin();
     for(; it != myMap.end(); )
     {
         if( (it->second) %  ==  )
         {
             myMap.erase(it++);
             //it = myMap.erase(it); //对于map这两种方法都可以 c++11 才开始支持返回当前的迭代器，之前的可能没有返回值，所以这种方法不管用
         }
         else
         {
             it++;
         }
     }
     //////////////set 跟map一样///////////////
     system("pause");
     return ;
 }