• C++学习 --map

    目录

    1， 什么是map

    2， 创建map

    2-1， 标准数据类型

    2-2， 自定义数据类型

    2-3， 其他创建方式

    3， 操作map

    3-1， 赋值

    3-2， 插入元素(insert)

    3-2-1， 插入标准数据类型

    3-2-1， 插入自定义数据类型

    3-3， 查询元素

    3-3-1， 标准数据类型查询

    3-3-1-1，迭代器访问 

    3-3-1-2， 键访问

    3-3-2， 自定义数据类型查询

    3-3-2-1， 迭代器访问

    3-3-2-2， 键访问

    3-4， 移除元素

    3-4-1， 通过键移除

    3-4-2， 通过迭代器移除

    3-5， 清空

    3-6， 获取长度

    3-7， 查找元素

    3-8， 判断map是否为空

    3-9， 统计键数量

    3-10， map互换

    4， multimap

    1， 什么是map

    map中存储的元素是pair， 元素会根据pair的key自动升序排序， 通过key快速找到对应的value

    分为map和multimap两种， 前者不允许key重复， 后者允许key重复

    由于不是标准数据类型， 需要包含头文件#include 才能使用

    2， 创建map

    通过map<数据类型， 数据类型> 对象名， 可创建map， 数据类型可以是标准数据类型， 也可以是自定义类型

    2-1， 标准数据类型

    1. //map中元素键数据类型为string， 值数据类型为int
    2. mapint> m1;

    2-2， 自定义数据类型

    1. Myclass1 mc_1("张三", 10);
    2. Myclass2 mc_2("李四", 20);
    3. //map中元素键数据类型为MyClass， 值数据类型为MyClass2
    4. map m1;

    2-3， 其他创建方式

    1. //通过拷贝构造方式， 将一个已存在的m1， 拷贝给m2
    2. mapint> m2(m1);
    3. //通过迭代器方式， 将一个已存在的m1， 拷贝给m2
    4. //m1.begin()指向m1的第一个元素， m1.begin()指向m1的最后一个元素的下一个元素
    5. mapint> m3(m1.begin(), m1.end());

    3， 操作map

    3-1， 赋值

    由于map是一个容器， 只支持将一个map赋值给另外一个map

    1. mapint> m1;
    2. mapint> m2;
    3. m2 = m1;

    3-2， 插入元素(insert)

    通过对象名.insert(pair对象)， 向map中插入元素， 不支持虚插(push_back)

    3-2-1， 插入标准数据类型

    1. mapint> m1;
    2. //下面三种都可以插入数据
    3. //注意：只能插入pair对象
    4. m1.insert(pairint>("aaa", 1));
    5. m1.insert(make_pair("bbb", 2));
    6. m1.insert(mapint>::value_type("ccc", 3));

    3-2-1， 插入自定义数据类型

    1. //重定义仿函数， 注意后面加了const，是个常函数
    2. class MyCompare
    3. {
    4. public:
    5. 	bool operator()(const Myclass1& m1, const Myclass1& m2) const
    6. 	{
    7. 		return m1.m_name > m2.m_name;
    8. 	}
    9. };
    10.  
    11. Myclass1 mc_1("aaa", 1);
    12. Myclass2 mc_2("bbb", 2);
    13. //由于key值是自定义数据类型，这里需要重定义仿函数， 数据加上MyCompare
    14. map m1;
    15. //下面三种都可以插入数据
    16. //注意：只能插入pair对象
    17. m1.insert(pair(mc_1, mc_2));
    18. m1.insert(make_pair(mc_1, mc_2));
    19. m1.insert(map::value_type(mc_1, mc_2));

    3-3， 查询元素

    可通过迭代器或者对象名[key]的方式

    3-3-1， 标准数据类型查询

    3-3-1-1，迭代器访问 
    1. #include 
    2. #include 
    3. #include 
    4.  
    5. using namespace std;
    6.  
    7. void print_map(mapint>& m)
    8. {
    9. 	for (mapint>::iterator it = m.begin(); it != m.end(); it++)
    10. 	{
    11. 		cout << "键：" << it->first << " " << "值：" << it->second << endl;
    12. 	}
    13. }
    14.  
    15. int main()
    16. {
    17. 	mapint> m1;
    18. 	//下面三种都可以插入数据
    19. 	//注意：只能插入pair对象
    20. 	m1.insert(pairint>("aaa", 111));
    21. 	m1.insert(make_pair("bbb", 222));
    22. 	m1.insert(mapint>::value_type("ccc", 333));
    23.  
    24. 	print_map(m1);
    25.  
    26. 	system("pause");
    27.  
    28. 	return 0;
    29. }
    3-3-1-2， 键访问
    1. #include 
    2. #include 
    3. #include 
    4.  
    5. using namespace std;
    6.  
    7. int main()
    8. {
    9. 	mapint> m1;
    10. 	//下面三种都可以插入数据
    11. 	//注意：只能插入pair对象
    12. 	m1.insert(pairint>("aaa", 111));
    13. 	m1.insert(make_pair("bbb", 222));
    14. 	m1.insert(mapint>::value_type("ccc", 333));
    15.  
    16. 	cout << "通过键获取元素：" << m1["aaa"] << endl;
    17.  
    18. 	system("pause");
    19.  
    20. 	return 0;
    21. }

    3-3-2， 自定义数据类型查询

    3-3-2-1， 迭代器访问
    1. #include 
    2. #include 
    3. #include 
    4.  
    5. using namespace std;
    6.  
    7. class Myclass1
    8. {
    9. public:
    10. 	Myclass1(string name, int age) : m_name(name), m_age(age) {};
    11. 	string m_name;
    12. 	int m_age;
    13. };
    14.  
    15. class Myclass2
    16. {
    17. public:
    18. 	Myclass2(string name, int age) : m_name(name), m_age(age) {};
    19. 	string m_name;
    20. 	int m_age;
    21. };
    22.  
    23. //仿函数重载
    24. class MyCompare
    25. {
    26. public:
    27. 	bool operator()(const Myclass1& m1, const Myclass1& m2) const
    28. 	{
    29. 		return m1.m_name < m2.m_name;
    30. 	}
    31. };
    32.  
    33. //注意map中加上了MyCompare
    34. void print_map_1(map& m)
    35. {
    36. 	for (map::iterator it = m.begin(); it != m.end(); it++)
    37. 	{
    38. 		cout << "键：" << it->first.m_name << " " << it->first.m_age << endl;
    39. 		cout << "值：" << it->second.m_name << " " << it->first.m_age << endl;
    40. 	}
    41. }
    42.  
    43. int main()
    44. {
    45. 	Myclass1 mc_1("aaa", 1);
    46. 	Myclass2 mc_2("bbb", 2);
    47. 	Myclass1 mc_3("ccc", 3);
    48. 	Myclass2 mc_4("ddd", 4);
    49. 	Myclass1 mc_5("eee", 5);
    50. 	Myclass2 mc_6("fff", 6);
    51. 	//由于key值是自定义数据类型，这里需要重定义仿函数， 数据加上MyCompare
    52. 	map m1;
    53. 	//下面三种都可以插入数据
    54. 	//注意：只能插入pair对象
    55. 	m1.insert(pair(mc_1, mc_2));
    56. 	m1.insert(make_pair(mc_3, mc_4));
    57. 	m1.insert(map::value_type(mc_5, mc_6));
    58.  
    59. 	print_map_1(m1);
    60. 	system("pause");
    61.  
    62. 	return 0;
    63. }
    64.
    3-3-2-2， 键访问

    在已知键的情况下， 通过对象名[键]， 获取元素

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. using namespace std;
    6.  
    7. class Myclass1
    8. {
    9. public:
    10. 	//通过键获取元素，需定义默认构造函数：Myclass1() {}
    11. 	Myclass1() {};
    12. 	Myclass1(string name, int age) : m_name(name), m_age(age) {};
    13. 	string m_name;
    14. 	int m_age;
    15. };
    16.  
    17. class Myclass2
    18. {
    19. public:
    20. 	//通过键获取元素，需定义默认构造函数：Myclass1() {}
    21. 	Myclass2() {};
    22. 	Myclass2(string name, int age) : m_name(name), m_age(age) {};
    23. 	string m_name;
    24. 	int m_age;
    25. };
    26.  
    27. //仿函数重载
    28. class MyCompare
    29. {
    30. public:
    31. 	bool operator()(const Myclass1& m1, const Myclass1& m2) const
    32. 	{
    33. 		return m1.m_name < m2.m_name;
    34. 	}
    35. };
    36.  
    37. int main()
    38. {
    39. 	Myclass1 mc_1("aaa", 1);
    40. 	Myclass2 mc_2("bbb", 2);
    41. 	Myclass1 mc_3("ccc", 3);
    42. 	Myclass2 mc_4("ddd", 4);
    43. 	Myclass1 mc_5("eee", 5);
    44. 	Myclass2 mc_6("fff", 6);
    45. 	//由于key值是自定义数据类型，这里需要重定义仿函数， 数据加上MyCompare
    46. 	map m1;
    47. 	//下面三种都可以插入数据
    48. 	//注意：只能插入pair对象
    49. 	m1.insert(pair(mc_1, mc_2));
    50. 	m1.insert(make_pair(mc_3, mc_4));
    51. 	m1.insert(map::value_type(mc_5, mc_6));
    52.     
    53.     //通过键访问
    54. 	cout << "通过键获取元素：" << m1[mc_3].m_name << " " << m1[mc_3].m_age << endl;
    55.  
    56. 	system("pause");
    57.  
    58. 	return 0;
    59. }
    60.

    3-4， 移除元素(erase)

    3-4-1， 通过键移除

    通过对象名.erase(键)， 指定从map中移除元素

    m1.erase("bbb");

    3-4-2， 通过迭代器移除

    通过对象名.erase(迭代器)， 指定从map中移除元素

    1. mapint>::iterator it = m1.begin();
    2. //移动迭代器的位置
    3. it = it++;
    4. m1.erase(it);

    3-5， 清空(clear)

    通过对象名.clear()， 清空map中的元素

    1. m1.clear();
    2. //通过指定迭代器区间进行清空
    3. m1.erase(m1.begin(), m1.end());

    3-6， 获取长度(size)

    通过对象名.size()， 获取map的元素个数

    m1.size();

    3-7， 查找元素(find)

    通过对象名.find(键)， 查找map中是否在存在元素， 存在返回对应iterator， 不存在返回对象名.end()

    1. //存在返回对应的iterator
    2. mapint>::iterator ret = m1.find("aaa");
    3.  
    4. if (ret != m1.end())
    5. {
    6. 	cout << "键：" << ret->first << " 值：" << ret->second << endl;
    7. }
    8. else
    9. {
    10. 	cout << "查找的键不存在" << endl;
    11. }

    3-8， 判断map是否为空(empty)

    通过对象名.empty()， 判断map是否为空， 为空返回1， 不为空返回0；

    m1.empty();

    3-9， 统计键数量(count)

    通过对象名.count(键)， 统计map中指定的键的个数，要么为1，要么为0

    m1.count("aaa");

    3-10， map互换(swap)

    通过对象名1.swap(对象名2)， 可交换两个map的元素

    m1.swap(m2);

    4， multimap

    通过multimap<数据类型， 数据类型> 对象名， 创建multimap， multimap支持键重复

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. using namespace std;
    6.  
    7. void print_map(multimapint>& m)
    8. {
    9. 	for (multimapint>::iterator it = m.begin(); it != m.end(); it++)
    10. 	{
    11. 		cout << "键：" << it->first << " " << "值：" << it->second << endl;
    12. 	}
    13. }
    14.  
    15. int main()
    16. {
    17. 	multimapint> mul_m1;
    18. 	mul_m1.insert(make_pair("aaa", 111));
    19. 	mul_m1.insert(make_pair("aaa", 112));
    20. 	mul_m1.insert(make_pair("aaa", 113));
    21.  
    22. 	print_map(mul_m1);
    23.  
    24. 	system("pause");
    25.  
    26. 	return 0;
    27. }

  • 相关阅读:
    【5GC】5G PDU会话以及会话类型
    STM32WB55的FUS更新及协议栈固件烧写方法
    主流MQ对比和选型
    ASP.NET CORE使用WebUploader对大文件分片上传,实时通知前端上传进度
    算法题：203. 移除链表元素（递归法、设置虚拟头节点法等3种方法）Java实现创建链表与解析链表
    [vue] vue2 Invalid Host header 解决问题
    【Linux】Linux常用操作命令(三)
    docker打包container成image，然后将image上传到docker hub
    Git工作原理
    Redis持久化(RDB AOF)
  • 原文地址：https://blog.csdn.net/qq_25500415/article/details/134484888