c++学习记录（六）

前面总结了vector容器的一些知识，这篇文章来总结其他一些容器的相关概念。

1、deque容器

1、基本概念

deque容器的示意图如下所示，他与vector容器的区别在于他是一个双端的数组，因此可以对头部的进行很方便的插入删除操作。

形成这样的工作原理为，deque内部有一个中控器，由中控器维护每段缓冲区的内容，而缓冲区中存放真实的数据，示意图如下所示：（这样整个容器看起来就是一片连续的内存空间）

2、构造函数

deque的构造相关函数如下：

函数名	说明
deque<T> deqT	默认构造形式
deque(beg, end)	构造函数将[beg, end)区间中的元素拷贝给本身
deque(n, elem	构造函数将n个elem拷贝给本身
deque(const deque &deq)	拷贝构造函数

完整示例代码如下，可以看到，基本上和vector容器是一样的：

#include <iostream>
#include <vector>
using namespace std;

#include <deque>

void printDeque(const deque<int>& d)
{
    
    
	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
    
    
		cout << *it << " ";

	}
	cout << endl;
}
//deque构造
void test01() 
{
    
    
	deque<int> d1; //无参构造函数
	for (int i = 0; i < 10; i++)
	{
    
    
		d1.push_back(i);
	}
	printDeque(d1);
	deque<int> d2(d1.begin(), d1.end());
	printDeque(d2);

	deque<int>d3(10, 100);
	printDeque(d3);

	deque<int>d4 = d3;
	printDeque(d4);
}

int main()
{
    
    
	test01();
	system("pause");
	return 0;
}

最终运行结果如下：

3、赋值操作

下面实现对deque容器的赋值操作，相关函数如下：

* deque& operator=(const deque &deq)	重载等号操作符
* assign(beg, end)	将[beg, end)区间中的数据拷贝赋值给本身
* assign(n, elem)	将n个elem拷贝赋值给本身

使用上述函数进行赋值，结果如下所示：

void test01()
{
    
    
	deque<int> d1;
	for (int i = 0; i < 10; i++)
	{
    
    
		d1.push_back(i);
	}
	printDeque(d1);

	deque<int>d2;
	d2 = d1;
	printDeque(d2);

	deque<int>d3;
	d3.assign(d1.begin(), d1.end());
	printDeque(d3);

	deque<int>d4;
	d4.assign(10, 100);
	printDeque(d4);

}

运行结果如下：

4、获取容器的大小

对deque容器的大小进行操作的相关功能函数如下所示：

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

相关示例代码如下所示：

void test01()
{
    
    
	deque<int> d1;
	for (int i = 0; i < 10; i++)
	{
    
    
		d1.push_back(i);
	}
	printDeque(d1);

	//判断容器是否为空
	if (d1.empty()) {
    
    
		cout << "d1为空!" << endl;
	}
	else {
    
    
		cout << "d1不为空!" << endl;
		//统计大小
		cout << "d1的大小为：" << d1.size() << endl;
	}
	cout << "大小变为15，以1填充" << endl;
	//重新指定大小
	d1.resize(15, 1);
	printDeque(d1);
	cout << "大小减小为5" << endl;
	d1.resize(5);
	printDeque(d1);
}

运行结果如下所示：

5、插入和删除

向deque插入和删除元素可以分为两种情况，分别如下所示：
两端插入操作：

- push_back(elem);	在容器尾部添加一个数据
- push_front(elem);	在容器头部插入一个数据
- pop_back();	删除容器最后一个数据
- pop_front();	删除容器第一个数据

指定位置操作：

insert(pos,elem);	在pos位置插入一个elem元素的拷贝，返回新数据的位置。
insert(pos,n,elem);	在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end);	在pos位置插入[beg,end)区间的数据，无返回值。
clear();	清空容器的所有数据
erase(beg,end);	删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);	删除pos位置的数据，返回下一个数据的位置。

相关代码如下：

//两端操作
void test01()
{
    
    
	deque<int> d;
	//尾插
	d.push_back(10);
	d.push_back(20);
	//头插
	d.push_front(100);
	d.push_front(200);

	printDeque(d);

	//尾删
	d.pop_back();
	//头删
	d.pop_front();
	printDeque(d);
}

//插入
void test02()
{
    
    
	deque<int> d;
	d.push_back(10);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);
	printDeque(d);

	d.insert(d.begin(), 1000);
	printDeque(d);

	d.insert(d.begin(), 2,10000);
	printDeque(d);

	deque<int>d2;
	d2.push_back(1);
	d2.push_back(2);
	d2.push_back(3);

	d.insert(d.begin(), d2.begin(), d2.end());
	printDeque(d);

}

//删除
void test03()
{
    
    
	deque<int> d;
	d.push_back(10);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);
	printDeque(d);

	d.erase(d.begin());
	printDeque(d);

	d.erase(d.begin(), d.end());
	d.clear();
	printDeque(d);
}

尾部插入和头部插入

中间插入

删除操作

6、数据存取

相关的操作函数如下所示：

at(int idx)	返回索引idx所指的数据
operator[]	返回索引idx所指的数据
front()	返回容器中第一个数据元素
back()	返回容器中最后一个数据元素

数据存取的样例如下所示：

void test01()
{
    
    
	deque<int> d;
	d.push_back(10);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);
	for (int i = 0; i < d.size(); i++) {
    
    
		cout << d[i] << " ";
	}
	cout << endl;
	for (int i = 0; i < d.size(); i++) {
    
    
		cout << d.at(i) << " ";
	}
	cout << endl;
	cout << "front:" << d.front() << endl;
	cout << "back:" << d.back() << endl;
}

运行结果如下所示：

7、排序

这里deque容器实现排序也有现成的函数：

sort(iterator beg, iterator end) 对beg和end区间内元素进行排序
使用示例如下：

void test01()
{
    
    
	deque<int> d;
	d.push_back(10);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);

	printDeque(d);
	sort(d.begin(), d.end());
	printDeque(d);
}

使用这个排序算法需要包含头文件：

运行结果如下所示：

2、stack容器

1、基本概念

下面继续介绍stack容器，这个就跟c中的栈比较像，也是一种先进后出的数据结构，因为只有一个出口，所以就像这样先进去的进入栈底，然后后进去的在栈顶，所以出栈的时候先出。

2、常用接口

stack的常用接口如下所示：

构造操作

stack<T> stk	stack采用模板类实现， stack对象的默认构造形式
stack(const stack &stk)	拷贝构造函数

赋值操作：

stack& operator=(const stack &stk)	重载等号操作符

数据存取：

push(elem)	向栈顶添加元素
pop()	从栈顶移除第一个元素
top()	返回栈顶元素

大小操作：

empty()	判断堆栈是否为空
size()	返回栈的大小

使用栈需要包含他的头文件：

测试上述函数如下所示：

void test01()
{
    
    
	//创建栈容器 栈容器必须符合先进后出
	stack<int> s;

	//向栈中添加元素，叫做 压栈 入栈
	s.push(10);
	s.push(20);
	s.push(30);

	while (!s.empty()) 
	{
    
    
		//输出栈顶元素
		cout << "栈顶元素为： " << s.top() << endl;
		//弹出栈顶元素
		s.pop();
	}
	cout << "栈的大小为：" << s.size() << endl;
}

运行结果如下所示：

3、queue容器

1、基本概念

这个又和c中的一种数据结构很像了，是一种先进先出的数据结构，和stack不同的在于他有两个出口，结构示意图如下所示：

2、常用接口

构造函数：

queue<T> que	queue采用模板类实现，queue对象的默认构造形式
queue(const queue &que)	拷贝构造函数

赋值操作：

queue& operator=(const queue &que)	重载等号操作符

数据存取：

push(elem)	往队尾添加元素
pop()	从队头移除第一个元素
back()	返回最后一个元素
front()	返回第一个元素

大小操作：

empty()	判断堆栈是否为空
size()	返回栈的大小

下面是上述一些接口的使用示例：

开头需要引用容器：

示例代码如下：

class Person
{
    
    
public:
	Person(string name, int age)
	{
    
    
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};

void test01() 
{
    
    
	//创建队列
	queue<Person> q;
	//准备数据
	Person p1("唐僧", 30);
	Person p2("孙悟空", 1000);
	Person p3("猪八戒", 900);
	Person p4("沙僧", 800);
	//向队列中添加元素  入队操作
	q.push(p1);
	q.push(p2);
	q.push(p3);
	q.push(p4);

	//队列不提供迭代器，更不支持随机访问	
	while (!q.empty()) 
	{
    
    
		//输出队头元素
		cout << "队头元素-- 姓名： " << q.front().m_Name
			<< " 年龄： " << q.front().m_Age << endl;

		cout << "队尾元素-- 姓名： " << q.back().m_Name
			<< " 年龄： " << q.back().m_Age << endl;
		cout << endl;
		//弹出队头元素
		q.pop();
	}
	cout << "队列大小为：" << q.size() << endl;
}

运行结果如下所示：

4、list容器

1、基本概念

list容器是将数据进行链式存储，就是链表，链表一种链式表形式的数据结构，但是它在物理储存单元上是非连续的，形成链式表是通过链表中的指针链接实现的，示意图如下所示：

这样的优点在于：

• 采用动态存储分配，不会造成内存浪费和溢出
• 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素

但是也有缺点，就是：

• 本身前后指针会占用内存空间，对内存耗费较大，在进行一些操作的时候时间复杂度和空间复杂度也都会很大

2、构造函数

相应的构造函数如下：

list<T> lst	list采用采用模板类实现,对象的默认构造形式
list(beg,end)	构造函数将[beg, end)区间中的元素拷贝给本身
list(n,elem)	构造函数将n个elem拷贝给本身
list(const list &lst)	拷贝构造函数

这里使用前还是要引用一下头文件：

示例代码如下所示：

void printList(const list<int>& L) {
    
    

	for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
    
    
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
    
    
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	printList(L1);

	list<int>L2(L1.begin(), L1.end());
	printList(L2);

	list<int>L3(L2);
	printList(L3);

	list<int>L4(10, 1000);
	printList(L4);
}

运行结果如下所示：

3、赋值操作

相关操作函数如下所示：

assign(beg, end)	将[beg, end)区间中的数据拷贝赋值给本身
assign(n, elem)	将n个elem拷贝赋值给本身。
list& operator=(const list &lst)	重载等号操作符
swap(lst)	将lst与本身的元素互换。

这里主要是赋值和交换的函数，下面分别一一举例来看一下：

void test01()
{
    
    
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	printList(L1);
	//赋值
	list<int>L2;
	L2 = L1;
	printList(L2);
	list<int>L3;
	L3.assign(L2.begin(), L2.end());
	printList(L3);
	list<int>L4;
	L4.assign(10, 100);
	printList(L4);
}

//交换
void test02()
{
    
    
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);
	list<int>L2;
	L2.assign(10, 100);
	cout << "交换前： " << endl;
	printList(L1);
	printList(L2);
	cout << endl;
	L1.swap(L2);
	cout << "交换后： " << endl;
	printList(L1);
	printList(L2);
}

赋值结果如下

交换的结果如下

4、大小操作

主要是获取容器的大小操作，相关功能函数如下：

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

相关示例代码如下：

void test01()
{
    
    
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	if (L1.empty())
	{
    
    
		cout << "L1为空" << endl;
	}
	else
	{
    
    
		cout << "L1不为空" << endl;
		cout << "L1的大小为： " << L1.size() << endl;
	}

	//重新指定大小
	L1.resize(10);
	printList(L1);

	L1.resize(2);
	printList(L1);
}

运行结果如下：

5、插入和删除

相关操作的功能函数如下所示：

push_back(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()	移除容器的所有数据
erase(beg,end)	删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos)	删除pos位置的数据，返回下一个数据的位置。
remove(elem)	删除容器中所有与elem值匹配的元素。

相关示例代码如下：

void test01()
{
    
    
	list<int> L;
	//尾插
	L.push_back(10);
	L.push_back(20);
	L.push_back(30);
	//头插
	L.push_front(100);
	L.push_front(200);
	L.push_front(300);

	printList(L);

	//尾删
	L.pop_back();
	printList(L);

	//头删
	L.pop_front();
	printList(L);

	//插入
	list<int>::iterator it = L.begin();
	L.insert(++it, 1000);
	printList(L);

	//删除
	it = L.begin();
	L.erase(++it);
	printList(L);

	//移除
	L.push_back(10000);
	L.push_back(10000);
	L.push_back(10000);
	printList(L);
	L.remove(10000);
	printList(L);
    
    //清空
	L.clear();
	printList(L);
}

运行结果如下所示：

6、数据存取

进行数据存取的相关功能函数如下所示：

front()	返回第一个元素
back()	返回最后一个元素

相关示例代码如下所示：

void test01()
{
    
    
	list<int>L1;
	L1.push_back(10);
	L1.push_back(20);
	L1.push_back(30);
	L1.push_back(40);

	cout << "第一个元素为： " << L1.front() << endl;
	cout << "最后一个元素为： " << L1.back() << endl;
}

运行结果如下所示：

7、排序

排序的主要功能函数包括将容器中的元素反转，或者是将容器中的数据进行排序，相关功能函数如下所示：

reverse()	反转链表
sort()	链表排序

示例代码如下所示：

bool myCompare(int val1, int val2)
{
    
    
	return val1 > val2;
}
void test01()
{
    
    
	list<int> L;
	L.push_back(90);
	L.push_back(30);
	L.push_back(20);
	L.push_back(70);
	printList(L);

	//反转容器的元素
	L.reverse();
	printList(L);

	//排序
	L.sort(); //默认的排序规则 从小到大
	printList(L);

	L.sort(myCompare); //指定规则，从大到小
	printList(L);
}

运行结果如下所示：

5、set/ multiset 容器

1、基本概念

set和multiset会根据特定的排序原则将元素排序。两者不同之处在于，multisets允许元素重复，而set不允许重复。他们是关联性容器，底层结构是用二叉树来实现。

2、set的基本构造

示例代码如下所示：

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

void printSet(set<int> & s)
{
    
    
	for (set<int>::iterator it = s.begin(); it != s.end(); it++)
	{
    
    
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
    
    
	set<int> s1;
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
	printSet(s1);

	set<int>s2(s1);
	printSet(s2);

	set<int>s3;
	s3 = s2;
	printSet(s3);
}

int main() 
{
    
    
	test01();
	system("pause");
	return 0;
}

相关说明如下所示：

这三个都是排序好的：

3、获取大小

set容器中与大小相关的函数原型如下所示：

size()	返回容器中元素的数目
empty()	判断容器是否为空
swap(st)	交换两个集合容器

示例代码如下所示：

//大小
void test01()
{
    
    
	set<int> s1;
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
	if (s1.empty())
	{
    
    
		cout << "s1为空" << endl;
	}
	else
	{
    
    
		cout << "s1不为空" << endl;
		cout << "s1的大小为： " << s1.size() << endl;
	}
}

//交换
void test02()
{
    
    
	set<int> s1;
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
	set<int> s2;
	s2.insert(100);
	s2.insert(300);
	s2.insert(200);
	s2.insert(400);
	cout << "交换前" << endl;
	printSet(s1);
	printSet(s2);
	cout << endl;
	cout << "交换后" << endl;
	s1.swap(s2);
	printSet(s1);
	printSet(s2);
}

运行结果如下所示：

交换结果

4、插入和删除

相关函数原型如下所示：

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

示例代码如下所示：

void test01()
{
    
    
	set<int> s1;
	//插入
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
	printSet(s1);
	//删除
	s1.erase(s1.begin());
	printSet(s1);
	s1.erase(30);
	printSet(s1);
	//清空
	s1.clear();
	printSet(s1);
}

运行结果如下所示：（最后一次打印是空的，所以就什么也没有）

5、统计和查找

这个函数比较简单，如下所示：

• find(key); //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
• count(key); //统计key的元素个数

示例代码如下所示：

void test01()
{
    
    
	set<int> s1;
	//插入
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
	//查找
	set<int>::iterator pos = s1.find(30);
	if (pos != s1.end())
	{
    
    
		cout << "找到了元素 ： " << *pos << endl;
	}
	else
	{
    
    
		cout << "未找到元素" << endl;
	}
	//统计
	int num = s1.count(30);
	cout << "num = " << num << endl;
}

运行结果如下所示：

6、使用set对容器进行排序

set默认情况下是会对加入到容器内的数据进行排序的，但是默认是从小到大的，不过我们可以修改这个排序规则，下面是几种改变排序规则的方法：

方法一：（使用内置数据类型）

void test01()
{
    
    
	set<int> s1;
	s1.insert(10);
	s1.insert(40);
	s1.insert(20);
	s1.insert(30);
	s1.insert(50);

	cout << "使用默认排序规则" << endl;
	//默认从小到大
	for (set<int>::iterator it = s1.begin(); it != s1.end(); it++) {
    
    
		cout << *it << " ";
	}
	cout << endl;

	//指定排序规则
	set<int, MyCompare> s2;
	s2.insert(10);
	s2.insert(40);
	s2.insert(20);
	s2.insert(30);
	s2.insert(50);
	cout << "使用指定排序规则" << endl;
	for (set<int, MyCompare>::iterator it = s2.begin(); it != s2.end(); it++) {
    
    
		cout << *it << " ";
	}
	cout << endl;
}

运行结果如下所示：

方法二：使用自定义数据类型来排序

示例代码如下：

class Person
{
    
    
public:
	Person(string name, int age)
	{
    
    
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};
class comparePerson
{
    
    
public:
	bool operator()(const Person& p1, const Person &p2)
	{
    
    
		//按照年龄进行排序  降序
		return p1.m_Age > p2.m_Age;
	}
};

void test01()
{
    
    
	set<Person, comparePerson> s;
	Person p1("小刘", 17);
	Person p2("小张", 52);
	Person p3("小赵", 21);
	Person p4("小李", 26);
	s.insert(p1);
	s.insert(p2);
	s.insert(p3);
	s.insert(p4);
	for (set<Person, comparePerson>::iterator it = s.begin(); it != s.end(); it++)
	{
    
    
		cout << "姓名： " << it->m_Name << " 年龄： " << it->m_Age << endl;
	}
}

运行结果如下所示：

6、map/multimap容器

1、基本概念

multimap 容器保存的是有序的键/值对，但它可以保存重复的元素。multimap 中会出现具有相同键的元素序列，它们会被添加到容器中。

采用这种的数据类型可以根据key值迅速找到value的值，就跟python里面的字典差不多。

2、构造函数

直接看代码吧，一般构造函数都差不多的：

void printMap(map<int, int>&m)
{
    
    
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
    
    
		cout << "key = " << it->first << " value = " << it->second << endl;
	}
	cout << endl;
}

void test01()
{
    
    
	map<int, int>m; //默认构造
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));
	printMap(m);

	map<int, int>m2(m); //拷贝构造
	printMap(m2);

	map<int, int>m3;
	m3 = m2; //赋值
	printMap(m3);
}

这里跟之前set容器是一样的方法生成的，结果如下所示：

3、获取大小

相关的函数原型如下所示：

• size(); //返回容器中元素的数目
• empty(); //判断容器是否为空
• swap(st); //交换两个集合容器

示例代码如下：

void test01()
{
    
    
	map<int, int>m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));
	if (m.empty())
	{
    
    
		cout << "m为空" << endl;
	}
	else
	{
    
    
		cout << "m不为空" << endl;
		cout << "m的大小为： " << m.size() << endl;
	}
}
//交换
void test02()
{
    
    
	map<int, int>m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));

	map<int, int>m2;
	m2.insert(pair<int, int>(4, 100));
	m2.insert(pair<int, int>(5, 200));
	m2.insert(pair<int, int>(6, 300));

	cout << "交换前" << endl;
	printMap(m);
	printMap(m2);

	cout << "交换后" << endl;
	m.swap(m2);
	printMap(m);
	printMap(m2);
}

运行结果如下所示：

交换的结果如下：（这里是两个容器之间的数据交换）

4、map的插入和删除

插入和删除相关的函数原型如下所示：

insert(elem)	在容器中插入元素
clear()	清除所有元素
erase(pos)	删除pos迭代器所指的元素，返回下一个元素的迭代器
erase(beg, end)	删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器
erase(key)	删除容器中值为key的元素

示例代码如下所示：

void test01()
{
    
    
	//插入
	map<int, int> m;
	//第一种插入方式
	m.insert(pair<int, int>(1, 10));
	//第二种插入方式
	m.insert(make_pair(2, 20));
	//第三种插入方式
	m.insert(map<int, int>::value_type(3, 30));
	//第四种插入方式
	m[4] = 40;
	printMap(m);

	//删除
	m.erase(m.begin());
	printMap(m);

	m.erase(3);
	printMap(m);

	//清空
	m.erase(m.begin(), m.end());
	m.clear();
	printMap(m);
}

运行结果如下所示：

5、查找和统计元素

这个也是使用find和count函数来实现，示例代码如下所示：

查找如下所示：

map<int, int>::iterator pos = m.find(3);

如果要计数：

int num = m.count(3);

6、map容器排序

这里可以用自己定义的函数来实现自定义排序，示例代码如下所示：

class MyCompare 
{
    
    
public:
	bool operator()(int v1, int v2) {
    
    
		return v1 > v2;
	}
};
void test01()
{
    
    
	map<int, int, MyCompare> m;
	m.insert(make_pair(1, 10));
	m.insert(make_pair(2, 20));
	m.insert(make_pair(3, 30));
	m.insert(make_pair(4, 40));
	m.insert(make_pair(5, 50));

	for (map<int, int, MyCompare>::iterator it = m.begin(); it != m.end(); it++) 
	{
    
    
		cout << "key:" << it->first << " value:" << it->second << endl;
	}
}

运行结果如下所示