【C++】STL——map的介绍和使用、map的构造函数、map的迭代器、map的容量和访问函数、map的增删查改函数_c++ map

1.map的介绍

map的介绍

  （1）map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。

  （2）在map中，键值key通常用于排序和惟一地标识元素，而值value中存储与此键值key关联的内容。键值key和值value的类型可能不同，并且在map的内部，key与value通过成员类型value_type绑定在一起，为其取别名称为pair:

    typedef pair<const key, T> value_type;

  （3）在内部，map中的元素总是按照键值key进行比较排序的。

  （4）map中通过键值访问单个元素的速度通常比unordered_map容器慢，但map允许根据顺序对元素进行直接迭代(即对map中的元素进行迭代时，可以得到一个有序的序列)。

  （5）map支持下标访问符，即在[]中放入key，就可以找到与key对应的value。

  （6）map通常被实现为二叉搜索树(更准确的说：平衡二叉搜索树。

              

2.map的使用

  map提供的模版参数列表：

  key: 键值对中key的类型

  T： 键值对中value的类型

  Compare: 比较器的类型， map中的元素是按照key来比较的，缺省情况下按照小于来比较，一般情况下(内置类型元素)该参数不需要传递，如果无法比较时(自定义类型)，需要用户自己显式传递比较规则(一般情况下按照函数指针或者仿函数来传递)

  Alloc：通过空间配置器来申请底层空间， 不需要用户传递，除非用户不想使用标准库提供的空间配置器

              

2.1map的构造函数

 
map提供了三种构造函数：

  以下是一些set构造函数的简单示例：

//1.默认构造函数：创建一个空的map对象。
std::map<int, std::string> myMap;
//通过传入键值对来创建map对象。
std::map<int, std::string> myMap = {{1, "apple"}, {2, "banana"}, {3, "orange"}};

//2.用迭代器构造：通过使用迭代器范围来构造map对象。
std::vector<std::pair<int, std::string>> vec = {{1, "apple"}, {2, "banana"}, {3, "orange"}};
std::map<int, std::string> myMap(vec.begin(), vec.end());

//3.拷贝构造函数：通过拷贝另一个map对象来创建一个新的map对象。
std::map<int, std::string> originalMap = {{1, "apple"}, {2, "banana"}, {3, "orange"}};
std::map<int, std::string> copiedMap(originalMap);
1
2
3
4
5
6
7
8
9
10
11
12

              

2.2map的迭代器

和set一样，map也有同样的迭代器：

map的迭代器的使用示例：

#include <iostream>
#include <map>

int main() {
    std::map<int, std::string> myMap = {{1, "apple"}, {2, "banana"}, {3, "orange"}};

    // 正向迭代器
    std::map<int, std::string>::iterator it;
    std::cout << "正向迭代器：" << std::endl;
    for (it = myMap.begin(); it != myMap.end(); ++it) {
        std::cout << it->first << ": " << it->second << std::endl;
    }

    // 逆向迭代器
    std::map<int, std::string>::reverse_iterator rit;
    std::cout << "逆向迭代器：" << std::endl;
    for (rit = myMap.rbegin(); rit != myMap.rend(); ++rit) {
        std::cout << rit->first << ": " << rit->second << std::endl;
    }

    // 常量迭代器
    std::map<int, std::string>::const_iterator cit;
    std::cout << "常量迭代器：" << std::endl;
    for (cit = myMap.cbegin(); cit != myMap.cend(); ++cit) {
        std::cout << cit->first << ": " << cit->second << std::endl;
    }

    return 0;
}

//正向迭代器：
//1: apple
//2: banana
//3: orange
//逆向迭代器：
//3: orange
//2: banana
//1: apple
//常量迭代器：
//1: apple
//2: banana
//3: orange
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

              

2.3map的容量和访问函数

  注意：在元素访问时，有一个与operator[]类似的操作at()(该函数不常用)函数，都是通过key找到与key对应的value然后返回其引用，不同的是：当key不存在时，operator[]用默认value与key构造键值对然后插入，返回该默认value，at()函数直接抛异常。

 

  map的容量和访问函数使用：

  在示例中，首先使用empty函数检查map是否为空，然后使用size函数获取map的大小。接下来，使用operator[]函数插入键值对到map中。再次使用empty函数和size函数检查map的状态。最后，使用operator[]函数访问map中的值。

#include <iostream>
#include <map>

int main() {
    std::map<int, std::string> myMap;

    // 使用empty函数检查map是否为空
    if (myMap.empty()) {
        std::cout << "Map is empty" << std::endl;
    } else {
        std::cout << "Map is not empty" << std::endl;
    }

    // 使用size函数获取map的大小
    std::cout << "Map size: " << myMap.size() << std::endl;

    // 使用operator[]函数插入键值对
    myMap[1] = "apple";
    myMap[2] = "banana";
    myMap[3] = "orange";

    // 再次使用empty函数检查map是否为空
    if (myMap.empty()) {
        std::cout << "Map is empty" << std::endl;
    } else {
        std::cout << "Map is not empty" << std::endl;
    }

    // 再次使用size函数获取map的大小
    std::cout << "Map size: " << myMap.size() << std::endl;

    // 使用operator[]函数访问map中的值
    std::cout << "Value at key 2: " << myMap[2] << std::endl;

    return 0;
}

//Map is empty
//Map size: 0
//Map is not empty
//Map size: 3
//Value at key 2: banana
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

              

2.4map的增删查改函数

  这里简单举例map的insert和erase:

#include <iostream>
#include <map>

int main() {
    std::map<int, std::string> myMap;

    // 使用insert函数插入键值对
    myMap.insert(std::make_pair(1, "apple"));
    myMap.insert(std::make_pair(2, "banana"));
    myMap.insert(std::make_pair(3, "orange"));

    // 打印插入后的map
    std::cout << "Map after insert:" << std::endl;
    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // 使用erase函数删除键值对
    myMap.erase(2);

    // 打印删除后的map
    std::cout << "Map after erase:" << std::endl;
    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

//Map after insert:
//1: apple
//2: banana
//3: orange
//Map after erase:
//1: apple
//3: orange
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36