C++ STL中容器的使用全面总结

转载自：https://blog.csdn.net/u014465639/article/details/70241850

一、容器的定义

       在数据存储上，有一种对象类型，它可以持有其它对象或指向其它对像的指针，这种对象类型就叫做容器。很简单，容器就是保存其它对象的对象，当然这是一个朴素的理解，这种“对象”还包含了一系列处理“其它对象”的方法。

二、容器的种类

  1、顺序容器：是一种各元素之间有顺序关系的线性表，是一种线性结构的可序群集。顺序性容器中的每个元素均有固定的位置，除非用删除或插入的操作改变这个位置。顺序容器的元素排列次序与元素值无关，而是由元素添加到容器里的次序决定。顺序容器包括：vector(向量)、list（列表）、deque（队列）。
  2、关联容器：关联式容器是非线性的树结构，更准确的说是二叉树结构。各元素之间没有严格的物理上的顺序关系，也就是说元素在容器中并没有保存元素置入容器时的逻辑顺序。但是关联式容器提供了另一种根据元素特点排序的功能，这样迭代器就能根据元素的特点“顺序地”获取元素。元素是有序的集合，默认在插入的时候按升序排列。关联容器包括：map（集合）、set（映射）、multimap（多重集合）、multiset（多重映射）。
  3、容器适配器：本质上，适配器是使一种不同的行为类似于另一事物的行为的一种机制。容器适配器让一种已存在的容器类型采用另一种不同的抽象类型的工作方式实现。适配器是容器的接口，它本身不能直接保存元素，它保存元素的机制是调用另一种顺序容器去实现，即可以把适配器看作“它保存一个容器，这个容器再保存所有元素”。STL 中包含三种适配器：栈stack 、队列queue 和优先级队列priority_queue 。

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

三、不同容器的使用方法

  1、vector(需要导入头文件#include <vector>)

       ①定义与初始化

            如果没有指定元素的初始化式，那么标准库将自行提供一个元素初始值进行，具体值为何，取决于存储在vector 中元素的数据类型；如果为int型数据，那么标准库将用 0 值创建元素初始化式；如果 vector 保存的是含有构造函数的类类型（如 string）的元素，标准库将用该类型的默认构造函数创建元素初始化式；元素类型可能是没有定义任何构造函数的类类型。这种情况下，标准库仍产生一个带初始值的对象，这个对象的每个成员进行了值初始化。

         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的元素

         vector<string> vec6(10,"null");    //10个值为null的元素

         vector<string> vec7(10,"hello");  //10个值为hello的元素

      ②常用的操作方法

           

    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.end());//删除之间的元素，其他元素前移

    cout<<(vec1==vec2)?true:false;  //判断是否相等==、！=、>=、<=...

    vector<int>::iterator iter = vec1.begin();    //获取迭代器首地址

    vector<int>::const_iterator c_iter = vec1.begin();   //获取const类型迭代器

    vec1.clear();                 //清空元素

•  反向迭代器的概念点此进入

③遍历方法

// 下标法(vector的特有访问方法，一般容器只能通过迭代器访问)
     int  length = vec1.size();
     for ( int  i=0;i<length;i++)
    {
       cout<<vec1[i];
    }
    cout<<endl<<endl;
     // 迭代器法
    vector< int >::const_iterator iterator = vec1.begin();
     for (;iterator != vec1.end();iterator++)
    {

       cout<<*iterator；

    }

  2、list(需要导入头文件#include <list>)

       ①定义与初始化

 

    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

       ②常用的操作方法

    lst1.assign(lst2.begin(),lst2.end());  //分配值

    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();                         //删除相邻重复元素

       ③遍历方法

    //迭代器法

    for(list<int>::const_iterator iter = lst1.begin();iter != lst1.end();iter++)

    {

       cout<<*iter;

    }

    cout<<endl;

  3、deque(需要导入头文件#include <deque>)

       deque容器类与vector类似，支持随机访问和快速插入删除，它在容器中某一位置上的操作所花费的是线性时间。与vector不同的是，deque还支持从开始端插入数据：push_front()。其余类似vector操作方法的使用。

 4、顺序容器使用方法小结（操作的共同点）

       ①添加元素

函数名	意义
c.push_back(t)	在容器c的尾部添加值为t的元素。返回void 类型
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所指向的元素前面插入由迭代器b和e标记的范围内的元素。返回 void 类型

//在容器首部或者尾部添加数据

list<int> ilist;

ilist.push_back(ix);//尾部添加

ilist.push_front(ix);//首部添加

//在容器中指定位置添加元素

list<string> lst;

list<string>::iterator iter = lst.begin();

while (cin >> word)

iter = lst.insert(iter, word); // 和push_front意义一样

//插入一段元素

list<string> slist;

string sarray[4] = {"quasi", "simba", "frollo", "scar"};

slist.insert(slist.end(), 10, "A");//尾部前添加十个元素都是A

list<string>::iterator slist_iter = slist.begin();

slist.insert(slist_iter, sarray+2, sarray+4);//指针范围添加

②容器大小的操作

函数名	意义
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

list<int> ilist(10, 1);

ilist.resize(15); // 尾部添加五个元素，值都为0

ilist.resize(25, -1); // 再在尾部添加十个元素，元素为-1

ilist.resize(5); // 从尾部删除20个元素

③访问元素

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

vector<int> vi;

for(int i=0;i<10;i++)vi.push_back(i);

cout<<vi[0]<<endl;

cout<<vi.at(0)<<endl;

cout<<vi[10]<<endl; //越界错误

cout<<vi.at(10)<<endl;//越界错误

④ 删除元素

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

//删除第一个或最后一个元素

list<int> li;

for(int i=0;i<10;i++)list.push_back(i);

li.pop_front();//删除第一个元素

li.pop_back(); //删除最后一个元素

//删除容器内的一个元素

list<int>::iterator iter =li.begin();

if(iter!= li.end())li.erase(iter);

//删除容器内所有元素

li.clear();

⑤赋值与swap

函数名	意义
c1 = c2	删除容器c1的所有元素，然后将c2的元素复制给c1。c1和c2的类型（包括容器类型和元素类型）必须相同
c1.swap(c2)	交换内容：调用完该函数后，c1中存放的是 c2 原来的元素，c2中存放的则是c1原来的元素。c1和c2的类型必须相同。该函数的执行速度通常要比将c2复制到c1的操作快
c.assign(b,e)	重新设置c的元素：将迭代器b和e标记的范围内所有的元素复制到c中。b和e必须不是指向c中元素的迭代器
c.assign(n,t)	将容器c重新设置为存储n个值为t的元素

list<string> sl1,sl2;

for(int i=0;i<10;i++)sl2.push_back("a");

sl1.assign(sl2.begin(),sl2.end());//用sl2的指针范围赋值，sl1中十个元素都为a

sl1.assign(10, "A"); //s1被重新赋值，拥有十个元素，都为A

vector<string> vs1(3);  // vs1有3个元素


vector<string> vs(5);  // vs2有5个元素


vs1.swap(vs2);//执行后,vs1中5个元素，而vs2则存3个元素。




  5、map(需要导入头文件#include <map>)

       C++中map容器提供一个键值对（key/value）容器，map与multimap差别仅仅在于multiple允许一个键对应多个值。对于迭代器来说，可以修改实值，而不能修改key。Map会根据key自动排序。

        map 是键－值对的集合。map 类型通常可理解为关联数组：可使用键作为下标来获取一个值，正如内置数组类型一样。而关联的本质在于元素的值与某个特定的键相关联，而并非通过元素在数组中的位置来获取。

       ①定义与初始化

          map<int,string> map1;                  //空map

函数名	意义
map<k, v>m	创建一个名为m的空map对象，其键和值的类型分别为k和v
map<k, v> m(m2)	创建m2的副本m，m与m2必须有相同的键类型和值类型
map<k, v> m(b, e)	创建map类型的对象m，存储迭代器b和e标记的范围内所有元素的副本。元素的类型必须能转换为pair<const k, v>

       在使用关联容器时，它的键不但有一个类型，而且还有一个相关的比较函数。所用的比较函数必须在键类型上定义严格弱排序（strict weak ordering）：可理解为键类型数据上的“小于”关系，虽然实际上可以选择将比较函数设计得更复杂。
       对于键类型，唯一的约束就是必须支持 < 操作符，至于是否支持其他的关系或相等运算，则不作要求。

       ②常用的操作方法

       添加元素有两种方法：1、先用下标操作符获取元素，然后给获取的元素赋值 2、使用insert成员函数实现
下标操作添加元素：如果该键已在容器中，则 map 的下标运算与 vector 的下标运算行为相同：返回该键所关联的值。只有在所查找的键不存在时，map 容器才为该键创建一个新的元素，并将它插入到此 map 对象中。此时，所关联的值采用值初始化：类类型的元素用默认构造函数初始化，而内置类型的元素初始化为 0。

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中具有给定键的元素

    例1：

word_count.insert(map<string,  int >::value_type( "Anna" , 1));

word_count.insert(make_pair( "Anna" , 2));//返回false，且键值仍为1.

word_count["Anna"] = 2;//键值变为2


   insert的返回值：包含一个迭代器和一个bool值的pair对象，其中迭代器指向map中具有相应键的元素，

而bool值则表示是否插入了该元素。 如果该键已在容器中，则其关联的值保持不变，返回的bool值为false。

在这两种情况下，迭代器都将指向具有给定键的元素。

例2：

pair<map<string,  int >::iterator,  bool > ret =

word_count.insert(make_pair(word, 1));




    ret存储insert函数返回的pair对象。该pair的first成员是一个map迭代器，指向插入的键。

ret.first从insert返回的pair对象中获取 map 迭代器；ret.second从insert返回是否插入了该元素。

例3：

    map1[3] = "Saniya";                    //添加元素

    map1.insert(map<int,string>::value_type(2,"Diyabi"));//插入元素

    map1.insert(pair<int,string>(1,"Siqinsini"));

    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();                      //清空所有元素

③遍历

    map中使用下标存在一个很危险的副作用：如果该键不在 map 容器中，那么下标操作会插入一个具有该键的新元素。所以map 容器提供了两个操作：count 和 find，用于检查某个键是否存在而不会插入该键。

函数名	意义
m.count(k)	返回 m 中 k 的出现次数
m.find(k)	如果m容器中存在按k索引的元素，则返回指向该元素的迭代器。如果不存在，则返回超出末端迭代器。

        例1：

int occurs = 0;

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;




   例2：

for(map<int,string>::iterator iter = map1.begin();iter!=map1.end();iter++)

    {

       int keyk = iter->first;

       string valuev = iter->second;

    }

④从map对象中删除元素

函数名	意义
m.erase(k)	删除m中键为k的元素。返回size_type类型的值，表示删除的元素个数
m.erase(p)	从m中删除迭代器p所指向的元素。p必须指向m中确实存在的元素，而且不能等于m.end()。返回void
m.erase(b, e)	从m中删除一段范围内的元素，该范围由迭代器对b和e标记。b和e必须标记m中的一段有效范围：即b和e都必须指向m中的元素或最后一个元素的下一个位置。而且，b和e要么相等（此时删除的范围为空），要么b所指向的元素必须出在e所 指向的元素之前。返回 void 类型

string removal_word = "a";

if (word_count.erase(removal_word))

cout << "ok: " << removal_word << " removed\n";

else cout << "oops: " << removal_word << " not found!\n";

  6、set(需要导入头文件#include <set>)

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

       ①set容器的定义和使用

           set 容器的每个键都只能对应一个元素。以一段范围的元素初始化set对象，或在set对象中插入一组元素时，对于每个键，事实上都只添加了一个元素。

vector< int > ivec;

for  (vector< int >::size_type i = 0; i != 10; ++i) {

ivec.push_back(i);

ivec.push_back(i);

}

set< int > iset(ivec.begin(), ivec.end());

cout << ivec.size() << endl;  //20个

cout << iset.size() << endl;  // 10个




       ②在set中添加元素

set<string> set1;

set1.insert( "the" );  //第一种方法：直接添加

set< int > iset2;

iset2.insert(ivec.begin(), ivec.end()); //第二中方法：通过指针迭代器




        ③从set中获取元素

 set 容器不提供下标操作符。为了通过键从 set 中获取元素，可使用 find运算。
如果只需简单地判断某个元素是否存在，同样可以使用 count 运算，返回 set 中该键对应的元素个数。
当然，对于 set 容器，count 的返回值只能是1（该元素存在）或 0（该元素不存在）。

set< int > iset;

for ( int  i = 0; i<10; i++)iset.insert(i);

iset.find(1)  // 返回指向元素内容为1的指针

iset.find(11)