C++之STL的map容器

map

map的实现方式

set是一个有序的关联容器，是基于平衡二叉搜索树(红黑树)实现的，元素是有序的

map的用法

#include <iostream>
#include <map>
using namespace std;const int ADDSIZE = 20;
int main()
{map<int, int> m;cout << "还没有插入数据的时候的情况：" << endl;cout << "m的size为：" << m.size() << endl;cout << "m的max_size为：" << m.max_size() << endl << endl;for(int i = 1; i < ADDSIZE; ++i){auto retResult = m.insert({i, i});/*if(retResult.second){cout << "插入成功，插入的键是：" << retResult.first->first << "，插入的值是：" << retResult.first->second << endl;	}else{cout << "插入失败" << endl;	}*/}m.insert(make_pair(19, 20));		//键存在就不能插入//m[19] = 666;						//键存在就覆盖m[20] = 20;int insertValue = 20;try{auto atIt = m.at(insertValue);cout << atIt << endl;}catch(const out_of_range& e){cout << "没有键为" << insertValue << "的值" << endl;}cout << endl;cout << "1容器的元素为：" << endl;for(auto value : m){cout << "键为：" << value.first << ", 值为：" << value.second << endl;}cout << endl;auto it = m.find(6);if(it != m.end()){cout << "删除的值是：" << it->second << endl;auto it_ = m.erase(it);}cout << "2容器的元素为：" << endl;for(auto value : m){cout << "键为：" << value.first << ", 值为：" << value.second << endl;}cout << endl;return 0;
}

下面是map迭代器的用法

#include <iostream>
#include <map>
using namespace std;const int VALUE = 10;int main()
{map<int, int> m;m[1] = 1;m[2] = 2;m[3] = 3;m[4] = 4;m[5] = 5;//map普通迭代器的用法cout << "map普通迭代器的用法" << endl;for (map<int, int>::iterator it = m.begin(); it != m.end(); ++it) {cout << it->second << "\t";}cout << endl;//map常量迭代器的用法cout << "map常量迭代器的用法" << endl;for (map<int, int>::const_iterator cit = m.cbegin(); cit != m.cend(); ++cit) {cout << cit->second << "\t";}cout << endl;//map反向迭代器的用法cout << "map反向迭代器的用法" << endl;for (map<int, int>::reverse_iterator rit = m.rbegin(); rit != m.rend(); ++rit) {cout << rit->second << "\t";}cout << endl;//map常量反向迭代器的用法cout << "map常量反向迭代器的用法" << endl;for (map<int, int>::const_reverse_iterator crit = m.crbegin(); crit != m.crend(); ++crit) {cout << crit->second << "\t";}cout << endl << endl;for (map<int, int>::iterator it = m.begin(); it != m.end(); ) {cout << "*it的值为：" << it->second << endl;if (it->second == 3) {it = m.insert(it, make_pair(3 * VALUE, 3 * VALUE));}else if (it->second == 2) {//使用erase之后，返回的是下一个有效迭代器的值it = m.erase(it);//m.erase(it++);//m.erase(++it);	//不能这样使用，报错}else {++it;}}cout << "现在容器的元素为：" << endl;for (auto value : m) {cout << value.second << "\t";}cout << endl << endl;return 0;
}

插入不会使得任何迭代器失效，返回当前插入元素的迭代器，删除会使指向删除位置的迭代器失效，但是不会失效其他迭代器；erase(it)返回的是下一有效迭代器，也可以使用erase(it++)的方式；但是容器执行clear()的话，所以迭代器失效；

#include <iostream>
#include <map>
using namespace std;
const bool PRINT = true;
const int TESTVALUE = 2;
int main()
{if(PRINT || TESTVALUE == 1){map<int, int> m;m[1] = 1;m[3] = 3;m[4] = 4;map<int, int>::iterator it_1 = m.begin();map<int, int>::iterator it_1_ = m.end();map<int, int>::iterator it_2 = m.begin();it_2 = m.insert(it_2, {2, 2});for(; it_1 != it_1_; ++it_1){cout << it_1->first << "的值为：" << it_1->second << endl;	}cout << endl;}if(PRINT || TESTVALUE == 2){map<int, int> m;m[1] = 1;m[3] = 3;m[4] = 4;map<int, int>::iterator it_1 = m.begin();it_1++;//m.erase(it_1++);		//方式一it_1 = m.erase(it_1);	//方式二/*auto it = m.erase(it_1);cout << typeid(it).name() << endl;*/		for(; it_1 != m.end(); ++it_1){cout << it_1->first << "的值为：" << it_1->second << endl;	}cout << endl;}return 0;
}

map迭代器移动的方式如下：

#include <iostream>
#include <map>
#include <iterator>
using namespace std;int main()
{map<int, int> m;m[1] = 1; m[2] = 2; m[3] = 3; m[4] = 4; m[5] = 5;m[6] = 6; m[7] = 7; m[8] = 8; m[9] = 9; m[10] = 10;cout << "容器的元素为：" << endl;for(auto value : m){cout << "键为" << value.first << "的值是" << value.second << endl;	}cout << endl;map<int, int>::iterator it = m.begin();cout << "m.begin()的值为：" << it->second << endl;//it += 1;		//it = it + 1;		//不能这样使用++it;++it;			//前缀加加cout << "执行两次++it;后，*it的值为：" << it->second << endl;--it;			//前缀减减cout << "执行--it;后，*it的值为：" << it->second << endl;it++;			//后缀加加cout << "执行it++;后，*it的值为：" << it->second << endl;it--;			//后缀减减cout << "执行it--;后，*it的值为：" << it->second << endl;advance(it, 1);		//这个有可能越界的，可以先使用distance()计算cout << "执行advance(it, 1);后，*it的值为：" << it->second << endl;advance(it, -1);cout << "执行advance(it, -1);后，*it的值为：" << it->second << endl;cout << "distance(it, m.end())的值为：" << distance(it, m.end()) << endl;if (distance(it, m.end()) >= 10) {advance(it, 10);		//这样就不会溢出	}else {cout << "没有执行advance(it, 10);" << endl;}cout << "distance(m.begin(), it)的值为：" << distance(m.begin(), it) << endl;if (distance(m.begin(), it) >= 10) {advance(it, -10);}else {cout << "没有执行advance(it, -10);" << endl;}/*		//不能这样使用cout << "distance(it, m.begin())的值为：" << distance(it, m.begin()) << endl;if (distance(it, m.begin()) <= -10) {advance(it, -10);}else {cout << "没有执行advance(it, -10);" << endl;}*//*		不能这样使用cout << "distance(m.end(), it)的值为：" << distance(m.end(), it) << endl;if (distance(m.end(), it) <= -10) {advance(it, -10);}else {cout << "没有执行advance(it, -10);" << endl;}*/it = next(it, 1);		//第二个参数不能为负值if (it != m.end()) {cout << "执行next(it, 1);后，*it的值为：" << it->second << endl;}else {//抛出异常	}it = prev(it, 1);		//第二个参数不能为负值if (it == m.begin()) {//这里有可能真正的到达第一个迭代器，也有可能已经越界	}return 0;
}

其他的用法读者可以自己试着用一下，方法就写到这里啦，感想阅读

map的使用场景

1、数据检索和索引
2、映射和关联数组

最后给加一个chatgpt中STL的map的方法回答吧

在 C++ 中，`std::map` 是一个有序的关联容器，它将每个键（`key`）映射到一个值（`mapped_value`），并且按照键的顺序自动排序。`std::map` 不允许键重复，每个键只能对应一个值。它使用平衡二叉搜索树（通常是红黑树）来实现，因此在插入、删除和查找元素时具有对数时间复杂度。以下是 `std::map` 的所有成员函数，按类别整理：### 1. **构造函数与析构函数**- `map()`: 默认构造函数，创建一个空的映射。
- `explicit map(const Compare& comp, const Allocator& alloc = Allocator())`: 使用指定的比较函数（`Compare`）和分配器（`Allocator`）构造一个空的映射。
- `map(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& alloc = Allocator())`: 使用指定范围的元素构造一个映射。
- `map(const map& other)`: 拷贝构造函数，创建一个作为另一个映射副本的新映射。
- `map(map&& other) noexcept`: 移动构造函数，使用另一个映射的内容来初始化新映射。
- `map(std::initializer_list<value_type> init, const Compare& comp = Compare(), const Allocator& alloc = Allocator())`: 使用初始化列表来构造映射。
- `~map()`: 析构函数，销毁映射并释放内存。### 2. **赋值操作**- `map& operator=(const map& other)`: 拷贝赋值运算符。
- `map& operator=(map&& other) noexcept`: 移动赋值运算符。
- `map& operator=(std::initializer_list<value_type> ilist)`: 使用初始化列表赋值。### 3. **迭代器**`std::map` 提供了一些迭代器方法，用于遍历映射中的元素：- `iterator begin() noexcept`: 返回指向映射第一个元素的迭代器。
- `const_iterator begin() const noexcept`: 返回指向映射第一个元素的常量迭代器。
- `iterator end() noexcept`: 返回指向映射末尾的迭代器（指向一个比最后一个元素大的位置）。
- `const_iterator end() const noexcept`: 返回指向映射末尾的常量迭代器。
- `reverse_iterator rbegin() noexcept`: 返回指向映射末尾的逆向迭代器。
- `const_reverse_iterator rbegin() const noexcept`: 返回指向映射末尾的常量逆向迭代器。
- `reverse_iterator rend() noexcept`: 返回指向映射第一个元素前的位置的逆向迭代器。
- `const_reverse_iterator rend() const noexcept`: 返回指向映射第一个元素前的位置的常量逆向迭代器。
- `const_iterator cbegin() const noexcept`: 返回指向映射第一个元素的常量迭代器（不可修改）。
- `const_iterator cend() const noexcept`: 返回指向映射末尾的常量迭代器（不可修改）。
- `const_reverse_iterator crbegin() const noexcept`: 返回指向映射末尾的常量逆向迭代器（不可修改）。
- `const_reverse_iterator crend() const noexcept`: 返回指向映射第一个元素前的位置的常量逆向迭代器（不可修改）。### 4. **容量**- `bool empty() const noexcept`: 如果映射为空，则返回 `true`，否则返回 `false`。
- `size_type size() const noexcept`: 返回映射中元素的数量。
- `size_type max_size() const noexcept`: 返回映射可以容纳的最大元素数（由实现限制）。### 5. **访问元素**- `mapped_type& operator[](const key_type& k)`: 如果键 `k` 存在，返回对应的值；如果键 `k` 不存在，插入一个新的键值对，键为 `k`，值为默认构造的值，并返回值的引用。
- `mapped_type& operator[](key_type&& k)`: 如果键 `k` 存在，返回对应的值；如果键 `k` 不存在，插入一个新的键值对，键为 `k`，值为默认构造的值，并返回值的引用（右值引用版本）。
- `iterator find(const key_type& k)`: 查找具有指定键 `k` 的元素，返回该元素的迭代器，如果未找到返回 `end()`。
- `size_type count(const key_type& k) const`: 返回具有指定键 `k` 的元素数量。对于 `map`，这个值始终为 0 或 1。
- `iterator lower_bound(const key_type& k)`: 返回指向第一个不小于 `k` 的元素的迭代器。
- `iterator upper_bound(const key_type& k)`: 返回指向第一个大于 `k` 的元素的迭代器。
- `pair<iterator, iterator> equal_range(const key_type& k)`: 返回一个 `pair`，包含一个迭代器区间，表示所有等于 `k` 的元素（对于 `map`，该区间至多包含一个元素）。### 6. **修改器**- `pair<iterator, bool> insert(const value_type& value)`: 向映射中插入一个元素。如果键已经存在，则插入失败，返回 `false`。
- `pair<iterator, bool> insert(value_type&& value)`: 向映射中插入一个元素，使用右值引用插入。
- `iterator insert(const_iterator hint, const value_type& value)`: 使用指定位置的提示（`hint`）来插入一个元素。
- `iterator insert(const_iterator hint, value_type&& value)`: 使用指定位置的提示（`hint`）插入一个元素，使用右值引用插入。
- `template <class InputIterator> void insert(InputIterator first, InputIterator last)`: 插入一个范围内的元素。
- `void insert(std::initializer_list<value_type> ilist)`: 使用初始化列表插入多个元素。
- `iterator erase(const_iterator pos)`: 删除指定位置的元素。
- `iterator erase(const_iterator first, const_iterator last)`: 删除指定范围内的元素。
- `size_type erase(const key_type& k)`: 删除具有特定键值 `k` 的元素，返回删除的元素数量（最多为 1）。
- `void swap(map& other) noexcept`: 交换两个映射的内容。
- `void clear() noexcept`: 删除映射中的所有元素。### 7. **比较函数**- `key_compare key_comp() const`: 返回用于比较键值的函数对象。
- `value_compare value_comp() const`: 返回用于比较键值对的函数对象。### 8. **非成员函数**- `void swap(map<Key, T, Compare, Allocator>& lhs, map<Key, T, Compare, Allocator>& rhs) noexcept`: 交换两个映射的内容。### 9. **其他**- `iterator at(const key_type& k)`: 如果键 `k` 存在，返回对应的值的迭代器；如果键 `k` 不存在，抛出 `std::out_of_range` 异常。
- `const_iterator at(const key_type& k) const`: 如果键 `k` 存在，返回对应的值的常量迭代器；如果键 `k` 不存在，抛出 `std::out_of_range` 异常。### 10. **比较操作**- `bool operator==(const map& lhs, const map& rhs)`: 判断两个映射是否相等。
- `bool operator!=(const map& lhs, const map& rhs)`: 判断两个映射是否不相等。
- `bool operator<(const map& lhs, const map& rhs)`: 判断左映射是否小于右映射（根据键排序）。
- `bool operator<=(const map& lhs, const map& rhs)`: 判断左映射是否小于或等于右映射（根据键排序）。
- `bool operator>(const map& lhs, const map& rhs)`: 判断左映射是否大于右映射（根据键排序）。
- `bool operator>=(const map& lhs, const map& rhs)`: 判断左映射是否大于或等于右映射（根据键排序）。---### 总结`std::map` 是一个非常有用的关联容器，它通过键值对存储数据，并保持按键排序。它提供了高效的查找、插入和删除操作，并且保证了键的唯一性。使用 `std::map` 时，插入、删除和查找操作的时间复杂度为对数级别（O(log n)）。