C++ 学习（20）STL - map容器

最新推荐文章于 2024-11-19 21:33:04 发布

原创最新推荐文章于 2024-11-19 21:33:04 发布 · 1.3k 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#学习 #c++

C++ 专栏收录该内容

21 篇文章

订阅专栏

本文详细介绍了C++ STL map容器的基本概念、优点、映射与multimap的区别，展示了常用接口的使用方法，包括构造、插入、删除、查找以及排序技巧。通过实例演示了如何利用仿函数进行降序排序，并提供了实际操作代码及输出结果。

1、map容器

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

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

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

map与multimap区别：

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

1.1、map常用接囗

函数原型

构造函数

map<T1, T2> 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 <iostream>
#include <map>
using namespace std;

void print(const map<string, int>& mp)
{
	for (map<string, int>::const_iterator it = mp.begin(); it != mp.end(); it++)
	{
		cout << "姓名：" << it->first << "，年龄：" << it->second << endl;
	}
}

int main()
{
	// STL - map - 常用接囗
	/*函数原型
		构造函数
		1、map<T1, T2> 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<T1, T2> mp;     //map默认构造函数
	map<string, int> mp;

	//5、emppy();  //判断容器是否为空
	if (mp.empty())
	{
		//7、insert(elem)；//在容器中插入元素
		//插入方式一
		mp.insert(pair<string, int>("Tracy", 20));
		//插入方式二
		mp.insert(make_pair("Felix", 27));
		//插入方式三
		mp.insert(map<string, int>::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); //拷贝构造函数
	map<string, int> mp2(mp);
	cout << "---- 2、拷贝构造函数mp2元素：----" << endl;
	print(mp2);


	//3、map& operator=(const map& mp);  //重载运算符=
	map<string, int> mp3 = mp;
	cout << "---- 3、重载运算符=mp3元素：----" << endl;
	print(mp3);

	//12、find(key);  //查找key是否存在，若存在，返回该键的元素的迭代器，若不存在，返回map.end()
	map<string, int>::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(pair<string, int>("Timo ", 29));
	mp3.insert(pair<string, int>("Alice", 32));
	mp3.insert(pair<string, int>("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 <iostream>
#include <map>
using namespace std;

void print(const map<string, int>& mp)
{
	for (map<string, int>::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 map<string, int, MyCompare>& mp)
{
	for (map<string, int, MyCompare>::const_iterator it = mp.begin(); it != mp.end(); it++)
	{
		cout << "姓名：" << it->first << "，年龄：" << it->second << endl;
	}
}

int main()
{
	// STL - map - 排序 
	/*
		map根据键值自动排序，默认排序规则为升序，可以利用仿函数实现降序排序。
	*/

	//map根据键值自动排序，默认排序规则为升序
	map<string, int> 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);

	//利用仿函数实现降序排序
	map<string, int, 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