转：STL提供了三个最基本的容器：vector,list,deque

vector和built-in数组类似，它拥有一段连续的内存空间，并且起始地址不变，因此它能非常好的支持随机存取，即[]操作符，但由于它的内存空间是连续的，所以在中间进行插入和删除会造成内存块的拷贝，另外，当该数组后的内存空间不够时，需要重新申请一块足够大的内存并进行内存的拷贝。这些都大大影响了vector的效率。 
  
  list就是数据结构中的双向链表(根据sgi   stl源代码)，因此它的内存空间可以是不连续的，通过指针来进行数据的访问，这个特点使得它的随机存取变的非常没有效率，因此它没有提供[]操作符的重载。但由于链表的特点，它可以以很好的效率支持任意地方的删除和插入。 
  
  deque是一个double-ended queue，它的具体实现不太清楚，但知道它具有以下两个特点：它支持[]操作符，也就是支持随即存取，并且和vector的效率相差无几，它支持在两端的操作：push_back、push_front、pop_back、pop_front等，并且在两端操作上与list的效率也差不多。 
  
  因此在实际使用时，如何选择这三个容器中哪一个，应根据你的需要而定，一般应遵循下面的原则： 
      1、如果你需要高效的随即存取，而不在乎插入和删除的效率，使用vector 
      2、如果你需要大量的插入和删除，而不关心随即存取，则应使用list 
      3、如果你需要随即存取，而且关心两端数据的插入和删除，则应使用deque。
 

STL是 C++的ANSI/ISO 标准的一部分,可以用于所有C++语言编译器和所有平台。STL的同一版本在任意硬件配置下都是可用的；STL 提供了大量的可复用软件组织。例如，程序员再也不用自己设计排序，搜索算法了，这些都已经是STL的一部分了。使用STL编写的代码更容易修改和阅读，因为代码更短了，很多基础工作代码已经被组件化了。

STL 的组成
　　STL有三大核心部分：容器（Container）、算法（Algorithms）、迭代器（Iterator），容器适配器（container adaptor），函数对象(functor)，除此之外还有STL其他标准组件。

容器（container）：

容器是数据在内存中组织的方法，例如，数组、堆栈、队列、链表或二叉树（不过这些都不是STL标准容器）。STL中的容器是一种存储T（Template）类型值的有限集合的数据结构,容器的内部实现一般是类。这些值可以是对象本身，如果数据类型T代表的是Class的话。

算法（algorithm）：

算法是应用在容器上以各种方法处理其内容的行为或功能。例如，有对容器内容排序、复制、检索和合并的算法。在STL中，算法是由模板函数表现的。这些函数不是容器类的成员函数。相反，它们是独立的函数。令人吃惊的特点之一就是其算法如此通用。不仅可以将其用于 STL容器，而且可以用于普通的C＋＋数组或任何其他应用程序指定的容器。
迭代器(iterator)：

一旦选定一种容器类型和数据行为(算法)，那么剩下唯一要他做的就是用迭代器使其相互作用。可以把迭代器看作一个指向容器中元素的普通指针。可以如递增一个指针那样递增迭代器，使其依次指向容器中每一个后继的元素。迭代器是STL的一个关键部分，因为它将算法和容器连在一起。

下面我将依次介绍STL的这三个主要组件。

容器
　　STL中的容器有队列容器和关联容器，容器适配器（congtainer adapters：stack,queue，priority queue），位集（bit_set），串包(string_package)等等。
　　在本文中，我将介绍list,vector，deque等队列容器，和set和multisets,map和multimaps等关联容器，一共7种基本容器类。
　　队列容器（顺序容器）：队列容器按照线性排列来存储T类型值的集合，队列的每个成员都有自己的特有的位置。顺序容器有向量类型、双端队列类型、列表类型三种。
基本容器——顺序容器
　　向量（vector容器类）：＃include <vector>，vector是一种动态数组，是基本数组的类模板。其内部定义了很多基本操作。既然这是一个类，那么它就会有自己的构造函数。vector 类中定义了4种构造函数：

默认构造函数，构造一个初始长度为0的空向量，
如：vector<int> v1;
带有单个整形参数的构造函数，此参数描述了向量的初始大小。这个构造函数还有一个可选的参数，这是一个类型为T的实例，描述了各个向量种各成员的初始值；
如：vector<int> v2(init_size,0); 如果预先定义了：int init_size;他的成员值都被初始化为0；
复制构造函数，构造一个新的向量，作为已存在的向量的完全复制，
如：vector<int> v3(v2);
带两个常量参数的构造函数，产生初始值为一个区间的向量。区间由一个半开区间[first,last](MS word的显示可能会有问题，first前是一个左方括号，last后面是一个右圆括号)来指定。
如：vector<int> v4（first,last）
下面一个例子用的是第四种构造方法，其它的方法读者可以自己试试。

代码

   
     

    
      
    
      //
    
      stl_cpp_7.cpp

    
      //
    
      程序：初始化演示
    
      

    
      #include 
    
      <
    
      cstring
    
      >
    
       
#include 
    
      <
    
      vector
    
      >
    
      
#include 
    
      <
    
      iostream
    
      >
    
      

    
      using
    
       
    
      namespace
    
       std;

    
      int
    
       ar[
    
      10
    
      ] 
    
      =
    
       { 
    
      12
    
      , 
    
      45
    
      , 
    
      234
    
      , 
    
      64
    
      , 
    
      12
    
      , 
    
      35
    
      , 
    
      63
    
      , 
    
      23
    
      , 
    
      12
    
      , 
    
      55
    
       };

    
      char
    
      *
    
       str 
    
      =
    
       
    
      "
    
      Hello World
    
      "
    
      ;

    
      int
    
       main(
    
      void
    
      )
{
 vector 
    
      <
    
      int
    
      >
    
       vec1(ar, ar
    
      +
    
      10
    
      ); 
    
      //
    
      first=ar,last=ar+10,不包括ar+10
    
      

    
       vector 
    
      <
    
      char
    
      >
    
       vec2(str, str
    
      +
    
      strlen(str)); 
    
      //
    
      first=str,last= str+strlen(str),不包括最后一个
    
      

    
       cout
    
      <<
    
      "
    
      vec1:
    
      "
    
      <<
    
      endl; 
 
    
      //
    
      打印vec1和vec2，const_iterator是迭代器，后面会讲到
 
    
      //
    
      当然，也可以用for (int i=0; i<vec1.size(); i++)cout << vec[i];输出
 
    
      //
    
      size()是vector的一个成员函数
    
      

    
       
    
      for
    
      (vector
    
      <
    
      int
    
      >
    
      ::const_iterator p
    
      =
    
      vec1.begin();p
    
      !=
    
      vec1.end(); 
    
      ++
    
      p)
 cout
    
      <<*
    
      p;
 cout
    
      <<
    
      "
    
      \n
    
      "
    
      <<
    
      "
    
      vec2:
    
      "
    
      <<
    
      endl;
 
    
      for
    
      (vector
    
      <
    
      char
    
      >
    
      ::const_iterator p1
    
      =
    
      vec2.begin();p1
    
      !=
    
      vec2.end(); 
    
      ++
    
      p1)
 cout
    
      <<*
    
      p1;
 getchar();
 
    
      return
    
       
    
      0
    
      ;
} 


　　为了帮助理解向量的概念，这里写了一个小例子，其中用到了vector的成员函数：begin()，end()，push_back()，assign()，front()，back()，erase()，empty()，at()，size()。 

    
      //
    
      stl_cpp_8.cpp
    
      

    
      #include 
    
      <
    
      iostream
    
      >
    
      
#include 
    
      <
    
      vector
    
      >
    
      

    
      using
    
       
    
      namespace
    
       std;
typedef vector
    
      <
    
      int
    
      >
    
       INTVECTOR;
    
      //
    
      自定义类型INTVECTOR

    
      //
    
      测试vector容器的功能
    
      

    
      void
    
       main(
    
      void
    
      )
{
 
    
      //
    
      vec1对象初始为空
    
      

    
       INTVECTOR vec1; 
 
    
      //
    
      vec2对象最初有10个值为6的元素 
    
      

    
       INTVECTOR vec2(
    
      10
    
      ,
    
      6
    
      ); 
 
    
      //
    
      vec3对象最初有3个值为6的元素，拷贝构造
    
      

    
       INTVECTOR vec3(vec2.begin(),vec2.begin()
    
      +
    
      3
    
      ); 
 
    
      //
    
      声明一个名为i的双向迭代器
    
      

    
       INTVECTOR::iterator i;
 
    
      //
    
      从前向后显示vec1中的数据
    
      

    
       cout
    
      <<
    
      "
    
      vec1.begin()--vec1.end():
    
      "
    
      <<
    
      endl;
 
    
      for
    
       (i 
    
      =
    
      vec1.begin(); i 
    
      !=
    
      vec1.end(); 
    
      ++
    
      i)
 cout 
    
      <<
    
       
    
      *
    
      i 
    
      <<
    
       
    
      "
    
       
    
      "
    
      ;
 cout 
    
      <<
    
       endl;
 
    
      //
    
      从前向后显示vec2中的数据
    
      

    
       cout
    
      <<
    
      "
    
      vec2.begin()--vec2.end():
    
      "
    
      <<
    
      endl;
 
    
      for
    
       (i 
    
      =
    
      vec2.begin(); i 
    
      !=
    
      vec2.end(); 
    
      ++
    
      i)
 cout 
    
      <<
    
       
    
      *
    
      i 
    
      <<
    
       
    
      "
    
       
    
      "
    
      ;
 cout 
    
      <<
    
       endl;
 
    
      //
    
      从前向后显示vec3中的数据
    
      

    
       cout
    
      <<
    
      "
    
      vec3.begin()--vec3.end():
    
      "
    
      <<
    
      endl;
 
    
      for
    
       (i 
    
      =
    
      vec3.begin(); i 
    
      !=
    
      vec3.end(); 
    
      ++
    
      i)
 cout 
    
      <<
    
       
    
      *
    
      i 
    
      <<
    
       
    
      "
    
       
    
      "
    
      ;
 cout 
    
      <<
    
       endl;
 
    
      //
    
      测试添加和插入成员函数，vector不支持从前插入
    
      

    
       vec1.push_back(
    
      2
    
      );
    
      //
    
      从后面添加一个成员
    
      

    
       vec1.push_back(
    
      4
    
      );
 vec1.insert(vec1.begin()
    
      +
    
      1
    
      ,
    
      5
    
      );
    
      //
    
      在vec1第一个的位置上插入成员5
 
    
      //
    
      从vec1第一的位置开始插入vec3的所有成员
    
      

    
       vec1.insert(vec1.begin()
    
      +
    
      1
    
      ,vec3.begin(),vec3.end());
 cout
    
      <<
    
      "
    
      after push() and insert() now the vec1 is:
    
      "
    
       
    
      <<
    
      endl;
 
    
      for
    
       (i 
    
      =
    
      vec1.begin(); i 
    
      !=
    
      vec1.end(); 
    
      ++
    
      i)
 cout 
    
      <<
    
       
    
      *
    
      i 
    
      <<
    
       
    
      "
    
       
    
      "
    
      ;
 cout 
    
      <<
    
       endl;
 
    
      //
    
      测试赋值成员函数
    
      

    
       vec2.assign(
    
      8
    
      ,
    
      1
    
      ); 
    
      //
    
       重新给vec2赋值，8个成员的初始值都为1
    
      

    
       cout
    
      <<
    
      "
    
      vec2.assign(8,1):
    
      "
    
       
    
      <<
    
      endl;
 
    
      for
    
       (i 
    
      =
    
      vec2.begin(); i 
    
      !=
    
      vec2.end(); 
    
      ++
    
      i)
 cout 
    
      <<
    
       
    
      *
    
      i 
    
      <<
    
       
    
      "
    
       
    
      "
    
      ;
 cout 
    
      <<
    
       endl;
 
    
      //
    
      测试引用类函数
    
      

    
       cout
    
      <<
    
      "
    
      vec1.front()=
    
      "
    
      <<
    
      vec1.front()
    
      <<
    
      endl;
    
      //
    
      vec1第零个成员
    
      

    
       cout
    
      <<
    
      "
    
      vec1.back()=
    
      "
    
      <<
    
      vec1.back()
    
      <<
    
      endl;
    
      //
    
      vec1的最后一个成员
    
      

    
       cout
    
      <<
    
      "
    
      vec1.at(4)=
    
      "
    
      <<
    
      vec1.at(
    
      4
    
      )
    
      <<
    
      endl;
    
      //
    
      vec1的第五个成员
    
      

    
       cout
    
      <<
    
      "
    
      vec1[4]=
    
      "
    
      <<
    
      vec1[
    
      4
    
      ]
    
      <<
    
      endl;
 
    
      //
    
      测试移出和删除
    
      

    
       vec1.pop_back();
    
      //
    
      将最后一个成员移出vec1
    
      

    
       vec1.erase(vec1.begin()
    
      +
    
      1
    
      ,vec1.end()
    
      -
    
      2
    
      );
    
      //
    
      删除成员
    
      

    
       cout
    
      <<
    
      "
    
      vec1.pop_back() and vec1.erase():
    
      "
    
       
    
      <<
    
      endl;
 
    
      for
    
       (i 
    
      =
    
      vec1.begin(); i 
    
      !=
    
      vec1.end(); 
    
      ++
    
      i)
 cout 
    
      <<
    
       
    
      *
    
      i 
    
      <<
    
       
    
      "
    
       
    
      "
    
      ;
 cout 
    
      <<
    
       endl;
 
    
      //
    
      显示序列的状态信息
    
      

    
       cout
    
      <<
    
      "
    
      vec1.size(): 
    
      "
    
      <<
    
      vec1.size()
    
      <<
    
      endl;
    
      //
    
      打印成员个数
    
      

    
       cout
    
      <<
    
      "
    
      vec1.empty(): 
    
      "
    
      <<
    
      vec1.empty()
    
      <<
    
      endl;
    
      //
    
      清空
    
      

    
      }
   
     

 

 

push_back()是将数据放入vector（向量）或deque（双端队列）的标准函数。Insert()是一个与之类似的函数，然而它在所有容器中都可以使用，但是用法更加复杂。end()实际上是取末尾加一，以便让循环正确运行--它返回的指针指向最靠近数组界限的数据。

　　在Java里面也有向量的概念。Java中的向量是对象的集合。其中，各元素可以不必同类型，元素可以增加和删除，不能直接加入原始数据类型。

双端队列（qeque容器类）：#include <deque>
　　deque（读音：deck，意即：double queue）容器类与vector类似，支持随机访问和快速插入删除，它在容器中某一位置上的操作所花费的是线性时间。与vector不同的是，deque还支持从开始端插入数据：
push_front()。此外deque也不支持与vector的capacity()、reserve()类似的操作。

 

代码

   
     

    
      
    
      //
    
      stl_cpp_9.cpp
    
      

    
      #include 
    
      <
    
      iostream
    
      >
    
      
#include 
    
      <
    
      deque
    
      >
    
      

    
      using
    
       
    
      namespace
    
       std;
typedef deque
    
      <
    
      int
    
      >
    
       INTDEQUE;
    
      //
    
      有些人很讨厌这种定义法，呵呵

    
      //
    
      从前向后显示deque队列的全部元素
    
      

    
      void
    
       put_deque(INTDEQUE deque, 
    
      char
    
       
    
      *
    
      name)
{
 INTDEQUE::iterator pdeque;
    
      //
    
      仍然使用迭代器输出
    
      

    
       cout 
    
      <<
    
       
    
      "
    
      The contents of 
    
      "
    
       
    
      <<
    
       name 
    
      <<
    
       
    
      "
    
       : 
    
      "
    
      ;
 
    
      for
    
      (pdeque 
    
      =
    
       deque.begin(); pdeque 
    
      !=
    
       deque.end(); pdeque
    
      ++
    
      )
 cout 
    
      <<
    
       
    
      *
    
      pdeque 
    
      <<
    
       
    
      "
    
       
    
      "
    
      ;
    
      //
    
      注意有 "*"号哦，没有"*"号的话会报错
    
      

    
       cout
    
      <<
    
      endl;
}

    
      //
    
      测试deqtor容器的功能
    
      

    
      void
    
       main(
    
      void
    
      )
{
 
    
      //
    
      deq1对象初始为空
    
      

    
       INTDEQUE deq1; 
 
    
      //
    
      deq2对象最初有10个值为6的元素 
    
      

    
       INTDEQUE deq2(
    
      10
    
      ,
    
      6
    
      ); 
 
    
      //
    
      deq3对象最初有3个值为6的元素 
 
    
      //
    
      声明一个名为i的双向迭代器变量
    
      

    
       INTDEQUE::iterator i;
 
    
      //
    
      从前向后显示deq1中的数据
    
      

    
       put_deque(deq1,
    
      "
    
      deq1
    
      "
    
      );
 
    
      //
    
      从前向后显示deq2中的数据
    
      

    
       put_deque(deq2,
    
      "
    
      deq2
    
      "
    
      );
 
    
      //
    
      从deq1序列后面添加两个元素
    
      

    
       deq1.push_back(
    
      2
    
      );
 deq1.push_back(
    
      4
    
      );
 cout
    
      <<
    
      "
    
      deq1.push_back(2) and deq1.push_back(4):
    
      "
    
      <<
    
      endl;
 put_deque(deq1,
    
      "
    
      deq1
    
      "
    
      );
 
    
      //
    
      从deq1序列前面添加两个元素
    
      

    
       deq1.push_front(
    
      5
    
      );
 deq1.push_front(
    
      7
    
      );
 cout
    
      <<
    
      "
    
      deq1.push_front(5) and deq1.push_front(7):
    
      "
    
      <<
    
      endl;
 put_deque(deq1,
    
      "
    
      deq1
    
      "
    
      );
 
    
      //
    
      在deq1序列中间插入数据
    
      

    
       deq1.insert(deq1.begin()
    
      +
    
      1
    
      ,
    
      3
    
      ,
    
      9
    
      );
 cout
    
      <<
    
      "
    
      deq1.insert(deq1.begin()+1,3,9):
    
      "
    
      <<
    
      endl;
 put_deque(deq1,
    
      "
    
      deq1
    
      "
    
      );
 
    
      //
    
      测试引用类函数
    
      

    
       cout
    
      <<
    
      "
    
      deq1.at(4)=
    
      "
    
      <<
    
      deq1.at(
    
      4
    
      )
    
      <<
    
      endl;
 cout
    
      <<
    
      "
    
      deq1[4]=
    
      "
    
      <<
    
      deq1[
    
      4
    
      ]
    
      <<
    
      endl;
 deq1.at(
    
      1
    
      )
    
      =
    
      10
    
      ;
 deq1[
    
      2
    
      ]
    
      =
    
      12
    
      ;
 cout
    
      <<
    
      "
    
      deq1.at(1)=10 and deq1[2]=12 :
    
      "
    
      <<
    
      endl;
 put_deque(deq1,
    
      "
    
      deq1
    
      "
    
      );
 
    
      //
    
      从deq1序列的前后各移去一个元素
    
      

    
       deq1.pop_front();
 deq1.pop_back();
 cout
    
      <<
    
      "
    
      deq1.pop_front() and deq1.pop_back():
    
      "
    
      <<
    
      endl;
 put_deque(deq1,
    
      "
    
      deq1
    
      "
    
      );
 
    
      //
    
      清除deq1中的第2个元素
    
      

    
       deq1.erase(deq1.begin()
    
      +
    
      1
    
      );
 cout
    
      <<
    
      "
    
      deq1.erase(deq1.begin()+1):
    
      "
    
      <<
    
      endl;
 put_deque(deq1,
    
      "
    
      deq1
    
      "
    
      );
 
    
      //
    
      对deq2赋值并显示
    
      

    
       deq2.assign(
    
      8
    
      ,
    
      1
    
      );
 cout
    
      <<
    
      "
    
      deq2.assign(8,1):
    
      "
    
      <<
    
      endl;
 put_deque(deq2,
    
      "
    
      deq2
    
      "
    
      );
}

   
     

上面我们演示了deque如何进行插入删除等操作，像erase(),assign()是大多数容器都有的操作。关于deque的其他操作请参阅附录。

表（List容器类）：#include <list>
　　 List又叫链表，是一种双线性列表，只能顺序访问（从前向后或者从后向前），图2是list的数据组织形式。与前面两种容器类有一个明显的区别就是：它不支持随机访问。要访问表中某个下标处的项需要从表头或表尾处（接近该下标的一端）开始循环。而且缺少下标预算符：operator[]。

　　同时，list仍然包涵了erase(),begin(),end(),insert(),push_back(),push_front()这些基本函数，下面我们来演示一下list的其他函数功能。

merge()：合并两个排序列表；
splice()：拼接两个列表；
sort()：列表的排序；

 

代码

   
     

    
      
    
      //
    
      stl_cpp_10.cpp
    
      

    
      #include 
    
      <
    
      iostream
    
      >
    
      
#include 
    
      <
    
      string
    
      >
    
      
#include 
    
      <
    
      list
    
      >
    
      

    
      using
    
       
    
      namespace
    
       std;

    
      void
    
       PrintIt(list
    
      <
    
      int
    
      >
    
       n)
{
 
    
      for
    
      (list
    
      <
    
      int
    
      >
    
      ::iterator iter
    
      =
    
      n.begin(); iter
    
      !=
    
      n.end(); 
    
      ++
    
      iter)
 cout
    
      <<*
    
      iter
    
      <<
    
      "
    
       
    
      "
    
      ;
    
      //
    
      用迭代器进行输出循环 
    
      

    
      }

    
      void
    
       main(
    
      void
    
      )
{
 list
    
      <
    
      int
    
      >
    
       listn1,listn2;
 
    
      //
    
      给listn1,listn2初始化 
    
      

    
       listn1.push_back(
    
      123
    
      );
 listn1.push_back(
    
      0
    
      );
 listn1.push_back(
    
      34
    
      );
 listn1.push_back(
    
      1123
    
      );
 
    
      //
    
      now listn1:123,0,34,1123 
    
      

    
       listn2.push_back(
    
      100
    
      );
 listn2.push_back(
    
      12
    
      );
 
    
      //
    
      now listn2:12,100
    
      

    
       listn1.sort();
 listn2.sort();
 
    
      //
    
      给listn1和listn2排序
 
    
      //
    
      now listn1:0,34,123,1123 listn2:12,100 
    
      

    
       PrintIt(listn1);
 cout
    
      <<
    
      endl;
 PrintIt(listn2);
 listn1.merge(listn2);
 
    
      //
    
      合并两个排序列表后,listn1:0，12，34，100，123，1123 
    
      

    
       cout
    
      <<
    
      endl;
 PrintIt(listn1);
 cin.
    
      get
    
      ();
}

   
     

 

 

上面并没有演示splice()函数的用法，这是一个拗口的函数。用起来有点麻烦。图3所示是splice函数的功能。将一个列表插入到另一个列表当中。list容器类定义了splice()函数的3个版本： splice(position,list_value);
splice(position,list_value,ptr);
splice(position,list_value,first,last);

　　list_value是一个已存在的列表，它将被插入到源列表中，position是一个迭代参数，他当前指向的是要进行拼接的列表中的特定位置。

listn1:123,0,34,1123   listn2:12,100

　　执行listn1.splice(find(listn1.begin(),listn1.end(),0),listn2);之后，listn1将变为：123，12，100，34，1123。即把listn2插入到listn1的0这个元素之前。其中，find()函数找到0这个元素在listn1中的位置。值得注意的是，在执行splice之后，list_value将不复存在了。这个例子中是listn2将不再存在。
　　第二个版本当中的ptr是一个迭代器参数，执行的结果是把ptr所指向的值直接插入到position当前指向的位置之前.这将只向源列表中插入一个元素。
　　第三个版本的first和last也是迭代器参数，并不等于list_value.begin(),list_value.end()。First指的是要插入的列的第一个元素，last指的是要插入的列的最后一个元素。

如果listn1:123,0,34,1123 listn2:12,43，87，100 执行完以下函数之后listn1.splice(find(listn1.begin(),listn1.end(),0),++listn2.begin(),--listn2.end());
listn1:123,43,87,0,34,1123  listn2:12,100

　　除了vector,deque,list三种基本顺序容器，其他的顺序容器还有：slist,bit_vector等等。

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/andylin02/archive/2008/11/19/3335545.aspx