【C++关联式容器】map

秋秋晗晗

已于 2024-02-14 20:31:31 修改

阅读量865

点赞数

分类专栏： C++容器文章标签：数据结构

于 2023-04-25 17:44:56 首次发布

本文链接：https://blog.csdn.net/Qiuhan_909/article/details/130364286

版权

C++容器专栏收录该内容

12 篇文章 1 订阅

订阅专栏

map

1. pair类型

2. 关联式容器额外的类型别名

3. Member functions

3.1 constructor、destructor、operator=

3.1.1 constructor

3.1.2 destructor

3.1.3 operator=

3.2 Iterators

3.3 Capacity

3.3.1 empty

3.3.2 size

3.3.3 max_size

3.4 Element access

3.5 Modifiers

3.6 Observers

3.7 Operations

3.8 Allocator

map

template < class Key,                                     // map::key_type
           class T,                                       // map::mapped_type
           class Compare = less<Key>,                     // map::key_compare
           class Alloc = allocator<pair<const Key, T> >   // map::allocator_type
           > class map;

map是关联式容器，它按照特定的顺序存储由关键字值和映射值的组合形成的元素。

在map中，关键字值通常用于排序和唯一识别元素，而映射值则存储与此键相关的内容。关键字值和映射值的类型可能不同，在成员类型value_type中被组合在一起，它是一个结合了两者的pair类型：

typedef pair<const Key, T> value_type;

在内部，map中的元素总是按照它的关键字进行排序，遵循一个特定的严格的弱排序标准，由其内部的比较对象（类型为Compare）指示。

map容器通常比unordered_map容器按关键字访问单个元素的速度要慢，但是它们允许根据顺序直接迭代子集。

map中的映射值可以使用括号操作符（operator[]）直接通过其相应的关键字来访问。

map通常以二叉搜索树（准确地说，是红黑树）的形式实现。

map定义在头文件map和命名空间std中。

1. pair类型

pair定义在头文件utility和命名空间std中。

一个pair保存两个数据成员。类似容器，pair是一个用来生成特定类型的模板。当创建一个pair时，我们必须提供两个类型名，pair的数据成员将具有对应的类型。两个类型不要求一样：

pair<string, string> anon;       // 保存两个string
pair<string, size_t> word_count; // 保存一个string和一个size_t
pair<string, vector<int>> line;  // 保存string和vector<int>

pair的默认构造函数对数据成员进行值初始化。因此，anon是一个包含两个空string的pair，line保存一个空string和一个空vector。word_count中的size_t成员值为0，而string成员被初始化为空。

我们也可以为每个成员提供初始化器：

pair<string, string> author{ "James","Joyce" };

这条语句创建一个名为author的pair，两个成员被初始化为"James"和"Joyce"。

与其他标准库类型不同，pair的数据成员是public的。两个成员分别命名为first和second。我们用普通的成员访问符号来访问它们。

pair上的操作
pair<T1, T2> p;	p是一个pair，两个类型分别为T1和T2的成员都进行了值初始化
pair<T1, T2> p(v1, v2);	p是一个成员类型为T1和T2的pair first和second成员分别用v1和v2进行初始化
pair<T1, T2> p = { v1,v2 };	等价于pair<T1, T2> p(v1, v2);
make_pair(v1, v2)	返回一个用v1和v2初始化的pair pair的类型从v1和v2的类型推断出来
p.first	返回p的名为first的（公有）数据成员
p.second	返回p的名为second的（公有）数据成员
p1 relop p2	关系运算符（<、>、<=、>=）按字典序定义
p1 == p2 p1 != p2	当first和second成员分别相等时，两个pair相等相等性判断利用元素的==运算符实现

创建pair对象的函数：

想象有一个函数需要返回一个pair。在新标准下，我们可以对返回值进行列表初始化：

pair<string, int> process(vector<string>& v)
{
	// 处理v
	if (!v.empty())
		return { v.back(), v.back().size() }; // 列表初始化
	else
		return pair<string, int>(); // 隐式构造返回值
}

若v不为空，我们返回一个由v中最后一个string及其大小组成的pair。否则，隐式构造一个空pair，并返回它。

在较早的C++版本中，不允许用花括号包围的初始化器来返回pair这种类型的对象，必须显式构造返回值:

if (!v.empty())
	return pair<string, int>(v.back(), v.back().size());

我们还可以用make_pair来生成pair对象，pair的两个类型来自于make_pair的参数：

if (!v.empty())
	return make_pair(v.back(), v.back().size());

2. 关联式容器额外的类型别名

key_type	此容器类型的关键字类型
mapped_type	每个关键字关联的类型；只适用于map
value_type	对于set，与key_type相同对于map，为pair<const key_type, mapped_type>

对于set类型，key_type和value_type是一样的：set中保存的值就是关键字。在一个map中，元素是键值对。即，每个元素是一个pair对象，包含一个关键字和一个关联的值。由于我们不能改变一个元素的关键字，因此这些pair的关键字部分是const的：

set<string>::value_type vl;       // v1是一个string
set<string>::key_type v2;         // v2是一个string
map<string, int>::value_type v3;  // v3是一个pair<const string, int>
map<string, int>::key_type v4;    // v4是一个string
map<string, int>::mapped_type v5; // v5是一个int

与序列式容器一样，我们使用作用域运算符来提取一个类型的成员——例如，map<string, int>::key_type。

只有map类型（unordered_map、unordered_multimap、multimap和map）才定义了mapped_type。

3. Member functions

3.1 constructor、destructor、operator=

3.1.1 constructor

// empty (1)
explicit map(const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type());
explicit map(const allocator_type& alloc);
// range (2)
template <class InputIterator> map(InputIterator first, InputIterator last, const key_compare& comp = key_compare(), const allocator_type& = allocator_type());
// copy (3)
map(const map& x);
map(const map& x, const allocator_type& alloc);
// move (4)
map(map&& x);
map(map&& x, const allocator_type& alloc);
// initializer list (5)
map(initializer_list<value_type> il, const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type());

创建降序排序的空map：

#include <map>
#include <iostream>
using namespace std;

struct cmp
{
	bool operator()(const int e1, const int e2) const
	{
		return e1 > e2;
	}
};

int main()
{
	map<char, int, cmp> mp;

	// 插入
	mp.insert({ 'g',30 });
	mp.insert(make_pair('a', 10));
	mp.insert(pair<char, int>('f', 50));
	mp.insert(map<char, int>::value_type('h', 70));
	mp['b'];
	mp['d'] = 20;

	for (auto& [x, y] : mp) // C++17 结构化绑定
	{
		cout << x << " " << y << endl;
	}
	// h 70
	// g 30
	// f 50
	// d 20
	// b 0
	// a 10

	return 0;
}

3.1.2 destructor

~map();

3.1.3 operator=

// copy (1)
map& operator=(const map& x);
// move (2)
map& operator=(map&& x);
// initializer list (3)
map& operator=(initializer_list<value_type> il);

3.2 Iterators

// begin
iterator begin() noexcept;
const_iterator begin() const noexcept;
// end
iterator end() noexcept;
const_iterator end() const noexcept;
// rbegin
reverse_iterator rbegin() noexcept;
const_reverse_iterator rbegin() const noexcept;
// rend
reverse_iterator rend() noexcept;
const_reverse_iterator rend() const noexcept;
// cbegin
const_iterator cbegin() const noexcept;
// cend
const_iterator cend() const noexcept;
// crbegin
const_reverse_iterator crbegin() const noexcept;
// crend
const_reverse_iterator crend() const noexcept;

函数	功能
begin & end	begin返回一个迭代器，指向map中第一个元素 end返回一个迭代器，指向map中最后一个元素的下一个位置
rbegin & rend	rbegin返回一个反向迭代器，指向map中最后一个元素 rend返回一个反向迭代器，指向map中第一个元素的上一个位置
cbegin & cend	cbegin返回一个const迭代器，指向map中第一个元素 cend返回一个const迭代器，指向map中最后一个元素的下一个位置
crbegin & crend	crbegin返回一个const反向迭代器，指向map中最后一个元素 crend返回一个const反向迭代器，指向map中第一个元素的上一个位置

函数

功能

begin

end

begin返回一个迭代器，指向map中第一个元素

end返回一个迭代器，指向map中最后一个元素的下一个位置

rbegin

rend

rbegin返回一个反向迭代器，指向map中最后一个元素

rend返回一个反向迭代器，指向map中第一个元素的上一个位置

cbegin

cend

cbegin返回一个const迭代器，指向map中第一个元素

cend返回一个const迭代器，指向map中最后一个元素的下一个位置

crbegin

crend

crbegin返回一个const反向迭代器，指向map中最后一个元素

crend返回一个const反向迭代器，指向map中第一个元素的上一个位置

begin&end和rbegin&rend返回的迭代器指向：

const_iterator是一个指向const内容的迭代器。迭代器本身可以修改，但是它不能被用来修改它所指向的内容。

begin&end/rbegin&rend和cbegin&cend/crbegin&crend的不同：

begin&end/rbegin&rend的返回类型由对象是否是常量来决定。如果不是常量，返回iterator；如果是常量，返回const_iterator。
cbegin&cend/crbegin&crend的返回类型是const_iterator，不管对象本身是否是常量。

当解引用一个关联式容器迭代器时，我们会得到一个类型为容器的value_type的值的引用。对map而言，value_type是一个pair类型，其first成员保存const的关键字，second成员保存值。

必须记住，一个map的value_type是一个pair，我们可以改变pair的值，但不能改变关键字成员的值。

#include <iostream>
#include <map>
using namespace std;

int main()
{
	map<string, string> mp{ {"iterator", "迭代器"},{"begin","开始"},{"end", "结束"} };

	map<string, string>::iterator it = mp.begin();
	while (it != mp.end())
	{
		cout << it->first << " " << it->second << endl;
		// 等价于cout << (*it).first << " " << (*it).second << endl;
		++it;
	}
	// begin 开始
	// end 结束
	// iterator 迭代器

	auto rit = mp.rbegin();
	// map<string, string>::reverse_iterator rit = mp.rbegin();
	while (rit != mp.rend())
	{
		cout << rit->first << " " << rit->second << endl;
		// 等价于cout << (*rit).first << " " << (*rit).second << endl;
		++rit;
	}
	// iterator 迭代器
	// end 结束
	// begin 开始

	return 0;
}

3.3 Capacity