STL中vector、list、deque和map-摩杜云开发者社区

STL中vector、list、deque和map的区别

vector

    向量相当于一个数组
    在内存中分配一块连续的内存空间进行存储。支持不指定vector大小的存储。STL内部实现时，首先分配一个非常大的内存空间预备进行存储，即capacituy（）函数返回的大小，当超过此分配的空间时再整体重新放分配一块内存存储，这给人以vector可以不指定vector即一个连续内存的大小的感觉。通常此默认的内存分配能完成大部分情况下的存储。
   优点：(1) 不指定一块内存大小的数组的连续存储，即可以像数组一样操作，但可以对此数组
               进行动态操作。通常体现在push_back() pop_back()
               (2) 随机访问方便，即支持[ ]操作符和vector.at()
               (3) 节省空间。
   缺点：(1) 在内部进行插入删除操作效率低。
               (2) 只能在vector的最后进行push和pop，不能在vector的头进行 push和pop。
                (3) 当动态添加的数据超过vector默认分配的大小时要进行整体的重新分配、拷贝与释
                     放

2 list
    双向链表
    每一个结点都包括一个信息快Info、一个前驱指针Pre、一个后驱指针Post。可以不分配必须的内存大小方便的进行添加和删除操作。使用的是非连续的内存空间进行存储。
   优点： (1) 不使用连续内存完成动态操作。
                (2) 在内部方便的进行插入和删除操作
               (3) 可在两端进行push、pop
   缺点：(1) 不能进行内部的随机访问，即不支持[ ]操作符和vector.at()
               (2) 相对于verctor占用内存多

3 deque
    双端队列 double-end queue
    deque是在功能上合并了vector和list。
   优点： (1) 随机访问方便，即支持[ ]操作符和vector.at()
                (2) 在内部方便的进行插入和删除操作
               (3) 可在两端进行push、pop
   缺点： (1) 占用内存多
使用区别：
     1 如果你需要高效的随即存取，而不在乎插入和删除的效率，使用vector
     2 如果你需要大量的插入和删除，而不关心随即存取，则应使用list
     3 如果你需要随即存取，而且关心两端数据的插入和删除，则应使用deque

C++STL中vector容器的用法

http://xiamaogeng.blog.163.com/blog/static/1670023742010102494039234/

vector是C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。为了可以使用vector，必须在你的头文件中包含下面的代码：

#include <vector>

vector属于std命名域的，因此需要通过命名限定，如下完成你的代码：

using std::vector;     vector<int> v;

或者连在一起，使用全名：

std::vector<int> v;

建议使用全局的命名域方式：

using namespace std;

1.vector的声明

vector<ElemType> c; 创建一个空的vector

vector<ElemType> c1(c2); 创建一个vector c1，并用c2去初始化c1

vector<ElemType> c(n) ; 创建一个含有n个ElemType类型数据的vector;

vector<ElemType> c(n,elem); 创建一个含有n个ElemType类型数据的vector,并全部初始化为elem;

c.~vector<ElemType>(); 销毁所有数据,释放资源;

2.vector容器中常用的函数。(c为一个容器对象）

c.push_back(elem); 在容器最后位置添加一个元素elem

c.pop_back(); 删除容器最后位置处的元素

c.at(index); 返回指定index位置处的元素

c.begin(); 返回指向容器最开始位置数据的指针

c.end(); 返回指向容器最后一个数据单元的指针+1

c.front(); 返回容器最开始单元数据的引用

c.back(); 返回容器最后一个数据的引用

c.max_size(); 返回容器的最大容量

c.size(); 返回当前容器中实际存放元素的个数

c.capacity(); 同c.size()

c.resize(); 重新设置vector的容量

c.reserve(); 同c.resize()

c.erase(p); 删除指针p指向位置的数据，返回下指向下一个数据位置的指针（迭代器）

c.erase(begin,end) 删除begin,end区间的数据，返回指向下一个数据位置的指针（迭代器）

c.clear(); 清除所有数据

c.rbegin(); 将vector反转后的开始指针返回(其实就是原来的end-1)

c.rend(); 将vector反转后的结束指针返回(其实就是原来的begin-1)

c.empty(); 判断容器是否为空，若为空返回true，否则返回false

c1.swap(c2); 交换两个容器中的数据

c.insert(p,elem); 在指针p指向的位置插入数据elem,返回指向elem位置的指针

c.insert(p,n,elem); 在位置p插入n个elem数据，无返回值

c.insert(p,begin,end) 在位置p插入在区间[begin,end)的数据，无返回值

3.vector中的操作

operator[] 如： c.[i];

同at()函数的作用相同，即取容器中的数据。

在上大致讲述了vector类中所含有的函数和操作，下面继续讨论如何使用vector容器；

1.数据的输入和删除。push_back（）与pop_back（）

STL中vector、list、deque和map_数据

2.元素的访问

STL中vector、list、deque和map_#include_02

3.排序和查询

STL中vector、list、deque和map_键值_03

4.二维容器

STL中vector、list、deque和map_数据_04

C++ STL List队列用法（实例）

2007-12-15 12:54

#include <iostream>
 #include <list>
 #include <numeric>
 #include <algorithm> using namespace std;
 //创建一个list容器的实例LISTINT
 typedef list<int> LISTINT; //创建一个list容器的实例LISTCHAR
 typedef list<char> LISTCHAR; void main(void)
 {
     //--------------------------
     //用list容器处理整型数据
     //--------------------------
     //用LISTINT创建一个名为listOne的list对象
     LISTINT listOne;
     //声明i为迭代器
       //从前面向listOne容器中添加数据
     listOne.push_front (2);
       //从后面向listOne容器中添加数据
     listOne.push_back (3);
       //从前向后显示listOne中的数据
     cout<<"listOne.begin()--- listOne.end():"<<endl;
     for (i = listOne.begin(); i != listOne.end(); ++i)
         cout << *i << " ";
       //从后向后显示listOne中的数据
 LISTINT::reverse_iterator ir;
     cout<<"listOne.rbegin()---listOne.rend():"<<endl;
     for (ir =listOne.rbegin(); ir!=listOne.rend();ir++) {
         cout << *ir << " ";
     }
       //使用STL的accumulate(累加)算法
     int result = accumulate(listOne.begin(), listOne.end(),0);
     cout<<"Sum="<<result<<endl;
       //--------------------------
     //用list容器处理字符型数据
       //用LISTCHAR创建一个名为listOne的list对象
     LISTCHAR listTwo;
     //声明i为迭代器
       //从前面向listTwo容器中添加数据
     listTwo.push_front ('A');
       //从后面向listTwo容器中添加数据
     listTwo.push_back ('x');
       //从前向后显示listTwo中的数据
     cout<<"listTwo.begin()---listTwo.end():"<<endl;
     for (j = listTwo.begin(); j != listTwo.end(); ++j)
         cout << char(*j) << " ";
       //使用STL的max_element算法求listTwo中的最大元素并显示
     j=max_element(listTwo.begin(),listTwo.end());
     cout << "The maximum element in listTwo is: "<<char(*j)<<endl;
 } #include <iostream>
 #include <list> using namespace std;
 typedef list<int> INTLIST; //从前向后显示list队列的全部元素
 void put_list(INTLIST list, char *name)
 {
       cout << "The contents of " << name << " : ";
     for(plist = list.begin(); plist != list.end(); plist++)
         cout << *plist << " ";
     cout<<endl;
 } //测试list容器的功能
 void main(void)
 {
 //list1对象初始为空
     INTLIST list1;  
     //list2对象最初有10个值为6的元素
     INTLIST list2(10,6);
     //list3对象最初有3个值为6的元素
       //声明一个名为i的双向迭代器
       //从前向后显示各list对象的元素
     put_list(list1,"list1");
     put_list(list2,"list2");
     put_list(list3,"list3");
    
 //从list1序列后面添加两个元素
 list1.push_back(2);
 list1.push_back(4);
 cout<<"list1.push_back(2) and list1.push_back(4):"<<endl;
     //从list1序列前面添加两个元素
 list1.push_front(5);
 list1.push_front(7);
 cout<<"list1.push_front(5) and list1.push_front(7):"<<endl;
     //在list1序列中间插入数据
 list1.insert(++list1.begin(),3,9);
 cout<<"list1.insert(list1.begin()+1,3,9):"<<endl;
     //测试引用类函数
 cout<<"list1.front()="<<list1.front()<<endl;
 cout<<"list1.back()="<<list1.back()<<endl; //从list1序列的前后各移去一个元素
 list1.pop_front();
 list1.pop_back();
 cout<<"list1.pop_front() and list1.pop_back():"<<endl;
     //清除list1中的第2个元素
 list1.erase(++list1.begin());
 cout<<"list1.erase(++list1.begin()):"<<endl;
     //对list2赋值并显示
 list2.assign(8,1);
 cout<<"list2.assign(8,1):"<<endl;
     //显示序列的状态信息
 cout<<"list1.max_size(): "<<list1.max_size()<<endl;
 cout<<"list1.size(): "<<list1.size()<<endl;
 cout<<"list1.empty(): "<<list1.empty()<<endl; //list序列容器的运算
     put_list(list1,"list1");
     put_list(list3,"list3");
 cout<<"list1>list3: "<<(list1>list3)<<endl;
 cout<<"list1<list3: "<<(list1<list3)<<endl; //对list1容器排序
 list1.sort();
     put_list(list1,"list1");
    
 //结合处理
 list1.splice(++list1.begin(), list3);
     put_list(list1,"list1");
     put_list(list3,"list3");
 }

C++ map 映照容器

map映照容器的元素数据是一个键值和一个映照数据组成的，键值与映照数据之间具有一一映照的关系。
        map映照容器的数据结构是采用红黑树来实现的，插入键值的元素不允许重复，比较函数只对元素的键值进行比较，元素的各项数据可通过键值检索出来。
        使用map容器需要头文件包含语句“#include<map>”， map文件也包含了对multimap多重映照容器的定义。

1、map创建、元素插入和遍历访问
        创建map对象，键值与映照数据的类型由自己定义。在没有指定比较函数时，元素的插入位置是按键值由小到大插入到黑白树中去的，下面这个程序详细说明了如何操作map容器。

1
#include <map>     
      2     
#include      <string>     
      3     
#include      <iostream>     
      4     

 5
using      std :: cout ;
 6
using      std :: endl ;
 7
using std :: string      ;
 8
using      std :: map ;
 9     

10
int      main()
11
     {
12
     //定义map对象，当前没有任何元素
13
     map<string,float> m ;
14
     
15
     //插入元素，按键值的由小到大放入黑白树中
16
     m["Jack"] = 98.5 ;
17
     m["Bomi"] = 96.0 ;
18
     m["Kate"] = 97.5 ;
19
     
20
     //先前遍历元素
21
     map<string,float> :: iterator it ;
22
     for(it = m.begin() ; it != m.end() ; it ++)
23
     
{
24
          cout << (*it).first << " : " << (*it).second << endl ;
25
     }
26
     
27
     return 0 ;
28
}     
     29
         运行结果：    
                           Bomi ：96    
                           Jack  ：98.5    
                           Kate  ：97.5

程序编译试，会产生代号为“warning C4786” 的警告， “4786” 是标记符超长警告的代号。可以在程序的头文件包含代码的前面使用"#pragma waring(disable:4786)" 宏语句，强制编译器忽略该警告。4786号警告对程序的正确性和运行并无影响。

2、删除元素 map映照容器的 erase() 删除元素函数，可以删除某个迭代器位置上的元素、等于某个键值的元素、一个迭代器区间上的所有元素，当然，也可使用clear()方法清空map映照容器。

下面这个程序演示了删除map容器中键值为28的元素：

1
#include <map>     
      2     
#include      <string>     
      3     
#include      <iostream>     
      4     

 5
using      std :: cout ;
 6
using      std :: endl ;
 7
using std :: string      ;
 8
using      std :: map ;
 9     

10
int      main()
11
     {
12
    //定义map对象，当前没有任何元素
13
    map<int, char> m ;
14
    //插入元素，按键值的由小到大放入黑白树中
15
    m[25] = 'm' ;
16
    m[28] = 'k' ;
17
    m[10] = 'x' ;
18
    m[30] = 'a' ;
19
    //删除键值为28的元素
20
    m.erase(28) ;
21
    //向前遍历元素
22
    map<int, char> :: iterator it ;
23
    for(it = m.begin() ; it != m.end() ; it ++)
24
    
{
25
        //输出键值与映照数据
26
        cout << (*it).first << " : " << (*it).second << endl ;
27
    }
28
    return 0 ;
29
}     
     30
 运行结果：    
                      10 : x    
                      25 : m    
                      30 : a

3、元素反向遍历

可以用反向迭代器reverse_iterator反向遍历map映照容器中的数据，它需要rbegin()方法和rend()方法指出反向遍历的起始位置和终止位置。

1
#include <map>     
      2     
#include      <string>     
      3     
#include      <iostream>     
      4     

 5
using      std :: cout ;
 6
using      std :: endl ;
 7
using std :: string      ;
 8
using      std :: map ;
 9     

10
int      main()
11
     {
12
    //定义map对象，当前没有任何元素
13
    map<int, char> m ;
14
    //插入元素，按键值的由小到大放入黑白树中
15
    m[25] = 'm' ;
16
    m[28] = 'k' ;
17
    m[10] = 'x' ;
18
    m[30] = 'a' ;
19
    //反向遍历元素
20
    map<int, char> :: reverse_iterator rit ;
21
    for( rit = m.rbegin() ; rit != m.rend() ; rit ++)
22
    
{
23
        //输入键值与映照数据
24
        cout << (*rit).first << " : " << (*rit).second << endl ;
25
    }
26
    return 0 ;
27
}     
     28
 运行结果：    
                   30 : a    
                   28 : k    
                   25 : m    
                   10 : x

4、元素的搜索
使用find()方法来搜索某个键值，如果搜索到了，则返回该键值所在的迭代器位置，否则，返回end()迭代器位置。由于map采用黑白树数据结构来实现，所以搜索速度是极快的。

下面这个程序搜索键值为28的元素：

1
#include <map>     
      2     
#include      <string>     
      3     
#include      <iostream>     
      4     

 5
using      std :: cout ;
 6
using      std :: endl ;
 7
using std :: string      ;
 8
using      std :: map ;
 9     

10
int      main()
11
     {
12
    //定义map对象，当前没有任何元素
13
    map<int, char> m ;
14
    //插入元素，按键值的由小到大放入黑白树中
15
    m[25] = 'm' ;
16
    m[28] = 'k' ;
17
    m[10] = 'x' ;
18
    m[30] = 'a' ;
19
    map<int, char> :: iterator it ;
20
    it = m.find(28) ;
21
    if(it != m.end())  //搜索到该键值
22
            cout << (*it).first << " : " << ( *it ).second << endl ;
23
    else
24
            cout << "not found it" << endl ;
25
    return 0 ;
26
}     
     27

5、自定义比较函数
将元素插入到map中去的时候，map会根据设定的比较函数将该元素放到该放的节点上去。在定义map的时候，如果没有指定比较函数，那么采用默认的比较函数，即按键值由小到大的顺序插入元素。在很多情况下，需要自己编写比较函数。

编写方法有两种。

（1）如果元素不是结构体，那么，可以编写比较函数。下面这个程序编写的比较规则是要求按键值由大到小的顺序将元素插入到map中

1
#include <map>     
      2     
#include      <string>     
      3     
#include      <iostream>     
      4     

 5
using      std :: cout ;
 6
using      std :: endl ;
 7
using std :: string      ;
 8
using      std :: map ;
 9     

10
//自定义比较函数 myComp     
     11
struct      myComp
12
     {
13
    bool operator() (const int &a, const int &b)
14
    
{
15
        if(a != b) return a > b ;
16
        else  return a > b ;
17
    }
18
}      ;
19     

20
int      main()
21
     {
22
    //定义map对象，当前没有任何元素
23
    map<int, char> m ;
24
    //插入元素，按键值的由小到大放入黑白树中
25
    m[25] = 'm' ;
26
    m[28] = 'k' ;
27
    m[10] = 'x' ;
28
    m[30] = 'a' ;
29
    //使用前向迭代器中序遍历map
30
    map<int, char,myComp> :: iterator it ;
31
    for(it = m.begin() ; it != m.end() ; it ++)
32
            cout << (*it).first << " : " << (*it).second << endl ;
33
    return 0 ;
34
}     
     35
 运行结果：    
                   30 ：a    
                   28 ：k    
                   25 ：m    
                   10 ：x

（2）如果元素是结构体，那么，可以直接把比较函数写在结构体内。下面的程序详细说明了如何操作：

1
#include <map>     
      2     
#include      <string>     
      3     
#include      <iostream>     
      4     

 5
using      std :: cout ;
 6
using      std :: endl ;
 7
using std :: string      ;
 8
using      std :: map ;
 9     

10
struct      Info
11
     {
12
    string name ;
13
    float score ;
14
    //重载 “<”操作符，自定义排列规则
15
    bool operator < (const Info &a) const
16
    
{
17
        //按score由大到小排列。如果要由小到大排列，使用“>”号即可
18
        return a.score < score ;
19
    }
20
}      ;
21     

22
int      main()
23
     {
24
    //定义map对象，当前没有任何元素
25
    map<Info, int> m ;
26
    //定义Info结构体变量
27
    Info info ;
28
    //插入元素，按键值的由小到大放入黑白树中
29
    info.name = "Jack" ;
30
    info.score = 60 ;
31
    m[info] = 25 ;
32
    info.name = "Bomi" ;
33
    info.score = 80 ;
34
    m[info] = 10 ;
35
    info.name = "Peti" ;
36
    info.score = 66.5 ;
37
    m[info] = 30 ;
38
    //使用前向迭代器中序遍历map
39
    map<Info,int> :: iterator it ;
40
    for(it = m.begin() ; it != m.end() ; it ++)
41
    
{
42
            cout << (*it).second << " : " ;
43
            cout << ((*it).first).name << " : " << ((*it).first).score << endl ;
44
    }
45
    return 0 ;
46
}     
     47
 运行结果：    
                   10 ：Bomi   80    
                   30 ：Peti     66.5    
                   25 ：Jack    60

6、用map实现数字分离

对数字的各位进行分离，采用取余等数学方法是很耗时的。而把数字当成字符串，使用map的映照功能，很方便地实现了数字分离。下面这个程序将一个字符串中的字符当成数字，并将各位的数值相加，最后输出各位的和。

1
#include <string>     
      2     
#include      <map>     
      3     
#include      <iostream>     
      4     

 5
using      std :: cout ;
 6
using      std :: endl ;
 7
using std :: string      ;
 8
using      std :: map ;
 9     

10
int      main()
11
     {
12
    //定义map对象，当前没有任何元素
13
    map<char, int> m ;
14

15
    //赋值：字符映射数字
16
    m['0'] = 0 ;
17
    m['1'] = 1 ;
18
    m['2'] = 2 ;
19
    m['3'] = 3 ;
20
    m['4'] = 4 ;
21
    m['5'] = 5 ;
22
    m['6'] = 6 ;
23
    m['7'] = 7 ;
24
    m['8'] = 8 ;
25
    m['9'] = 9 ;
26
    /**//*上面的10条赋值语句可采用下面这个循环简化代码编写
27
    for(int j = 0 ; j < 10 ; j++)
28
    {
29
            m['0' + j] = j ;
30
    }
31
    */
32
    string sa, sb ;
33
    sa = "6234" ;
34
    int i ;
35
    int sum = 0 ;
36
    for ( i = 0 ; i < sa.length() ; i++ )
37
            sum += m[sa[i]] ;
38
    cout << "sum = " << sum << endl ;
39
    return 0 ;
40
}     
     41

7、数字映照字符的map写法
在很多情况下，需要实现将数字映射为相应的字符，看看下面的程序：

1
#include <string>     
      2     
#include      <map>     
      3     
#include      <iostream>     
      4     

 5
using      std :: cout ;
 6
using      std :: endl ;
 7
using std :: string      ;
 8
using      std :: map ;
 9     

10
int      main()
11
     {
12
    //定义map对象，当前没有任何元素
13
    map<int, char> m ;
14

15
    //赋值：字符映射数字
16
    m[0] = '0' ;
17
    m[1] = '1' ;
18
    m[2] = '2' ;
19
    m[3] = '3' ;
20
    m[4] = '4' ;
21
    m[5] = '5' ;
22
    m[6] = '6' ;
23
    m[7] = '7' ;
24
    m[8] = '8' ;
25
    m[9] = '9' ;
26
    /**//*上面的10条赋值语句可采用下面这个循环简化代码编写
27
    for(int j = 0 ; j < 10 ; j++)
28
    {
29
            m[j] = '0' + j ;
30
    }
31
    */
32
    int n = 7 ;
33
    string s = "The number is " ;
34
    cout << s + m[n] << endl ;
35
    return 0 ;
36
}     
     37
 运行结果：    
                   The number is 7

c.reserve();                同c.resize()

1.List

List将元素按顺序储存在链表中. 与向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却比较慢.

list对象函数

assign() 给list赋值
back() 返回最后一个元素
begin() 返回指向第一个元素的迭代器
clear() 删除所有元素
empty() 如果list是空的则返回true
end() 返回末尾的迭代器
erase() 删除一个元素
front() 返回第一个元素
get_allocator() 返回list的配置器
insert() 插入一个元素到list中
max_size() 返回list能容纳的最大元素数量
merge() 合并两个list
pop_back() 删除最后一个元素
pop_front() 删除第一个元素
push_back() 在list的末尾添加一个元素
push_front() 在list的头部添加一个元素
rbegin() 返回指向第一个元素的逆向迭代器
remove() 从list删除元素
remove_if() 按指定条件删除元素
rend() 指向list末尾的逆向迭代器
resize() 改变list的大小
reverse() 把list的元素倒转
size() 返回list中的元素个数
sort() 给list排序
splice() 合并两个list
swap() 交换两个list
unique() 删除list中重复的元素

#include <iostream>
#include <list>
#include <numeric>
#include <algorithm>

using namespace std;

//创建一个list容器的实例LISTINT
typedef list<int> LISTINT;

//创建一个list容器的实例LISTCHAR
typedef list<char> LISTCHAR;

int main(void)
{
    //--------------------------
    //用list容器处理整型数据
    //--------------------------
    //用LISTINT创建一个名为listOne的list对象
    LISTINT listOne;
    //声明i为迭代器
    LISTINT::iterator i;

    //从前面向listOne容器中添加数据
    listOne.push_front (2);
    listOne.push_front (1);

    //从后面向listOne容器中添加数据
    listOne.push_back (3);
    listOne.push_back (4);

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

    //从后向后显示listOne中的数据
    LISTINT::reverse_iterator ir;
    cout<<"listOne.rbegin()---listOne.rend():"<<endl;
    for (ir =listOne.rbegin(); ir!=listOne.rend();ir++) {
        cout << *ir << " ";
    }
    cout << endl;

    //使用STL的accumulate(累加)算法
    int result = accumulate(listOne.begin(), listOne.end(),0);
    cout<<"Sum="<<result<<endl;
    cout<<"------------------"<<endl;

    //--------------------------
    //用list容器处理字符型数据
    //--------------------------

    //用LISTCHAR创建一个名为listOne的list对象
    LISTCHAR listTwo;
    //声明i为迭代器
    LISTCHAR::iterator j;

    //从前面向listTwo容器中添加数据
    listTwo.push_front ('A');
    listTwo.push_front ('B');

    //从后面向listTwo容器中添加数据
    listTwo.push_back ('x');
    listTwo.push_back ('y');

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

    //使用STL的max_element算法求listTwo中的最大元素并显示
    j=max_element(listTwo.begin(),listTwo.end());
    cout << "The maximum element in listTwo is: "<<char(*j)<<endl;

    return 0;
}
#include <iostream>
#include <list>
#include <numeric>
#include <algorithm>

using namespace std;

//创建一个list容器的实例LISTINT
typedef list<int> LISTINT;

//创建一个list容器的实例LISTCHAR
typedef list<char> LISTCHAR;

int main(void)
{
    //--------------------------
    //用list容器处理整型数据
    //--------------------------
    //用LISTINT创建一个名为listOne的list对象
    LISTINT listOne;
    //声明i为迭代器
    LISTINT::iterator i;

    //从前面向listOne容器中添加数据
    listOne.push_front (2);
    listOne.push_front (1);

    //从后面向listOne容器中添加数据
    listOne.push_back (3);
    listOne.push_back (4);

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

    //从后向后显示listOne中的数据
    LISTINT::reverse_iterator ir;
    cout<<"listOne.rbegin()---listOne.rend():"<<endl;
    for (ir =listOne.rbegin(); ir!=listOne.rend();ir++) {
        cout << *ir << " ";
    }
    cout << endl;

    //使用STL的accumulate(累加)算法
    int result = accumulate(listOne.begin(), listOne.end(),0);
    cout<<"Sum="<<result<<endl;
    cout<<"------------------"<<endl;

    //--------------------------
    //用list容器处理字符型数据
    //--------------------------

    //用LISTCHAR创建一个名为listOne的list对象
    LISTCHAR listTwo;
    //声明i为迭代器
    LISTCHAR::iterator j;

    //从前面向listTwo容器中添加数据
    listTwo.push_front ('A');
    listTwo.push_front ('B');

    //从后面向listTwo容器中添加数据
    listTwo.push_back ('x');
    listTwo.push_back ('y');

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

    //使用STL的max_element算法求listTwo中的最大元素并显示
    j=max_element(listTwo.begin(),listTwo.end());
    cout << "The maximum element in listTwo is: "<<char(*j)<<endl;

    return 0;
}

2.vector相关用法

vector的初始化大小和赋初值
(1)vector< 类型 > 标识符 ;
(2)vector< 类型 > 标识符(最大容量) ；
(3)vector< 类型 > 标识符（最大容量，初始所有值）；
vector< int > arry(5, 1);
注：定义一个大小为5的数组，并将每个值都赋为1；
int i;
for( i = 0; i < 5; i ++ )
cout << arry[i] << " ";
输出结果为：1 1 1 1 1
同理定义其他类型的：
vector<char> arry(3, '*');
定义二维的vector:
vector< vector <int>> Arry（10， vector<int>(0)）;

使用数组对C++ Vector进行初始化

int i[10] ={1,2,3,4,5,6,7,78,8} ;  
 ///第一种   
 vector<int> vi(i+1,i+3); ///从第2个元素到第三个元素  
 for(vector <int>::interator it = vi.begin() ; 
 it != vi.end() ; it++)  
 {  
 cout << *it <<" " ;   
 }

vector附带函数
1.push_back 在数组的最后添加一个数据
2.pop_back 去掉数组的最后一个数据
3.at 得到编号位置的数据
4.begin 得到数组头的指针
5.end 得到数组的最后一个单元+1的指针
6．front 得到数组头的引用
7.back 得到数组的最后一个单元的引用
8.max_size 得到vector最大可以是多大
9.capacity 当前vector分配的大小
10.size 当前使用数据的大小
11.resize 改变当前使用数据的大小，如果它比当前使用的大，者填充默认值
v.resize(2*v.size, 99) 将v的容量翻倍(并把新元素的值初始化为99)
12.reserve 改变当前vecotr所分配空间的大小
13.erase 删除指针指向的数据项
14.clear 清空当前的vector
15.rbegin 将vector反转后的开始指针返回(其实就是原来的end-1)
16.rend 将vector反转构的结束指针返回(其实就是原来的begin-1)
17.empty 判断vector是否为空
18.swap 与另一个vector交换数据

vector 的数据的存入和输出：

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdlib>
using namespace std;
 
int main(void)
{
   vector<int> num;   // STL中的vector容器
   int element;
 
   // 从标准输入设备读入整数， 
   // 直到输入的是非整型数据为止
   while (cin >> element)     //ctrl+Z 结束输入 
      num.push_back(element);
 
   // STL中的排序算法
   sort(vi.begin() , vi.end()); /// 从小到大  
   reverse(vi.begin(),vi.end()) /// 从大道小 
 
 
   // 将排序结果输出到标准输出设备
   for (int i = 0; i < num.size(); i ++)
      cout << num[i] << "\n";
   //也可以这样做
   
      
   system("pause");
   return 0;
}
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdlib>
using namespace std;
 
int main(void)
{
   vector<int> num;   // STL中的vector容器
   int element;
 
   // 从标准输入设备读入整数， 
   // 直到输入的是非整型数据为止
   while (cin >> element)     //ctrl+Z 结束输入 
      num.push_back(element);
 
   // STL中的排序算法
   sort(vi.begin() , vi.end()); /// 从小到大  
   reverse(vi.begin(),vi.end()) /// 从大道小 
 
 
   // 将排序结果输出到标准输出设备
   for (int i = 0; i < num.size(); i ++)
      cout << num[i] << "\n";
   //也可以这样做
   
      
   system("pause");
   return 0;
}

对于二维vector的定义。

1)定义一个10个vector元素，并对每个vector符值1-10。

#include<stdio.h>
#include<vector>
#include <iostream>
using namespace std;
int main()
{
 int i = 0, j = 0;
//定义一个二维的动态数组，有10行，每一行是一个用一个vector存储这一行的数据。
所 以每一行的长度是可以变化的。之所以用到vector<int>(0)是对vector初始化，否则不能对vector存入元素。
 vector< vector<int> > Array( 10, vector<int>(0) ); 
for( j = 0; j < 10; j++ )
 {
  for ( i = 0; i < 9; i++ )
  {
   Array[ j ].push_back( i );
  }
 }
 for( j = 0; j < 10; j++ )
 {
  for( i = 0; i < Array[ j ].size(); i++ )
  {
   cout << Array[ j ][ i ] << "  ";
  }
  cout<< endl;
 }
}
#include<stdio.h>
#include<vector>
#include <iostream>
using namespace std;
int main()
{
 int i = 0, j = 0;
//定义一个二维的动态数组，有10行，每一行是一个用一个vector存储这一行的数据。
所 以每一行的长度是可以变化的。之所以用到vector<int>(0)是对vector初始化，否则不能对vector存入元素。
 vector< vector<int> > Array( 10, vector<int>(0) ); 
for( j = 0; j < 10; j++ )
 {
  for ( i = 0; i < 9; i++ )
  {
   Array[ j ].push_back( i );
  }
 }
 for( j = 0; j < 10; j++ )
 {
  for( i = 0; i < Array[ j ].size(); i++ )
  {
   cout << Array[ j ][ i ] << "  ";
  }
  cout<< endl;
 }
}

定义一个行列都是变化的数组。

#include<stdio.h>
#include<vector>
#include <iostream>
using namespace std;
void main()
{
 int i = 0, j = 0;
 vector< vector<int> > Array;
 vector< int > line;
 for( j = 0; j < 10; j++ )
 {
  Array.push_back( line );//要对每一个vector初始化，否则不能存入元素。
  for ( i = 0; i < 9; i++ )
  {
   Array[ j ].push_back( i );
  }
 }
 for( j = 0; j < 10; j++ )
 {
  for( i = 0; i < Array[ j ].size(); i++ )
  {
   cout << Array[ j ][ i ] << "  ";
  }
  cout<< endl;
#include<stdio.h>
#include<vector>
#include <iostream>
using namespace std;
void main()
{
 int i = 0, j = 0;
 vector< vector<int> > Array;
 vector< int > line;
 for( j = 0; j < 10; j++ )
 {
  Array.push_back( line );//要对每一个vector初始化，否则不能存入元素。
  for ( i = 0; i < 9; i++ )
  {
   Array[ j ].push_back( i );
  }
 }
 for( j = 0; j < 10; j++ )
 {
  for( i = 0; i < Array[ j ].size(); i++ )
  {
   cout << Array[ j ][ i ] << "  ";
  }
  cout<< endl;

使用 vettor erase 指定元素

#include <iostream>
#include <vector>

using namespace std;

int   main()
{
    vector<int>   arr;
    arr.push_back(6);
    arr.push_back(8);
    arr.push_back(3);
    arr.push_back(8);

    for(vector<int>::iterator it=arr.begin(); it!=arr.end(); )
    {
        if(* it == 8)
        {
            it = arr.erase(it);
        }
        else
        {
            ++it;
        }
    }

    cout << "After remove 8:\n";

    for(vector<int>::iterator it = arr.begin(); it < arr.end(); ++it)
    {
        cout << * it << " ";
    }
    cout << endl;
    return 0;
}
#include <iostream>
#include <vector>

using namespace std;

int   main()
{
    vector<int>   arr;
    arr.push_back(6);
    arr.push_back(8);
    arr.push_back(3);
    arr.push_back(8);

    for(vector<int>::iterator it=arr.begin(); it!=arr.end(); )
    {
        if(* it == 8)
        {
            it = arr.erase(it);
        }
        else
        {
            ++it;
        }
    }

    cout << "After remove 8:\n";

    for(vector<int>::iterator it = arr.begin(); it < arr.end(); ++it)
    {
        cout << * it << " ";
    }
    cout << endl;
    return 0;
}

map用法

1、map简介

map是一类关联式容器。它的特点是增加和删除节点对迭代器的影响很小，除了那个操作节点，对其他的节点都没有什么影响。对于迭代器来说，可以修改实值，而不能修改key。

2、map的功能

自动建立Key － value的对应。key 和 value可以是任意你需要的类型。
根据key值快速查找记录，查找的复杂度基本是Log(N)，如果有1000个记录，最多查找10次，1,000,000个记录，最多查找20次。
快速插入Key - Value 记录。
快速删除记录
根据Key 修改value记录。
遍历所有记录。
3、使用map

使用map得包含map类所在的头文件

#include <map> //注意，STL头文件没有扩展名.h

map对象是模板类，需要关键字和存储对象两个模板参数：

std:map<int, string> personnel;

这样就定义了一个用int作为索引,并拥有相关联的指向string的指针.

为了使用方便，可以对模板类进行一下类型定义，

typedef map<int, CString> UDT_MAP_INT_CSTRING;

UDT_MAP_INT_CSTRING enumMap;

4、在map中插入元素

改变map中的条目非常简单，因为map类已经对[]操作符进行了重载

enumMap[1] = "One";

enumMap[2] = "Two";

.....

这样非常直观，但存在一个性能的问题。插入2时,先在enumMap中查找主键为2的项，没发现，然后将一个新的对象插入enumMap，键是2，值是一个空字符串，插入完成后，将字符串赋为"Two"; 该方法会将每个值都赋为缺省值，然后再赋为显示的值，如果元素是类对象，则开销比较大。我们可以用以下方法来避免开销：

enumMap.insert(map<int, CString> :: value_type(2, "Two"))

5、查找并获取map中的元素

下标操作符给出了获得一个值的最简单方法：

CString tmp = enumMap[2];

但是,只有当map中有这个键的实例时才对，否则会自动插入一个实例，值为初始化值。

我们可以使用Find()和Count()方法来发现一个键是否存在。

查找map中是否包含某个关键字条目用find()方法，传入的参数是要查找的key，在这里需要提到的是begin()和end()两个成员，分别代表map对象中第一个条目和最后一个条目，这两个数据的类型是iterator.

int nFindKey = 2; //要查找的Key 
//定义一个条目变量(实际是指针) 
UDT_MAP_INT_CSTRING::iterator it= enumMap.find(nFindKey); 
if(it == enumMap.end()) { 
//没找到 
} 
else { 
//找到 
}

通过map对象的方法获取的iterator数据类型是一个std::pair对象，包括两个数据 iterator->first 和 iterator->second 分别代表关键字和存储的数据

6、从map中删除元素

移除某个map中某个条目用erase()

该成员方法的定义如下

iterator erase(iterator it); //通过一个条目对象删除
iterator erase(iterator first, iterator last); //删除一个范围
size_type erase(const Key& key); //通过关键字删除
clear()就相当于 enumMap.erase(enumMap.begin(), enumMap.end());

C++ STL map的使用

以下是对C++中STL map的插入，查找，遍历及删除的例子：

#include <map> 
#include <string> 
#include <iostream> 
using namespace std;

void map_insert(map < string, string > *mapStudent, string index, string x) 
{ 
mapStudent->insert(map < string, string >::value_type(index, x)); 
}

int main(int argc, char **argv) 
{ 
char tmp[32] = ""; 
map < string, string > mapS;

//insert element 
map_insert(&mapS, "192.168.0.128", "xiong"); 
map_insert(&mapS, "192.168.200.3", "feng"); 
map_insert(&mapS, "192.168.200.33", "xiongfeng");

map < string, string >::iterator iter;

cout << "We Have Third Element:" << endl; 
cout << "-----------------------------" << endl;

//find element 
iter = mapS.find("192.168.0.33"); 
if (iter != mapS.end()) { 
cout << "find the elememt" << endl; 
cout << "It is:" << iter->second << endl; 
} else { 
cout << "not find the element" << endl; 
}

//see element 
for (iter = mapS.begin(); iter != mapS.end(); iter ) {

cout << "| " << iter->first << " | " << iter-> 
second << " |" << endl;

} 
cout << "-----------------------------" << endl;

map_insert(&mapS, "192.168.30.23", "xf");

cout << "After We Insert One Element:" << endl; 
cout << "-----------------------------" << endl; 
for (iter = mapS.begin(); iter != mapS.end(); iter ) {

cout << "| " << iter->first << " | " << iter-> 
second << " |" << endl; 
}

cout << "-----------------------------" << endl;

//delete element 
iter = mapS.find("192.168.200.33"); 
if (iter != mapS.end()) { 
cout << "find the element:" << iter->first << endl; 
cout << "delete element:" << iter->first << endl; 
cout << "=================================" << endl; 
mapS.erase(iter); 
} else { 
cout << "not find the element" << endl; 
} 
for (iter = mapS.begin(); iter != mapS.end(); iter ) {

cout << "| " << iter->first << " | " << iter-> 
second << " |" << endl;

} 
cout << "=================================" << endl;

return 0; 
}
#include <map> 
#include <string> 
#include <iostream> 
using namespace std;

void map_insert(map < string, string > *mapStudent, string index, string x) 
{ 
mapStudent->insert(map < string, string >::value_type(index, x)); 
}

int main(int argc, char **argv) 
{ 
char tmp[32] = ""; 
map < string, string > mapS;

//insert element 
map_insert(&mapS, "192.168.0.128", "xiong"); 
map_insert(&mapS, "192.168.200.3", "feng"); 
map_insert(&mapS, "192.168.200.33", "xiongfeng");

map < string, string >::iterator iter;

cout << "We Have Third Element:" << endl; 
cout << "-----------------------------" << endl;

//find element 
iter = mapS.find("192.168.0.33"); 
if (iter != mapS.end()) { 
cout << "find the elememt" << endl; 
cout << "It is:" << iter->second << endl; 
} else { 
cout << "not find the element" << endl; 
}

//see element 
for (iter = mapS.begin(); iter != mapS.end(); iter ) {

cout << "| " << iter->first << " | " << iter-> 
second << " |" << endl;

} 
cout << "-----------------------------" << endl;

map_insert(&mapS, "192.168.30.23", "xf");

cout << "After We Insert One Element:" << endl; 
cout << "-----------------------------" << endl; 
for (iter = mapS.begin(); iter != mapS.end(); iter ) {

cout << "| " << iter->first << " | " << iter-> 
second << " |" << endl; 
}

cout << "-----------------------------" << endl;

//delete element 
iter = mapS.find("192.168.200.33"); 
if (iter != mapS.end()) { 
cout << "find the element:" << iter->first << endl; 
cout << "delete element:" << iter->first << endl; 
cout << "=================================" << endl; 
mapS.erase(iter); 
} else { 
cout << "not find the element" << endl; 
} 
for (iter = mapS.begin(); iter != mapS.end(); iter ) {

cout << "| " << iter->first << " | " << iter-> 
second << " |" << endl;

} 
cout << "=================================" << endl;

return 0; 
}

本文参考：

http://blog.sina.com.cn/s/blog_63a1163f0100jxr9.html

http://wmnmtm.blog.163.com/blog/static/38245714201072310131130/

//              

               ///author:Jeson Yang              

               ///Date:2014.9.15              

               //              

               #include <vector>              

               #include <list>              

               #include <iostream>              

               #include <map>              

               using namespace std;              

                              

               int                _tmain(               int               argc, _TCHAR* argv[])              

               {              

                              //              

                              //vector              

                              vector<               int               > *vecInteger =                new               vector<               int               >();              

                              int               num[               10               ] = {               1               ,               2               ,               3               ,               4               ,               5               ,               6               ,               7               ,               8               ,               9               ,               10               };              

                              

                              vecInteger->push_back(num[               0               ]);              

                              vecInteger->push_back(num[               1               ]);              

                              

                              std::cout<<               "iterator use way"               <<endl; (vector<               int               =               ""               for               =               ""               >::iterator it = vecInteger->begin(); it != vecInteger->end(); ++it)              

                              {              

                              std::cout<<*it<<endl;                for               =               ""               vecinteger-=               ""                <=               ""               i=               "0;"               (               int               =               ""               i               "<<endl;="               " int="               " cout<<"               for               =               ""               }=               ""               >size(); i++)              

                              {              

                              cout<<*(vecInteger->begin() + i)<<endl; vecinteger-=               ""               }=               ""                cout<<(*vecinteger)[i]<<endl;=               ""               >pop_back();              

                              vecInteger->clear();              

                              

                              vecInteger->clear();              

                              delete vecInteger;              

                              

                              //              

                              //map              

                              map<               int               ,                int               =               ""               > *mapInteger =                new               map<               int               ,                int               =               ""               >();              

                              mapInteger->insert(pair<               int               ,                int               =               ""               >(                1               , num[               0               ]));              

                              mapInteger->insert(pair<               int               ,                int               =               ""               >(               2               , num[               1               ]));              

                              mapInteger->insert(map<               int               ,                int               =               ""               >::value_type(               3               , num[               2               ]));              

                              

                              for               (map<               int               ,                int               =               ""               >::iterator it = mapInteger->begin(); it != mapInteger->end(); it++)              

                              {              

                              cout<<               "it->first = "               <<it->first <<                "it->second = "                <<it->second<<endl;                for               =               ""               <=               ""                i=               "0;"               (               int               =               ""               }=               ""                mapinteger-=               ""               >size(); i++)              

                              {              

                              cout<<(&mapInteger)[i]<<endl;                int               =               ""               }=               ""                map<               int               ,=               ""               >::iterator iter = mapInteger->find(               1               );                

                              if               (iter != mapInteger->end())                

                              {                

                              cout<<               "Find, the value is "               <<iter->second<<endl; }=               ""               mapinteger-=               ""                find               "<<endl;="               " not="               " cout<<"               do               =               ""               {=               ""                else               =               ""               >clear();              

                              delete mapInteger;              

                              

                              //              

                              //list              

                              list<               int               > *listInteger =                new               list<               int               >();              

                              listInteger->push_back(num[               0               ]);              

                              listInteger->push_back(num[               1               ]);              

                              listInteger->push_front(num[               2               ]);              

                              

                              //list不要插入两个相同的元素,否则根据insert的描述可能出现问题               

                              //listInteger->insert()              

                              

                              for               (list<               int               >::iterator it = listInteger->begin(); it != listInteger->end(); it++)              

                              {              

                              cout<<*it<<endl; }=               ""               reinterpret_cast<list<               int               =               ""               >::iterator>();              

                              for               (               int                i =                0               ; i < listInteger->size(); i++)              

                              {              

                              //cout<<*(listInteger->begin() + i)<<endl; }="" listinteger-="">pop_back();              

                              listInteger->pop_front();              

                              listInteger->remove(num[               1               ]);              

                              

                              listInteger->clear();              

                              delete listInteger;              

                              return               0               ;              

               }              

                              

                              

               </endl;></endl;></               int               ></               int               ></               int               ></endl;></iter-></endl;></endl;></it-></it-></               int               ,></               int               ,></               int               ,></               int               ,></               int               ,></               int               ,></endl;></endl;></endl;></               int               ></               int               ></map></iostream></list></vector>

一步一步认识C++STL中的迭代器