1、map容器

map中所有元素都是pair，pair中第一个元素为key（键），起到索引作用，第二个元素为value（值），所有元素都会根据元素的键值自动排序。

map的本质：map / multimap属于关联式容器，底层结构是用二叉树实现的。

map的优点：可以根据key值快速找到value值

map与multimap区别：

• map不允许容器中有重复key元素
• multimap允许容器中有重复key元素

1.1、map常用接囗

函数原型

构造函数

• map mp;        //map默认构造函数
• map(const map &mp); //拷贝构造函数

赋值

• map& operator=(const map& mp);  //重载运算符=

大小

• size();       //返回容器中元素个数
• emppy();  //判断容器是否为空

交换

• swap(st); //交换两个map容器

插入

• insert(elem)；//在容器中插入元素

删除

• erase(key);    //删除容器中key元素
• erase(pos);    //删除pos迭代器所指的元素，返回下一个元素的迭代器
• erase(beg, end); //删除区间[beg, end) 的所有元素， 返回下一个元素的迭代器
• clear();          //清除所有元素

查找

• find(key);  //查找key是否存在，若存在，返回该键的元素的迭代器，若不存在，返回map.end()

统计

• count(key);  //统计key的元素个数

#include 
#include 
using namespace std;
 
void print(const mapint>& mp)
{
	for (mapint>::const_iterator it = mp.begin(); it != mp.end(); it++)
	{
		cout << "姓名：" << it->first << "，年龄：" << it->second << endl;
	}
}
 
int main()
{
	// STL - map - 常用接囗
	/*函数原型
		构造函数
		1、map mp;     //map默认构造函数
		2、map(const map &mp); //拷贝构造函数
		赋值
		3、map& operator=(const map& mp);  //重载运算符=
		大小
		4、size();   //返回容器中元素个数
		5、emppy();  //判断容器是否为空
		交换
		6、swap(st); //交换两个map容器
		插入
		7、insert(elem)；//在容器中插入元素
		删除
		8、erase(key);   	 //删除容器中key元素
		9、erase(pos);   	 //删除pos迭代器所指的元素，返回下一个元素的迭代器
		10、erase(beg, end); //删除区间[beg, end) 的所有元素， 返回下一个元素的迭代器
		11、clear();         //清除所有元素
		查找
		12、find(key);  //查找key是否存在，若存在，返回该键的元素的迭代器，若不存在，返回map.end()
		统计
		13、count(key);  //统计key的元素个数
	*/
 
	//1、map mp;     //map默认构造函数
	mapint> mp;
 
	//5、emppy();  //判断容器是否为空
	if (mp.empty())
	{
		//7、insert(elem)；//在容器中插入元素
		//插入方式一
		mp.insert(pairint>("Tracy", 20));
		//插入方式二
		mp.insert(make_pair("Felix", 27));
		//插入方式三
		mp.insert(mapint>::value_type("Polly", 36));
		//插入方式四
		mp["Linda"] = 26;
	}
	
	//4、size();   //返回容器中元素个数
	cout << "---- 4、mp容器中元素个数：" << mp.size()  << endl;
	cout << "---- 7、插入数据后mp，容器中元素：---" << endl;
	print(mp);
 
 
	//2、map(const map &mp); //拷贝构造函数
	mapint> mp2(mp);
	cout << "---- 2、拷贝构造函数mp2元素：----" << endl;
	print(mp2);
 
 
	//3、map& operator=(const map& mp);  //重载运算符=
	mapint> mp3 = mp;
	cout << "---- 3、重载运算符=mp3元素：----" << endl;
	print(mp3);
 
	//12、find(key);  //查找key是否存在，若存在，返回该键的元素的迭代器，若不存在，返回map.end()
	mapint>::iterator pos = mp.find("Tracy");
	if (pos != mp.end())
	{
		cout << "---- 12、mp容器中查找到键 = " << (*pos).first << ", 值 = " << (*pos).second << endl;
	}
 
	//13、count(key);  //统计key的元素个数
	//map不允许插入重复key元素，count统计结果 只有 0 或 1
	cout << "---- 13、mp容器中统计键的元素个数 " << mp.count("Tracy") << endl;
 
	//6、swap(st); //交换两个map容器
	cout << "---- 6、交换前mp元素：----" << endl;
	print(mp);
	mp3.insert(pairint>("Timo ", 29));
	mp3.insert(pairint>("Alice", 32));
	mp3.insert(pairint>("Yolim", 17));
	cout << "---- 6、交换前mp3元素：----" << endl;
	print(mp3);
 
	mp.swap(mp3);
 
	cout << "---- 6、交换后mp元素：----" << endl;
	print(mp);
	cout << "---- 6、交换后mp3元素：----" << endl;
	print(mp3);
 
	//8、erase(key);   	 //删除容器中key元素
	mp.erase("Yolim");
	cout << "---- 8、删除key元素后，mp元素：----" << endl;
	print(mp);
	
	//9、erase(pos);   	 //删除pos迭代器所指的元素，返回下一个元素的迭代器
	mp.erase(mp.begin());
	cout << "---- 9、删除指定的第一个元素后，mp元素：----" << endl;
	print(mp);
	
	//10、erase(beg, end); //删除区间[beg, end) 的所有元素， 返回下一个元素的迭代器
	pos = mp.begin();
	pos++;
	mp.erase(pos, mp.end());
	cout << "---- 10、删除指定区间元素后，mp元素：----" << endl;
	print(mp);
	
	//11、clear();         //清除所有元素
	mp.clear();
	cout << "---- 11、清除所有元素后，mp元素：----" << endl;
	print(mp);
 
	system("pause");
 
	return 0;
}

输出结果

---- 4、mp容器中元素个数：4
---- 7、插入数据后mp，容器中元素：---
姓名：Felix，年龄：27
姓名：Linda，年龄：26
姓名：Polly，年龄：36
姓名：Tracy，年龄：20
---- 2、拷贝构造函数mp2元素：----
姓名：Felix，年龄：27
姓名：Linda，年龄：26
姓名：Polly，年龄：36
姓名：Tracy，年龄：20
---- 3、重载运算符=mp3元素：----
姓名：Felix，年龄：27
姓名：Linda，年龄：26
姓名：Polly，年龄：36
姓名：Tracy，年龄：20
---- 12、mp容器中查找到键 = Tracy, 值 = 20
---- 13、mp容器中统计键的元素个数 1
---- 6、交换前mp元素：----
姓名：Felix，年龄：27
姓名：Linda，年龄：26
姓名：Polly，年龄：36
姓名：Tracy，年龄：20
---- 6、交换前mp3元素：----
姓名：Alice，年龄：32
姓名：Felix，年龄：27
姓名：Linda，年龄：26
姓名：Polly，年龄：36
姓名：Timo ，年龄：29
姓名：Tracy，年龄：20
姓名：Yolim，年龄：17
---- 6、交换后mp元素：----
姓名：Alice，年龄：32
姓名：Felix，年龄：27
姓名：Linda，年龄：26
姓名：Polly，年龄：36
姓名：Timo ，年龄：29
姓名：Tracy，年龄：20
姓名：Yolim，年龄：17
---- 6、交换后mp3元素：----
姓名：Felix，年龄：27
姓名：Linda，年龄：26
姓名：Polly，年龄：36
姓名：Tracy，年龄：20
---- 8、删除key元素后，mp元素：----
姓名：Alice，年龄：32
姓名：Felix，年龄：27
姓名：Linda，年龄：26
姓名：Polly，年龄：36
姓名：Timo ，年龄：29
姓名：Tracy，年龄：20
---- 9、删除指定的第一个元素后，mp元素：----
姓名：Felix，年龄：27
姓名：Linda，年龄：26
姓名：Polly，年龄：36
姓名：Timo ，年龄：29
姓名：Tracy，年龄：20
---- 10、删除指定区间元素后，mp元素：----
姓名：Felix，年龄：27
---- 11、清除所有元素后，mp元素：---- 

1.2、map排序

map根据键值自动排序，默认排序规则为升序，可以利用仿函数实现降序排序。

#include 
#include 
using namespace std;
 
void print(const mapint>& mp)
{
	for (mapint>::const_iterator it = mp.begin(); it != mp.end(); it++)
	{
		cout << "姓名：" << it->first << "，年龄：" << it->second << endl;
	}
}
 
class MyCompare
{
public:
	//仿函数
	bool operator()(string v1, string v2) const
	{
		return v1 > v2;
	}
};
 
//打印降序排序的容器元素
void printDescending(const mapint, MyCompare>& mp)
{
	for (mapint, MyCompare>::const_iterator it = mp.begin(); it != mp.end(); it++)
	{
		cout << "姓名：" << it->first << "，年龄：" << it->second << endl;
	}
}
 
int main()
{
	// STL - map - 排序 
	/*
		map根据键值自动排序，默认排序规则为升序，可以利用仿函数实现降序排序。
	*/
 
	//map根据键值自动排序，默认排序规则为升序
	mapint> mp;
 
	mp.insert(make_pair("Tracy", 29));
	mp.insert(make_pair("Felix", 27));
	mp.insert(make_pair("Timo ", 16));
	mp.insert(make_pair("Alice", 27));
 
	cout << "---- map 默认排序规则为升序 ----" << endl;
	print(mp);
 
	//利用仿函数实现降序排序
	mapint, MyCompare> mp2;
 
	mp2.insert(make_pair("Tracy", 29));
	mp2.insert(make_pair("Felix", 27));
	mp2.insert(make_pair("Timo ", 16));
	mp2.insert(make_pair("Alice", 27));
 
	cout << "---- map 利用仿函数实现降序排序 ----" << endl;
	printDescending(mp2);
 
 
	system("pause");
 
	return 0;
}

输出结果

---- map 默认排序规则为升序 ----
姓名：Alice，年龄：27
姓名：Felix，年龄：27
姓名：Timo ，年龄：16
姓名：Tracy，年龄：29
---- map 利用仿函数实现降序排序 ----
姓名：Tracy，年龄：29
姓名：Timo ，年龄：16
姓名：Felix，年龄：27
姓名：Alice，年龄：27