C++ STL之容器先容（vector、list、set、map）

1 STL基本概念

• C++有两大思想，面向对象和泛型编程。
  
• 泛型编程指编写代码时不必指定具体的数据范例，而是利用模板来代替现实范例，如许编写的函数或类可以在之后应用于各种数据范例。而STL就是C++泛型编程的一个杰出例子。
  
• STL（Standard Template Library）即标准模板库。STL通过利用模板实现了容器和算法的分离，允许程序员编写与范例无关的代码，这正是泛型编程的核心思想。
  

2 STL六大组件

• STL分为六大组件，分别是容器、算法、迭代器、仿函数、适配器和空间配置器。
  
• 容器：各种数据结构，主要用来存放数据。如vector、list、map等。
  
• 算法：各种常见的算法，用来处理惩罚元素。如sort、find、copy、for_each等。
  
• 迭代器：毗连容器和算法的桥梁
  
• 仿函数：行为类似函数，可作为算法的某种策略
  
• 适配器：一种用来修饰容器大概仿函数或迭代器接口的东西
  
• 空间配置器：负责空间的配置与管理
  

3 容器概述

• 容器分为序列式容器和关联式容器
  
• 序列式容器：有序集合，其内的每个元素均有确凿的位置 - 取决于插入时机和地点，与元素值无关。主要有vector、deque、list和forward_list。
  
• 关联式容器：已排序集合，元素位置取决于其value（或key）和给定的某个排序准则。主要有set、multiset、map、multimap。
  
•    范例容器迭代器特点序列容器vector - 动态数组迭代器支持随机访问
  插入元素可能导致全部迭代器失效
  删除元素会使指向被删除元素及之后元素的迭代器失效支持快速随机访问
  但在末尾以外位置插入或删除元素效率较低deque - 双端队列迭代器支持随机访问
  插入和删除元素都可能导致迭代器失效两端都可以高效地举行插入和删除操作
  随机访问效率没有vector高list - 双向链表迭代器不支持随机访问
  插入新元素不会使现有迭代器失效
  删除元素只会使指向被删除元素的迭代器失效支持高效的中心插入和删除操作，但访问速率较慢关联容器set/multiset插入元素不会使迭代器失效
  删除元素只会使指向被删除元素的迭代器失效查找、插入和删除操作的时间复杂度为 O(log n)。map/multimap 插入元素不会使迭代器失效
  删除元素只会使指向被删除元素的迭代器失效查找、插入和删除操作的时间复杂度为 O(log n)。容器适配器stack - 栈无迭代器先辈后出的数据结构queue - 队列无迭代器先辈先出的数据结构
  

4 vector

• vector是动态数组。动态扩展时，会将原数据拷贝到一块新的内存中，再释放原内存空间。
  
• vector迭代器支持随机访问，即可以举行+2，+3，+n操作。不支持随机访问的迭代器只能举行++操作。
  
• 结构图示
  
  
  
  • 
    
    
  
  

4.1 vector构造

• vector<T> v：默认构造
  
• vector(v.begin(), v.end())：将[begin, end)区间的元素拷贝给自己
  
• vector(n, elem)：将n个elem元素拷贝给自己
  
• vector(const vector &vec)：拷贝构造
  
• vector构造示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <vector>
    4.   
    5.   int main() {
    6.           // 默认构造
    7.           std::vector<int> v1;
    8.   
    9.           // 插入数据
    10.           v1.push_back(10);
    11.           v1.push_back(20);
    12.           v1.push_back(30);
    13.           v1.push_back(40);
    14.           v1.push_back(50);
    15.   
    16.           // 通过区间方式构造
    17.           std::vector<int> v2(v1.begin(), v1.end());
    18.   
    19.           // 构造时放入5个100
    20.           std::vector<int> v3(10, 100);
    21.   
    22.           // 拷贝构造
    23.           std::vector<int> v4(v3);
    24.   
    25.           system("pause");
    26.           return 0;
    27.   }

    复制代码
  
  

4.2 vector赋值

• vector& operator=(const vector &vec)
  
• assign(beg, end)：将[beg, end)区间的元素赋值给自己
  
• assign(n, elem)：将n个elem元素赋值给自己
  
• vector赋值示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <vector>
    4.   
    5.   int main() {
    6.           // 默认构造
    7.           std::vector<int> v1;
    8.   
    9.           // 插入数据
    10.           v1.push_back(10);
    11.           v1.push_back(20);
    12.           v1.push_back(30);
    13.           v1.push_back(40);
    14.           v1.push_back(50);
    15.   
    16.           // 通过=赋值
    17.           std::vector<int> v2;
    18.           v2 = v1;
    19.   
    20.           // 通过assign赋值一个区间的值
    21.           std::vector<int> v3;
    22.           v3.assign(v1.begin(), v1.end());
    23.   
    24.           // 通过assign赋值5个100
    25.           std::vector<int> v4;
    26.           v4.assign(5, 100);
    27.   
    28.           system("pause");
    29.           return 0;
    30.   }

    复制代码
  
  

4.3 vector容量和大小

• empty(): 判断容器是否为空
  
• capacity(): 容器的容量
  
• size(): 容器中元素个数
  
• resize(int num): 重新指定容器的长度为num，若容器变长，则以默认值填充新位置。若容器变短，则末尾超出长度的元素被删除。
  
• resize(int num, const value_type& value): 同上，只不外在容器变长时以value填充新位置。
  
• void reserve(int len): 容器预留len长度的空间，预留位置不初始化，元素不可访问。预留容器的空间可以镌汰vector在动态扩展时的扩展次数。
  

4.4 vector插入和删除

• push_back(elem): 尾部插入元素。
  
• pop_back(): 删除尾部元素。
  
• iterator insert(pos, elem): 迭代器指向位置pos处插入元素elem，返回新元素的位置。
  
• iterator insert(pos, count, elem): 迭代器实行位置pos处插入count个元素elem，返回新元素的位置。
  
• iterator erase(pos): 删除迭代器pos指向的元素，返回下一个数据的位置。
  
• iterator erase(first, last): 删除迭代器从first带last之间的元素，返回下一个数据的位置。
  
• clear(): 删除容器中全部元素。
  
• 插入删除示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <vector>
    4.   #include <algorithm>
    5.   
    6.   void printVector(std::vector<int>& vec) {
    7.           // 遍历数据
    8.           std::cout << "vector: ";
    9.           for (std::vector<int>::iterator iter = vec.begin(); iter != vec.end(); iter++) {
    10.                   std::cout << *iter << " ";
    11.           }
    12.           std::cout << std::endl;
    13.   }
    14.   
    15.   
    16.   int main() {
    17.           std::vector<int> v;
    18.   
    19.           // 插入数据
    20.           v.push_back(10);
    21.           v.push_back(20);
    22.           v.push_back(30);
    23.           v.push_back(40);
    24.           printVector(v);
    25.   
    26.           v.pop_back();
    27.           printVector(v);
    28.   
    29.           v.insert(v.begin(), 1024);
    30.           printVector(v);
    31.   
    32.           v.insert(v.begin(), 2, 520);
    33.           printVector(v);
    34.   
    35.           // 删除
    36.           v.erase(v.begin());
    37.           printVector(v);
    38.   
    39.   
    40.           system("pause");
    41.           return 0;
    42.   }

    复制代码
  
  
• 打印效果
  
  
  
  • 1.   vector: 10 20 30 40
    2.   vector: 10 20 30
    3.   vector: 1024 10 20 30
    4.   vector: 520 520 1024 10 20 30
    5.   vector: 520 1024 10 20 30
    6.   请按任意键继续. . .

    复制代码
  
  
• vector插入自界说数据范例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <vector>
    4.   #include <algorithm>
    5.   
    6.   class Person {
    7.   public:
    8.           Person(int code, std::string name) {
    9.                   mCode = code;
    10.                   mName = name;
    11.           }
    12.   
    13.           int mCode;
    14.           std::string mName;
    15.   };
    16.   
    17.   void vPrint(Person data) {
    18.           std::cout << "code: " << data.mCode << std::endl;
    19.           std::cout << "name: " << data.mName << std::endl;
    20.   }
    21.   
    22.   int main() {
    23.           Person p1(10010, "Tom");
    24.           Person p2(10020, "Jack");
    25.           Person p3(10030, "Lucy");
    26.           Person p4(10040, "Mary");
    27.   
    28.   
    29.           std::vector<Person> v;
    30.   
    31.           // 插入数据
    32.           v.push_back(p1);
    33.           v.push_back(p2);
    34.           v.push_back(p3);
    35.           v.push_back(p4);
    36.   
    37.           // 通过迭代器遍历数据
    38.           for (std::vector<Person>::iterator iter = v.begin(); iter != v.end(); iter++) {
    39.                   std::cout << "code " << (*iter).mCode << std::endl;
    40.                   std::cout << "name " << (*iter).mName << std::endl;
    41.           }
    42.   
    43.           // 通过算法遍历
    44.           std::for_each(v.begin(), v.end(), vPrint);
    45.          
    46.           system("pause");
    47.           return 0;
    48.   }

    复制代码
  
  

4.5 vector数据存取

• at( size_type pos ): 返回索引pos处的数据
  
• operator[]( size_type pos ): 返回索引pos处的数据
  
• front(): 返回容器中第一个元素
  
• back(): 返回容器中最后一个元素
  
• 数据存储示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <vector>
    4.   
    5.   void printVector(std::vector<int>& vec) {
    6.           // 遍历数据
    7.           std::cout << "vector[]: ";
    8.           for (int i = 0; i < vec.size(); i++) {
    9.                   std::cout << vec[i] << " ";
    10.           }
    11.           std::cout << std::endl;
    12.   
    13.           std::cout << "vector at: ";
    14.           for (int i = 0; i < vec.size(); i++) {
    15.                   std::cout << vec.at(i) << " ";
    16.           }
    17.           std::cout << std::endl;
    18.   }
    19.   
    20.   
    21.   int main() {
    22.           std::vector<int> v;
    23.   
    24.           // 插入数据
    25.           v.push_back(10);
    26.           v.push_back(20);
    27.           v.push_back(30);
    28.           v.push_back(40);
    29.           printVector(v);
    30.   
    31.           system("pause");
    32.           return 0;
    33.   }

    复制代码
  
  

4.6 通过swap缩小容器容量

• void swap( vector& other ): 交换两个容器中的元素。常用的一个场景是缩小容器容量
  
• 示比方下
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <vector>
    4.   
    5.   int main() {
    6.           // 默认构造
    7.           std::vector<int> v1;
    8.   
    9.           // 插入50万个数据
    10.           for (int i = 0; i < 500000; i++) {
    11.                   v1.push_back(i);
    12.           }
    13.          
    14.           // 容器中元素为50万，容器容量可能为70万
    15.           std::cout << "v1.size: " << v1.size() << std::endl;
    16.           std::cout << "v1.cap: " << v1.capacity() << std::endl;
    17.   
    18.           // 后续如果要删除元素，比如只剩下3个元素了
    19.           // 此时容器元素个数为3，但容器容量依然是70万，造成资源浪费
    20.           v1.resize(3);
    21.           std::cout << "v1.size: " << v1.size() << std::endl;
    22.           std::cout << "v1.cap: " << v1.capacity() << std::endl;
    23.   
    24.           // 通过匿名对象交换容器
    25.           // 匿名对象中的元素会被系统自动回收
    26.           std::vector<int>(v1).swap(v1);
    27.   
    28.           // v1此时的元素个数和容量都为3
    29.           std::cout << "v1.size: " << v1.size() << std::endl;
    30.           std::cout << "v1.cap: " << v1.capacity() << std::endl;
    31.   
    32.           system("pause");
    33.           return 0;
    34.   }

    复制代码
  
  

5 deque

• deque是双端队列，可以在头部举行插入删除操作
  
• vector对于头部的插入删除效率低，数据量越大，效率越低。deque对头部的插入删除速率比vector快。vector访问元素的速率比deque快。
  
• deque容器的迭代器支持随机访问。
  
• 结构图示
  
  
  
  • 
    
    
  
  
• deque工作原理：deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据。中控器维护的是每段缓冲区的地址。图示如下
  
  
  
  • 
    
    
  
  
• deque的构造、赋值、遍历、数据存取和vector基本类似，这里就不再先容。
  

5.1 deque容量和大小

• empty()：判断容器是否为空。
  
• size()：返回容器中元素个数。
  
• resize(num)：重新指定容器的长度为num。若容器变长，则以默认值填充新位置。若容器变短，则末尾超出容器长度的元素被删除。
  
• resize(num, elem)：同上，重新指定容器长度为num，容器变长则以elem填充。
  

5.2 deque插入和删除

• push_back(elem)：容器尾部插入数据。
  
• push_front(elem)：容器头部插入数据。
  
• pop_back()：删除容器尾部最后一个数据。
  
• pop_front()：删除容器头部第一个容器。
  
• iterator intsert(pos, elem)：在pos位置插入一个elem数据，返回新数据的位置。
  
• iterator intsert(pos, n, elem)：在pos位置插入n个elem数据，返回新数据的位置。
  
• iterator intsert(pos, beg, end)：在pos位置插入[beg, end)区间的数据，返回新数据的位置。
  
• clear()：清空容器的全部数据。
  
• iterator erase(beg, end)：删除[beg, end)区间的数据，返回下一个数据的位置。
  
• iterator erase(pos)：删除pos位置的数据，返回下一个数据的位置。
  
• 代码示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <deque>
    4.   
    5.   void printDeque(std::deque<int> & de) {
    6.           std::cout << "deque: ";
    7.           for (std::deque<int>::iterator iter = de.begin(); iter != de.end(); iter++) {
    8.                   std::cout << *iter << " ";
    9.           }
    10.           std::cout << std::endl;
    11.   }
    12.   
    13.   int main() {
    14.           // 默认构造
    15.           std::deque<int> d1;
    16.   
    17.           // 尾部插入
    18.           d1.push_back(10);
    19.           d1.push_back(20);
    20.           d1.push_back(30);
    21.           printDeque(d1);
    22.   
    23.           // 头部插入
    24.           d1.push_front(40);
    25.           d1.push_front(50);
    26.           d1.push_front(60);
    27.           printDeque(d1);
    28.   
    29.           // 删除尾部元素
    30.           d1.pop_back();
    31.           printDeque(d1);
    32.   
    33.           // 删除头部元素
    34.           d1.pop_front();
    35.           printDeque(d1);
    36.   
    37.           // insert插入
    38.           std::deque<int>::iterator iter1 = d1.insert(d1.begin(), 1024);
    39.           printDeque(d1);
    40.           std::cout << "*iter1: " << *iter1 << std::endl;
    41.   
    42.           // insert插入多个元素
    43.           std::deque<int>::iterator iter2 = d1.insert(d1.begin(), 2, 256);
    44.           printDeque(d1);
    45.           std::cout << "*iter2: " << *iter2 << std::endl;
    46.   
    47.           std::deque<int> d2;
    48.           d2.push_back(1);
    49.           d2.push_back(2);
    50.           d2.push_back(3);
    51.   
    52.           // insert 区间插入
    53.           std::deque<int>::iterator iter3 = d1.insert(d1.begin(), d2.begin(), d2.end());
    54.           printDeque(d1);
    55.           std::cout << "*iter3: " << *iter3 << std::endl;
    56.   
    57.           // 删除指定位置元素
    58.           std::deque<int>::iterator iter4 = d1.begin();
    59.           iter4++;
    60.           std::deque<int>::iterator iter5 = d1.erase(iter4);
    61.           printDeque(d1);
    62.           std::cout << "*iter5: " << *iter5 << std::endl;
    63.   
    64.           // 删除所有元素
    65.           d1.clear();
    66.   
    67.           system("pause");
    68.           return 0;
    69.   }

    复制代码
  
  
• 打印效果
  
  
  
  • 1.   deque: 10 20 30
    2.   deque: 60 50 40 10 20 30
    3.   deque: 60 50 40 10 20
    4.   deque: 50 40 10 20
    5.   deque: 1024 50 40 10 20
    6.   *iter1: 1024
    7.   deque: 256 256 1024 50 40 10 20
    8.   *iter2: 256
    9.   deque: 1 2 3 256 256 1024 50 40 10 20
    10.   *iter3: 1
    11.   deque: 1 3 256 256 1024 50 40 10 20
    12.   *iter5: 3
    13.   请按任意键继续. . .

    复制代码
  
  

5.3 deque排序

• sort(iterator beg, iterator end)：对beg和end区间内元素举行排序
  
• 迭代器支持随机访问的容器都可以利用sort举行排序
  
• 代码示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <deque>
    4.   #include <algorithm>
    5.   
    6.   void printDeque(std::deque<int> & de) {
    7.           std::cout << "deque: ";
    8.           for (std::deque<int>::iterator iter = de.begin(); iter != de.end(); iter++) {
    9.                   std::cout << *iter << " ";
    10.           }
    11.           std::cout << std::endl;
    12.   }
    13.   
    14.   int main() {
    15.           // 默认构造
    16.           std::deque<int> d1;
    17.   
    18.           // 尾部插入
    19.           d1.push_back(10);
    20.           d1.push_back(900);
    21.           d1.push_back(23);
    22.           d1.push_back(250);
    23.           d1.push_back(18);
    24.           printDeque(d1);
    25.   
    26.           sort(d1.begin(), d1.end());
    27.           printDeque(d1);
    28.   
    29.           system("pause");
    30.           return 0;
    31.   }

    复制代码
  
  
• 效果打印
  
  
  
  • 1.   deque: 10 900 23 250 18
    2.   deque: 10 18 23 250 900
    3.   请按任意键继续. . .

    复制代码
  
  

6 stack

• stack是栈，一种先辈后出的数据结构，只有一个出口。
  
• 栈中只有顶端元素才可以被外部利用，因此栈没有遍历操作。
  
• 结构图示
  
  
  
  • 
    
    
  
  

6.1 stack赋值操作

• stack& operator=(const stack &stk)
  

6.2 stack数据存取

• push(elem)：向栈顶添加元素（入栈）。
  
• pop()：从栈顶移除元素（出栈）。
  
• top()：返回栈顶元素。
  

6.3 stack 大小操作

• empty()：判断栈是否为空。
  
• size()：返回栈大小。
  
• 利用示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <stack>
    4.   
    5.   int main() {
    6.           // 默认构造
    7.           std::stack<int> st1;
    8.   
    9.           // 入栈
    10.           st1.push(10);
    11.           st1.push(20);
    12.           st1.push(30);
    13.           st1.push(40);
    14.   
    15.           // 获取栈顶元素
    16.           std::cout << "stack top: " << st1.top() << std::endl;
    17.           std::cout << "stack size: " << st1.size() << std::endl;
    18.   
    19.           while (!st1.empty()) {
    20.                   std::cout << "stack top: " << st1.top() << std::endl;
    21.   
    22.                   // 出栈
    23.                   st1.pop();
    24.           }
    25.   
    26.           std::cout << "stack size: " << st1.size() << std::endl;
    27.   
    28.   
    29.           system("pause");
    30.           return 0;
    31.   }

    复制代码
  
  
• 打印效果
  
  
  
  • 1.   stack top: 40
    2.   stack size: 4
    3.   stack top: 40
    4.   stack top: 30
    5.   stack top: 20
    6.   stack top: 10
    7.   stack size: 0
    8.   请按任意键继续. . .

    复制代码
  
  

7 queue

• queue是队列，一种先辈先出的数据结构。
  
• 队列允许从一端新增元素，另一端移除元素。队列中只有队头和队尾才可以被外部利用，因此队列不允许有遍历行为。
  
• 结构图示
  
  
  
  • 
    
    
  
  

7.1 queue构造

• queue<T> que：默认构造。
  
• queue(const queue &que)：拷贝构造。
  

7.2 queue赋值

• queue& operator=(const queue &que)
  

7.3 queue数据存取

• push(elem)：队尾添加元素（入队）。
  
• pop()：移除队头元素（出队）。
  
• back()：返回队尾元素。
  
• front()：返回队头元素。
  

7.4 queue大小操作

• empty()：判断队列是否为空。
  
• size()：返回队列大小。
  
• 利用示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <queue>
    4.   
    5.   int main() {
    6.           // 默认构造
    7.           std::queue<int> que1;
    8.   
    9.           // 入队
    10.           que1.push(10);
    11.           que1.push(20);
    12.           que1.push(30);
    13.           que1.push(40);
    14.   
    15.           std::cout << "size: " << que1.size() << std::endl;
    16.           while (!que1.empty()) {
    17.                   // 查看队头和队尾元素
    18.                   std::cout << "front: " << que1.front()  << ", back: "<< que1.back() << std::endl;
    19.   
    20.                   // 出队
    21.                   que1.pop();
    22.           }
    23.           std::cout << "size: " << que1.size() << std::endl;
    24.   
    25.   
    26.           system("pause");
    27.           return 0;
    28.   }

    复制代码
  
  
• 打印效果
  
  
  
  • 1.   size: 4
    2.   front: 10, back: 40
    3.   front: 20, back: 40
    4.   front: 30, back: 40
    5.   front: 40, back: 40
    6.   size: 0
    7.   请按任意键继续. . .

    复制代码
  
  

8 list

• list是链表，一种物理存储单元上非连续的存储结构。list可以在恣意位置举行快速插入和删除元素，但遍历速率没有vector快。list的迭代器属于双向迭代器。
  
• list插入和删除都不会造成原有list迭代器的失效。list的迭代器不支持随机访问。
  
• STL中的链表是一个双向循环链表。
  
• 结构图示
  
  
  
  • 
    
    
  
  

8.1 list构造

• list<T> lst：默认构造
  
• list(begin, end)：将[begin, end)区间的元素拷贝给自己
  
• list(n, elem)：将n个elem元素拷贝给自己
  
• list(const list &lst)：拷贝构造。
  
• 利用示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <list>
    4.   
    5.   void printList(std::list<int>& lst) {
    6.           std::cout << "list: ";
    7.           for (std::list<int>::iterator iter = lst.begin(); iter != lst.end(); iter++) {
    8.                   std::cout << *iter << " ";
    9.           }
    10.           std::cout << std::endl;
    11.   }
    12.   
    13.   int main() {
    14.           // 默认构造
    15.           std::list<int> lst1;
    16.   
    17.           // 添加数据
    18.           lst1.push_back(10);
    19.           lst1.push_back(20);
    20.           lst1.push_back(30);
    21.           lst1.push_back(40);
    22.   
    23.           printList(lst1);
    24.   
    25.           // 区间方式构造
    26.           std::list<int> lst2(lst1.begin(), lst1.end());
    27.           printList(lst2);
    28.   
    29.           // 拷贝构造
    30.           std::list<int> lst3(lst2);
    31.           printList(lst3);
    32.   
    33.           std::list<int> lst4(5, 10);
    34.           printList(lst4);
    35.   
    36.           system("pause");
    37.           return 0;
    38.   }

    复制代码
  
  
• 打印效果
  
  
  
  • 1.   list: 10 20 30 40
    2.   list: 10 20 30 40
    3.   list: 10 20 30 40
    4.   list: 10 10 10 10 10
    5.   请按任意键继续. . .

    复制代码
  
  

8.2 list赋值和交换

• assign(beg, end)：将[beg, end)区间的数据拷贝给自己。
  
• assign(n, elem)：将n个elem元素拷贝给自己。
  
• list& operator=(const list &lst)
  
• swap(lst)：将lst元素与自己元素互换。
  
• 利用示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <list>
    4.   
    5.   void printList(std::list<int>& lst) {
    6.           std::cout << "list: ";
    7.           for (std::list<int>::iterator iter = lst.begin(); iter != lst.end(); iter++) {
    8.                   std::cout << *iter << " ";
    9.           }
    10.           std::cout << std::endl;
    11.   }
    12.   
    13.   int main() {
    14.           // 默认构造
    15.           std::list<int> lst1;
    16.   
    17.           // 添加数据
    18.           lst1.push_back(10);
    19.           lst1.push_back(20);
    20.           lst1.push_back(30);
    21.           lst1.push_back(40);
    22.   
    23.           printList(lst1);
    24.   
    25.           // 赋值
    26.           std::list<int> lst2;
    27.           lst2 = lst1;
    28.           printList(lst2);
    29.   
    30.           std::list<int> lst3;
    31.           lst3.assign(lst1.begin(), lst1.end());
    32.           printList(lst3);
    33.   
    34.           std::list<int> lst4;
    35.           lst4.assign(5, 10);
    36.           printList(lst4);
    37.   
    38.           // 交换
    39.           std::list<int> lst5;
    40.   
    41.           // 添加数据
    42.           lst5.push_back(100);
    43.           lst5.push_back(200);
    44.           lst5.push_back(300);
    45.           lst5.push_back(400);
    46.   
    47.           std::cout << "交换前" << std::endl;
    48.           printList(lst1);
    49.           printList(lst5);
    50.           lst1.swap(lst5);
    51.           std::cout << "交换前" << std::endl;
    52.           printList(lst1);
    53.           printList(lst5);
    54.   
    55.   
    56.           system("pause");
    57.           return 0;
    58.   }

    复制代码
  
  
• 打印效果
  
  
  
  • 1.   list: 10 20 30 40
    2.   list: 10 20 30 40
    3.   list: 10 20 30 40
    4.   list: 10 10 10 10 10
    5.   交换前
    6.   list: 10 20 30 40
    7.   list: 100 200 300 400
    8.   交换前
    9.   list: 100 200 300 400
    10.   list: 10 20 30 40
    11.   请按任意键继续. . .

    复制代码
  
  

8.3 list容量和大小

• empty()：判断容器是否为空。
  
• size()：返回容器中元素个数。
  
• resize(num)：重新指定容器的长度为num。若容器变长，则以默认值填充新位置。若容器变短，则末尾超出容器长度的元素被删除。
  
• resize(num, elem)：同上，重新指定容器长度为num，容器变长则以elem填充。
  

8.4 list插入和删除

• push_back(elem)：容器尾部插入一个元素elem
  
• pop_back()：删除容器中最后一个元素
  
• push_front(elem)：在容器头部插入一个元素
  
• pop_front()：移除容器头部的一个元素
  
• insert(pos, elem)：在pos位置插入elem元素，返回新元素的位置
  
• insert(pos, n, elem)：在pos位置插入n个elem元素，返回新元素的位置
  
• insert(pos, beg, end)：在pos位置插入[beg, end)区间的元素，返回新元素的位置
  
• clear()：移除容器中全部元素
  
• erese(beg, end)：删除[beg, end)区间的元素，返回下一个元素的位置
  
• erese(pos)：删除pos位置处的元素，返回下一个元素的位置
  
• remove(elem)：删除容器中全部与elem值匹配的元素
  
• 利用示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <list>
    4.   
    5.   void printList(std::list<int>& lst) {
    6.           std::cout << "list: ";
    7.           for (std::list<int>::iterator iter = lst.begin(); iter != lst.end(); iter++) {
    8.                   std::cout << *iter << " ";
    9.           }
    10.           std::cout << std::endl;
    11.   }
    12.   
    13.   int main() {
    14.           // 默认构造
    15.           std::list<int> lst1;
    16.   
    17.           // 尾部添加数据
    18.           lst1.push_back(10);
    19.           lst1.push_back(20);
    20.           lst1.push_back(30);
    21.           lst1.push_back(40);
    22.   
    23.           // 头部添加元素
    24.           lst1.push_front(50);
    25.           lst1.push_front(60);
    26.   
    27.           printList(lst1);
    28.   
    29.           // 尾部删除
    30.           lst1.pop_back();
    31.   
    32.           // 头部删除
    33.           lst1.pop_front();
    34.   
    35.           printList(lst1);
    36.   
    37.           std::list<int>::iterator iter;
    38.           // insert插入
    39.           iter = lst1.begin();
    40.           iter++;
    41.           lst1.insert(iter, 1024);
    42.           printList(lst1);
    43.   
    44.           // 删除
    45.           iter = lst1.begin();
    46.           lst1.erase(iter);
    47.           printList(lst1);
    48.   
    49.           // 移除
    50.           lst1.push_back(30);
    51.           lst1.push_back(30);
    52.           lst1.remove(30);
    53.           printList(lst1);
    54.   
    55.           system("pause");
    56.           return 0;
    57.   }

    复制代码
  
  
• 打印效果
  
  
  
  • 1.   list: 60 50 10 20 30 40
    2.   list: 50 10 20 30
    3.   list: 50 1024 10 20 30
    4.   list: 1024 10 20 30
    5.   list: 1024 10 20
    6.   请按任意键继续. . .

    复制代码
  
  

8.5 list数据存取

• front()：返回容器中第一个元素
  
• back()：返回容器中最后一个元素
  

8.6 list反转和排序

• reverse()：反转链表
  
• sort()：链表排序
  
• 利用示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <list>
    4.   
    5.   void printList(std::list<int>& lst) {
    6.           std::cout << "list: ";
    7.           for (std::list<int>::iterator iter = lst.begin(); iter != lst.end(); iter++) {
    8.                   std::cout << *iter << " ";
    9.           }
    10.           std::cout << std::endl;
    11.   }
    12.   
    13.   bool myCompare(int data1, int data2) {
    14.           // 设置降序
    15.           return data1 > data2;
    16.   }
    17.   
    18.   int main() {
    19.           // 默认构造
    20.           std::list<int> lst1;
    21.   
    22.           // 尾部添加数据
    23.           lst1.push_back(10);
    24.           lst1.push_back(200);
    25.           lst1.push_back(54);
    26.           lst1.push_back(1024);
    27.           lst1.push_back(521);
    28.           printList(lst1);
    29.   
    30.           // 反转
    31.           lst1.reverse();
    32.           printList(lst1);
    33.   
    34.           // 排序 - 升序
    35.           lst1.sort();
    36.           printList(lst1);
    37.   
    38.           // 排序 - 降序
    39.           lst1.sort(myCompare);
    40.           printList(lst1);
    41.   
    42.           system("pause");
    43.           return 0;
    44.   }

    复制代码
  
  
• 打印效果
  
  
  
  • 1.   list: 10 200 54 1024 521
    2.   list: 521 1024 54 200 10
    3.   list: 10 54 200 521 1024
    4.   list: 1024 521 200 54 10
    5.   请按任意键继续. . .

    复制代码
  
  

9 pair对组

• pair是成对出现的数据，利用对组可以返回两个数据
  

9.1 创建方式

• pair<type, type> p(value1, value2)
  
• pair<type, type> p = make_pair(value1, value2)
  
• 利用示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   
    4.   int main() {
    5.           // 第一种创建方式
    6.           std::pair<int, std::string> pa(10010, "Tom");
    7.           std::cout << "pa.first: " << pa.first << ", pa.second: " << pa.second << std::endl;
    8.   
    9.           // 第二种创建方式
    10.           std::pair<int, std::string> pa2 = std::make_pair(10020, "Mary");
    11.           std::cout << "pa2.first: " << pa2.first << ", pa2.second: " << pa2.second << std::endl;
    12.   
    13.           system("pause");
    14.           return 0;
    15.   }

    复制代码
  
  
• 打印效果
  
  
  
  • 1.   pa.first: 10010, pa.second: Tom
    2.   pa2.first: 10020, pa2.second: Mary
    3.   请按任意键继续. . .

    复制代码
  
  

10 set/multiset

• set/multiset属于关联式容器，底层结构是用二叉树实现（通常为平衡二叉树），全部元素会在插入时自动排序。
  
• set不允许容器中有重复的元素，multiset允许容器中有重复的元素。
  
• 结构图示
  
  
  
  • 
    
    
  
  

10.1 set构造和赋值

• set<T> st：默认构造
  
• set(const set& st)：拷贝构造
  
• set& operator=(const set& st)：赋值
  
• 利用示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <vector>
    4.   #include <algorithm>
    5.   #include <set>
    6.   
    7.   void printSet(std::set<int>& st) {
    8.           // 遍历数据
    9.           std::cout << "list: ";
    10.           for (std::set<int>::iterator iter = st.begin(); iter != st.end(); iter++) {
    11.                   std::cout << *iter << " ";
    12.           }
    13.           std::cout << std::endl;
    14.   }
    15.   
    16.   
    17.   int main() {
    18.           std::set<int> st;
    19.   
    20.           // 插入数据
    21.           st.insert(10);
    22.           st.insert(100);
    23.           st.insert(100);
    24.           st.insert(15);
    25.           st.insert(520);
    26.           st.insert(2);
    27.   
    28.           printSet(st);
    29.   
    30.           // 拷贝构造
    31.           std::set<int> st2(st);
    32.           printSet(st2);
    33.   
    34.           // 赋值
    35.           std::set<int> st3;
    36.           st3 = st;
    37.           printSet(st3);
    38.   
    39.           system("pause");
    40.           return 0;
    41.   }

    复制代码
  
  
• 打印效果
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <vector>
    4.   #include <algorithm>
    5.   #include <set>
    6.   
    7.   void printSet(std::set<int>& st) {
    8.           // 遍历数据
    9.           std::cout << "list: ";
    10.           for (std::set<int>::iterator iter = st.begin(); iter != st.end(); iter++) {
    11.                   std::cout << *iter << " ";
    12.           }
    13.           std::cout << std::endl;
    14.   }
    15.   
    16.   
    17.   int main() {
    18.           std::set<int> st;
    19.   
    20.           // 插入数据
    21.           st.insert(10);
    22.           st.insert(100);
    23.           st.insert(100);
    24.           st.insert(15);
    25.           st.insert(520);
    26.           st.insert(2);
    27.   
    28.           printSet(st);
    29.   
    30.           // 拷贝构造
    31.           std::set<int> st2(st);
    32.           printSet(st2);
    33.   
    34.           // 赋值
    35.           std::set<int> st3;
    36.           st3 = st;
    37.           printSet(st3);
    38.   
    39.           system("pause");
    40.           return 0;
    41.   }

    复制代码
  
  

10.2 set大小和交换

• size()：获取容器中元素个数。
  
• empty()：判断容器是否为空。
  
• swap(st)：交换两个容器。
  

10.3 set插入和删除

• insert(elem)：插入元素。
  
• clear()：清除全部元素。
  
• erase(pos)：删除pos迭代器指向的元素，返回下一个元素的迭代器。
  
• erase(beg, end)：删除区间[beg, end)的全部元素，返回下一个元素的迭代器。
  
• erase(elem)：删除容器中值为elem的元素。
  

10.4 set查找和统计

• find(key)：查找key是否存在，若存在，返回该键的元素的迭代器，若不存在，返回set.end()。
  
• count(key)：统计key的元素个数。对于set容器，只有0大概1。
  
• 利用示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <vector>
    4.   #include <algorithm>
    5.   #include <set>
    6.   
    7.   void printSet(std::set<int>& st) {
    8.           // 遍历数据
    9.           std::cout << "list: ";
    10.           for (std::set<int>::iterator iter = st.begin(); iter != st.end(); iter++) {
    11.                   std::cout << *iter << " ";
    12.           }
    13.           std::cout << std::endl;
    14.   }
    15.   
    16.   
    17.   int main() {
    18.           std::set<int> st;
    19.   
    20.           // 插入数据
    21.           st.insert(10);
    22.           st.insert(100);
    23.           st.insert(100);
    24.           st.insert(15);
    25.           st.insert(520);
    26.           st.insert(2);
    27.   
    28.           printSet(st);
    29.   
    30.           std::set<int>::iterator iter = st.find(100);
    31.           if (iter != st.end()) {
    32.                   std::cout << "*iter: " << *iter << std::endl;
    33.           }
    34.   
    35.           std::cout << "st.count(100): " << st.count(100) << std::endl;
    36.   
    37.           system("pause");
    38.           return 0;
    39.   }

    复制代码
  
  
• 打印效果
  
  
  
  • 1.   list: 2 10 15 100 520
    2.   *iter: 100
    3.   st.count(100): 1
    4.   请按任意键继续. . .

    复制代码
  
  

10.5 set和multiset区别

• set不可以插入重复数据，而multiset可以。
  
• set插入数据的同时会返回插入效果，表现是否插入成功。multiset不会检测数据，因此可以插入重复数据。
  
• 示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <set>
    3.   
    4.   int main() {
    5.           std::set<int> st;
    6.   
    7.           // 插入数据
    8.          
    9.           std::pair<std::set<int>::iterator, bool> ret;
    10.           // 返回值为pair, 第一个参数为插入位置迭代器，第二个参数表示是否插入成功
    11.           ret = st.insert(100);
    12.           if (ret.second) {
    13.                   // 插入成功
    14.                   std::cout << "插入成功: " << *ret.first <<std::endl;
    15.           }
    16.           else {
    17.                   // 插入失败
    18.                   std::cout << "插入失败" << std::endl;
    19.           }
    20.   
    21.           ret = st.insert(100);
    22.           if (ret.second) {
    23.                   // 插入成功
    24.                   std::cout << "插入成功: " << *ret.first << std::endl;
    25.           }
    26.           else {
    27.                   // 插入失败
    28.                   std::cout << "插入失败" << std::endl;
    29.           }
    30.   
    31.           std::multiset<int> mst;
    32.   
    33.           std::set<int>::iterator iter;
    34.           // 返回值为插入位置迭代器
    35.           iter = mst.insert(200);
    36.           std::cout << "*iter: " << *iter << std::endl;
    37.           iter = mst.insert(200);
    38.           std::cout << "*iter: " << *iter << std::endl;
    39.   
    40.           system("pause");
    41.           return 0;
    42.   }

    复制代码
  
  
• 打印效果
  
  
  
  • 1.   插入成功: 100
    2.   插入失败
    3.   *iter: 200
    4.   *iter: 200
    5.   请按任意键继续. . .

    复制代码
  
  

10.6 set容器排序

• set容器默认排序规则是从小到大，利用仿函数，可以改变默认排序规则。
  
• set存放内置数据范例
  
• 利用示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <vector>
    4.   #include <algorithm>
    5.   #include <set>
    6.   
    7.   // 利用仿函数指定排序规则为从大到小
    8.   class myCompare {
    9.   public:
    10.           bool operator()(int data1, int data2) {
    11.                   return data1 > data2;
    12.           }
    13.   };
    14.   
    15.   int main() {
    16.           std::set<int> st;
    17.   
    18.           // 插入数据
    19.           st.insert(10);
    20.           st.insert(100);
    21.           st.insert(15);
    22.           st.insert(520);
    23.           st.insert(2);
    24.           std::cout << "st: ";
    25.           for (std::set<int>::iterator iter = st.begin(); iter != st.end(); iter++) {
    26.                   std::cout << *iter << " ";
    27.           }
    28.           std::cout << std::endl;
    29.   
    30.           // 指定排序规则为从大到小
    31.           // 利用仿函数
    32.           std::set<int, myCompare> st2;
    33.           st2.insert(10);
    34.           st2.insert(100);
    35.           st2.insert(15);
    36.           st2.insert(520);
    37.           st2.insert(2);
    38.           std::cout << "st2: ";
    39.           for (std::set<int, myCompare>::iterator iter = st2.begin(); iter != st2.end(); iter++) {
    40.                   std::cout << *iter << " ";
    41.           }
    42.           std::cout << std::endl;
    43.   
    44.           system("pause");
    45.           return 0;
    46.   }

    复制代码
  
  
• 打印效果
  
  
  
  • 1.   st: 2 10 15 100 520
    2.   st2: 520 100 15 10 2
    3.   请按任意键继续. . .

    复制代码
  
  
• set存放自界说数据范例
  
• 利用示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <set>
    4.   
    5.   class Person {
    6.   public:
    7.           Person(int code, std::string name) {
    8.                   mCode = code;
    9.                   mName = name;
    10.           }
    11.   
    12.           int mCode;
    13.           std::string mName;
    14.   };
    15.   
    16.   // 利用仿函数指定排序规则
    17.   class myComparePerson {
    18.   public:
    19.           bool operator()(const Person &p1, const Person &p2) {
    20.                   return p1.mCode < p2.mCode;
    21.           }
    22.   };
    23.   
    24.   int main() {
    25.           std::set<Person, myComparePerson> st;
    26.   
    27.           Person p1(10010, "Tom");
    28.           Person p2(10080, "Jack");
    29.           Person p3(10000, "Mary");
    30.           Person p4(11100, "Lucy");
    31.   
    32.           // 插入数据
    33.           st.insert(p1);
    34.           st.insert(p2);
    35.           st.insert(p3);
    36.           st.insert(p4);
    37.   
    38.           for (std::set<Person, myComparePerson>::iterator iter = st.begin(); iter != st.end(); iter++) {
    39.                   std::cout << iter->mCode << " " << iter->mName << std::endl;
    40.           }
    41.   
    42.           system("pause");
    43.           return 0;
    44.   }

    复制代码
  
  
• 打印效果
  
  
  
  • 1.   10000 Mary
    2.   10010 Tom
    3.   10080 Jack
    4.   11100 Lucy
    5.   请按任意键继续. . .

    复制代码
  
  

11 map/multimap

• map中全部元素都是pair，pair中第一个元素为key（键值），起到索引作用，第二个元素为value（值），全部元素都会根据元素的键值自动排序。
  
• map/multimap属于关联式容器，底层结构是用二叉树实现（通常为平衡二叉树）。
  
• map中不允许容器中有重复key值，multimap允许容器中有重复key值。
  
• 结构图示
  
  
  
  • 
    
    
  
  

11.1 map构造和赋值

• map<T1, T2> mp：默认构造
  
• map(const map &mp)：拷贝构造
  
• map& operator=(const map& mp)：等号赋值。
  
• 利用示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <map>
    4.   
    5.   void printMap(std::map<int, std::string>& mp) {
    6.           // 遍历数据
    7.           for (std::map<int, std::string>::iterator iter = mp.begin(); iter != mp.end(); iter++) {
    8.                   std::cout << "iter->first: " << iter->first << ", iter->second: " << iter->second << std::endl;
    9.           }
    10.   }
    11.   
    12.   
    13.   int main() {
    14.           std::map<int, std::string> mp;
    15.   
    16.           // 插入数据
    17.           mp.insert(std::pair<int, std::string>(10010, "AA"));
    18.           mp.insert(std::pair<int, std::string>(11000, "BB"));
    19.           mp.insert(std::pair<int, std::string>(11110, "CC"));
    20.           mp.insert(std::pair<int, std::string>(10000, "DD"));
    21.           mp.insert(std::pair<int, std::string>(10001, "EE"));
    22.           std::cout << "mp: " << std::endl;
    23.           printMap(mp);
    24.   
    25.           // 拷贝构造
    26.           std::map<int, std::string> mp2(mp);
    27.           std::cout << "mp2: " << std::endl;
    28.           printMap(mp2);
    29.   
    30.           // 赋值
    31.           std::map<int, std::string> mp3;
    32.           mp3 = mp;
    33.           std::cout << "mp3: " << std::endl;
    34.           printMap(mp3);
    35.   
    36.           system("pause");
    37.           return 0;
    38.   }

    复制代码
  
  
• 打印效果
  
  
  
  • 1.   mp:
    2.   iter->first: 10000, iter->second: DD
    3.   iter->first: 10001, iter->second: EE
    4.   iter->first: 10010, iter->second: AA
    5.   iter->first: 11000, iter->second: BB
    6.   iter->first: 11110, iter->second: CC
    7.   mp2:
    8.   iter->first: 10000, iter->second: DD
    9.   iter->first: 10001, iter->second: EE
    10.   iter->first: 10010, iter->second: AA
    11.   iter->first: 11000, iter->second: BB
    12.   iter->first: 11110, iter->second: CC
    13.   mp3:
    14.   iter->first: 10000, iter->second: DD
    15.   iter->first: 10001, iter->second: EE
    16.   iter->first: 10010, iter->second: AA
    17.   iter->first: 11000, iter->second: BB
    18.   iter->first: 11110, iter->second: CC
    19.   请按任意键继续. . .

    复制代码
  
  

11.2 map大小和交换

• size()：返回容器中元素个数。
  
• empty()：判断容器是否为空。
  
• swap(st)：交换两个容器数据。
  

11.3 map插入和删除

• insert(elem)：插入元素。
  
• clear()：清除全部元素。
  
• erase(pos)：删除pos迭代器指向的元素，返回下一个元素的迭代器。
  
• erase(beg, end)：删除区间[beg, end)的全部元素，返回下一个元素的迭代器。
  
• erase(elem)：删除容器中值为elem的元素。
  
• 利用示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <map>
    4.   
    5.   void printMap(std::map<int, std::string>& mp) {
    6.           // 遍历数据
    7.           for (std::map<int, std::string>::iterator iter = mp.begin(); iter != mp.end(); iter++) {
    8.                   std::cout << "iter->first: " << iter->first << ", iter->second: " << iter->second << std::endl;
    9.           }
    10.   }
    11.   
    12.   int main() {
    13.           std::map<int, std::string> mp;
    14.   
    15.           // 插入数据
    16.           // 第一种插入方式
    17.           mp.insert(std::pair<int, std::string>(10010, "AA"));
    18.           mp.insert(std::pair<int, std::string>(11000, "BB"));
    19.          
    20.           // 第二种插入方式
    21.           mp.insert(std::make_pair(11110, "CC"));
    22.           mp.insert(std::make_pair(10000, "DD"));
    23.   
    24.           // 第三种插入方式
    25.           mp.insert(std::map<int, std::string>::value_type(10001, "EE"));
    26.   
    27.           // 第四种插入方式(不建议使用)
    28.           mp[11111] = "FF";
    29.   
    30.           std::cout << "mp: " << std::endl;
    31.           printMap(mp);
    32.   
    33.           // 删除
    34.           // 根据迭代器删除
    35.           mp.erase(mp.begin());
    36.           std::cout << "根据迭代器删除: " << std::endl;
    37.           printMap(mp);
    38.   
    39.           // 根据key值删除
    40.           mp.erase(11111);
    41.           std::cout << "根据key值删除: " << std::endl;
    42.           printMap(mp);
    43.   
    44.           system("pause");
    45.           return 0;
    46.   }

    复制代码
  
  
• 打印效果
  
  
  
  • 1.   mp:
    2.   iter->first: 10000, iter->second: DD
    3.   iter->first: 10001, iter->second: EE
    4.   iter->first: 10010, iter->second: AA
    5.   iter->first: 11000, iter->second: BB
    6.   iter->first: 11110, iter->second: CC
    7.   iter->first: 11111, iter->second: FF
    8.   根据迭代器删除:
    9.   iter->first: 10001, iter->second: EE
    10.   iter->first: 10010, iter->second: AA
    11.   iter->first: 11000, iter->second: BB
    12.   iter->first: 11110, iter->second: CC
    13.   iter->first: 11111, iter->second: FF
    14.   根据key值删除:
    15.   iter->first: 10001, iter->second: EE
    16.   iter->first: 10010, iter->second: AA
    17.   iter->first: 11000, iter->second: BB
    18.   iter->first: 11110, iter->second: CC
    19.   请按任意键继续. . .

    复制代码
  
  

11.4 map查找和统计

• find(key)：查找key是否存在，若存在，返回该键的元素的迭代器，若不存在，返回map.end()。
  
• count(key)：统计key的元素个数。对于map容器，只有0大概1。
  
• 利用示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <map>
    4.   
    5.   void printMap(std::map<int, std::string>& mp) {
    6.           // 遍历数据
    7.           for (std::map<int, std::string>::iterator iter = mp.begin(); iter != mp.end(); iter++) {
    8.                   std::cout << "iter->first: " << iter->first << ", iter->second: " << iter->second << std::endl;
    9.           }
    10.   }
    11.   
    12.   int main() {
    13.           std::map<int, std::string> mp;
    14.   
    15.           // 插入数据
    16.           mp.insert(std::pair<int, std::string>(10010, "AA"));
    17.           mp.insert(std::pair<int, std::string>(11000, "BB"));
    18.           mp.insert(std::pair<int, std::string>(11110, "CC"));
    19.           mp.insert(std::pair<int, std::string>(10000, "DD"));
    20.           mp.insert(std::pair<int, std::string>(10001, "EE"));
    21.          
    22.           // 查找
    23.           std::map<int, std::string>::iterator iter = mp.find(11110);
    24.           if (iter != mp.end()) {
    25.                   std::cout << "找到了" << std::endl;
    26.                   std::cout << "key: " << iter->first << ", value: " << iter->second << std::endl;
    27.           }
    28.           else {
    29.                   std::cout << "未找到" << std::endl;
    30.           }
    31.   
    32.           // 统计
    33.           std::cout << "mp.count(10000): " << mp.count(10000) <<std::endl;
    34.   
    35.           system("pause");
    36.           return 0;
    37.   }

    复制代码
  
  
• 打印效果
  
  
  
  • 1.   找到了
    2.   key: 11110, value: CC
    3.   mp.count(10000): 1
    4.   请按任意键继续. . .

    复制代码
  
  

11.5 map容器排序

• map容器默认排序规则是从小到大，利用仿函数，可以改变默认排序规则。
  
• 利用示例
  
  
  
  • 1.   #include <iostream>
    2.   #include <string>
    3.   #include <map>
    4.   
    5.   class myCompare {
    6.   public:
    7.           bool operator()(int data1, int data2) {
    8.                   return data1 > data2;
    9.           }
    10.   };
    11.   
    12.   int main() {
    13.           std::map<int, std::string, myCompare> mp;
    14.   
    15.           // 插入数据
    16.           mp.insert(std::pair<int, std::string>(10010, "AA"));
    17.           mp.insert(std::pair<int, std::string>(11000, "BB"));
    18.           mp.insert(std::pair<int, std::string>(11110, "CC"));
    19.           mp.insert(std::pair<int, std::string>(10000, "DD"));
    20.           mp.insert(std::pair<int, std::string>(10001, "EE"));
    21.          
    22.           for (std::map<int, std::string, myCompare>::iterator iter = mp.begin(); iter != mp.end(); iter++) {
    23.                   std::cout << "iter->first: " << iter->first << ", iter->second: " << iter->second << std::endl;
    24.           }
    25.   
    26.           system("pause");
    27.           return 0;
    28.   }

    复制代码
  
  
• 打印效果
  
  
  
  • 1.   iter->first: 11110, iter->second: CC
    2.   iter->first: 11000, iter->second: BB
    3.   iter->first: 10010, iter->second: AA
    4.   iter->first: 10001, iter->second: EE
    5.   iter->first: 10000, iter->second: DD
    6.   请按任意键继续. . .

    复制代码
  
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。