C++之STL整理（3）之map 用法（创建、赋值、方法）整理

<code> 注：整理一些突然学到的C++知识，随时mark一下

例如：忘记的关键字用法，新关键字，新数据结构

C++ 的map用法整理

C++之STL整理（3）之map 用法（创建、赋值、方法）整理一、map的初始化1、 map构造函数2、 map赋值操作（=，swap）3、 map的容量（size、empty）

二、map的增删查改1、map插入数据元素操作2、map键值对value的修改使用下标操作符（operator[]）使用find方法和迭代器

3、map的删操作（erase、clear）

三 、指定键的排序规则四、pair结构总结

提示：本文为 C++ 中 map构造、赋值、接口 的写法和举例

一、map的初始化

STL 中的map是一个关联容器，它存储的元素都是键值对（key-value pair），并且根据键（key）自动排序的容器。map不允许键重复，每个键在map中只能出现一次。map容器的每一个元素都是一个pair结构（pair<t1,t2>）的数据。

以下对map的初始化用法及举例：

1、 map构造函数

默认构造函数

std::map<int, std::string> myMap; // 创建一个空的map，键类型为int，值类型为std::string

拷贝构造函数

std::map<int, std::string> myMap1 = { { 1, "one"}, { 2, "two"} };

std::map<int, std::string> myMap2(myMap1); // 使用myMap1初始化myMap2，myMap2现在包含myMap1的所有元素

2、 map赋值操作（=，swap）

重载等号操作符

std::map<int, std::string> myMap1 = { { 1, "one"}, { 2, "two"} };

std::map<int, std::string> myMap2;

myMap2 = myMap1; // 使用重载的等号操作符将myMap1的内容赋值给myMap2

swap函数

std::map<int, std::string> myMap1 = { { 1, "one"}, { 2, "two"} };

std::map<int, std::string> myMap2 = { { 3, "three"}, { 4, "four"} };

myMap1.swap(myMap2); // 交换myMap1和myMap2的内容，现在myMap1包含{3, "three"}, {4, "four"}，myMap2包含{1, "one"}, {2, "two"}

3、 map的容量（size、empty）

size函数

std::map<int, std::string> myMap = { { 1, "one"}, { 2, "two"}, { 3, "three"} };

std::size_t size = myMap.size(); // size现在是3，因为myMap中有3个元素

empty函数

std::map<int, std::string> myMap;

if (myMap.empty()) {

std::cout << "The map is empty." << std::endl; // 输出"The map is empty."，因为myMap是空的

} else {

std::cout << "The map is not empty." << std::endl;

}

这些函数展示了map的一些基本用法，包括创建map、添加元素、复制map、交换map内容以及查询map的大小和是否为空。map的键和值可以是任何数据类型，包括自定义类型，只要键类型支持比较操作即可

二、map的增删查改

以下是针对map插入和删除操作的示例代码：

1、map插入数据元素操作

#include <iostream>

#include <map>

#include <string>

int main() {

std::map<int, std::string> mapStu;

// 第一种 通过pair的方式插入对象

mapStu.insert(std::pair<int, std::string>(3, "小张"));

// 第二种 通过make_pair的方式插入对象（注意：您的示例中写成了inset，这是错误的，应该是insert）

mapStu.insert(std::make_pair(-1, "校长"));

// 第三种 通过value_type的方式插入对象

mapStu.insert(std::map<int, std::string>::value_type(1, "小李"));

// 第四种 通过数组的方式插入值

// 这种方式在键已存在时更新对应的值，在键不存在时插入新的键值对

mapStu[3] = "小刘"; // 注意：这会替换掉key为3的原始值"小张"

mapStu[5] = "小王";

// 输出map内容

for (const auto& kv : mapStu) {

std::cout << kv.first << ": " << kv.second << std::endl;

}

return 0;

}

2、map键值对value的修改

map容器中，改变某个键（key）对应的值（value）可以通过以下方式实现。

使用下标操作符（operator[]）

下标操作符可以用于访问或修改map中的元素。如果键已经存在，它会返回对应的引用，你可以直接通过这个引用修改值。如果键不存在，它会创建一个新的键值对，键为你提供的键，值为该类型的默认值。

std::map<int, std::string> mapStu;

mapStu[3] = "小张"; // 如果键3不存在，会创建一个新的键值对(3, "小张")

mapStu[3] = "小刘"; // 如果键3已经存在，会更新其对应的值为"小刘"

使用find方法和迭代器

首先，使用find方法查找键在map中的位置，然后检查返回的迭代器是否指向map的结束位置（即键是否不存在）。如果键存在，可以通过迭代器访问并修改其对应的值。

std::map<int, std::string> mapStu;

mapStu[3] = "小张";

// 使用find查找键3

auto it = mapStu.find(3);

if (it != mapStu.end()) {

// 键存在，修改其对应的值

it->second = "小刘";

} else {

// 键不存在，可以选择插入新的键值对

mapStu[3] = "小刘";

}

在这个例子中，it->second就是键为3的元素的值的引用，你可以直接给它赋新的值来修改它。

使用find方法则更加安全，因为它不会在你尝试修改不存在的键时创建新的键值对。

在大多数情况下，如果只是想修改现有键的值，并且确定该键一定存在，使用下标操作符可能是最简洁的方式。但如果你不确定键是否存在，或者不想在键不存在时创建新的键值对，那么使用find方法会更加合适。

3、map的删操作（erase、clear）

假设mapStu是一个map容器，则：

mapStu.clear(); //删所有

mapStu.erase(it);//删迭代器指定

mapStu.erase(beg, end);//删key区间

mapStu.erase(key1); //删key对应

#include <iostream>

#include <map>

#include <string>

int main() {

std::map<int, std::string> mapStu;

// 假设已经插入了一些元素

mapStu.insert(std::pair<int, std::string>(3, "小张"));

mapStu.insert(std::pair<int, std::string>(5, "小王"));

mapStu.insert(std::pair<int, std::string>(7, "小赵"));

// 删除所有元素

mapStu.clear();

std::cout << "After clear(): ";

for (const auto& kv : mapStu) {

std::cout << kv.first << ": " << kv.second << " ";

}

std::cout << std::endl;

// 重新插入一些元素

mapStu.insert(std::pair<int, std::string>(3, "小张"));

mapStu.insert(std::pair<int, std::string>(5, "小王"));

mapStu.insert(std::pair<int, std::string>(7, "小赵"));

// 删除指定迭代器所指的元素

auto it = mapStu.find(5);

if (it != mapStu.end()) {

mapStu.erase(it);

}

// 输出map内容

std::cout << "After erase(pos): ";

for (const auto& kv : mapStu) {

std::cout << kv.first << ": " << kv.second << " ";

}

std::cout << std::endl;

// 重新插入一些元素

mapStu.insert(std::pair<int, std::string>(3, "小张"));

mapStu.insert(std::pair<int, std::string>(5, "小王"));

mapStu.insert(std::pair<int, std::string>(7, "小赵"));

// 删除指定区间的元素

auto beg = mapStu.find(3);

auto end = mapStu.find(7);

mapStu.erase(beg, end); // 注意：这里删除的是[beg, end)区间

// 输出map内容

std::cout << "After erase(beg, end): ";

for (const auto& kv : mapStu) {

std::cout << kv.first << ": " << kv.second << " ";

}

std::cout << std::endl;

// 重新插入一些元素

mapStu.insert(std::pair<int, std::string>(3, "小张"));

mapStu.insert(std::pair<int, std::string>(5, "小王"));

// 删除指定key的元素

mapStu.erase(5);

// 输出map内容

std::cout << "After erase(keyElem): ";

for (const auto& kv : mapSt

三 、指定键的排序规则

std::map 默认是按照键（key）的升序进行排序的。然而，你可以通过提供自定义的比较函数或仿函数（functor）来改变这一排序规则。这里其实map的定义语法模板要填三个参数，map<T1,T2,R> ，第三个参数就是比较规则的函数（仿函数、lamda表达式、谓词等函数对象）

以下是一个例子，展示了如何使用std::greater仿函数来创建一个键为降序的map：

#include <map>

#include <string>

#include <iostream>

#include <functional> // 为了使用std::greater

int main() {

// 创建一个键为降序的map，使用std::greater<int>作为比较函数

std::map<int, std::string, std::greater<int>> mapStuDesc;

mapStuDesc[3] = "小张";

mapStuDesc[5] = "小王";

mapStuDesc[1] = "小李";

// 遍历map并输出元素

for (const auto& pair : mapStuDesc) {

std::cout << "键: " << pair.first << ", 值: " << pair.second << std::endl;

}

return 0;

}

在这个例子中，std::greater<int>是一个仿函数，它告诉map按照键的降序来存储元素。当你遍历这个map时，你会看到键是按照从大到小的顺序输出的。还可以创建自己的仿函数来实现更复杂的排序规则。例如，如果想要根据某个自定义的条件（假设是键的绝对值）来排序键，可以这样做：

struct MyCompare {

bool operator()(const int& a, const int& b) const {

// 在这里实现你的比较逻辑

// 例如，假设我们想要按照键的绝对值来排序

return std::abs(a) < std::abs(b);

}

};

int main() {

std::map<int, std::string, MyCompare> mapAbsDesc;

mapAbsDesc[-3] = "小张";

mapAbsDesc[5] = "小王";

mapAbsDesc[-1] = "小李";

// 遍历map并输出元素

for (const auto& pair : mapAbsDesc) {

std::cout << "键: " << pair.first << ", 值: " << pair.second << std::endl;

}

return 0;

}

在这个例子中，MyCompare是一个自定义的仿函数，它根据键的绝对值来进行比较。因此，当你遍历mapAbsDesc时，元素会按照键的绝对值的升序输出。

四、pair结构

pair 通常用于将两个值组合成一个单一的实体，以便可以作为一个整体进行传递或返回。std::pair 的两个元素可以是任何类型，包括基本数据类型（如 int、double 等）或自定义类型（如类、结构体等）。这两个元素分别被称为 first 和 second。

使用方法是先包含头文件：#include <utility>

定义和使用 std::pair：

std::pair<int, std::string> myPair;

myPair.first = 10;

myPair.second = "Hello";

使用 make_pair 函数创建 std::pair对象：

std::pair<int, std::string> myPair = std::make_pair(10, "Hello");

总结