【C++关联式容器】unordered_map

已于 2024-02-14 21:16:48 修改
阅读量894 收藏 25
点赞数 19
分类专栏： C++容器 文章标签： 数据结构 散列表 哈希算法
于 2024-02-14 20:10:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Qiuhan_909/article/details/136111360
版权

目录

unordered_map

1. pair类型

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

3. 哈希桶

4. 无序容器对关键字类型的要求

5. Member functions

5.1 constructor、destructor、operator=

5.1.1 constructor

5.1.2 destructor

5.1.3 operator= 

5.2 Capacity

​5.2.1 empty

5.2.2 size

5.2.3 max_size

5.3 Iterators

5.4 Element access

5.4.1 operator[]

5.4.2 at

5.5 Element lookup

5.5.1 find

5.5.2 count

5.5.3 equal_range

5.6 Modifiers

5.6.1 emplace

5.6.2 emplace_hint

5.6.3 insert

5.6.4 erase

5.6.5 clear

5.6.6 swap

5.7 Buckets

5.7.1 bucket_count

5.7.2 max_bucket_count

5.7.3 bucket_size

5.7.4 bucket

5.8 Hash policy

5.8.1 load_factor

5.8.2 max_load_factor

5.8.3 rehash

5.8.4 reserve

5.9 Observers

5.9.1 hash_function

5.9.2 key_eq

5.9.3 get_allocator

6. Non-member function overloads

6.1 operators

6.2 swap

7. unordered_map对象的插入方法

8. unordered_map对象的遍历方法

8.1 迭代器

8.2 范围for

unordered_map

template < class Key,                                    // unordered_map::key_type
           class T,                                      // unordered_map::mapped_type
           class Hash = hash<Key>,                       // unordered_map::hasher
           class Pred = equal_to<Key>,                   // unordered_map::key_equal
           class Alloc = allocator< pair<const Key, T> > // unordered_map::allocator_type
           > class unordered_map;

unordered_map是一种关联式容器，存储由键值和映射值组合而成的元素，允许根据键快速检索单个元素。

在unordered_map中，键值通常用于唯一标识元素，而映射值是与该键相关联的内容的对象。键和映射值的类型可能不同。

在内部，unordered_map中的元素并没有按照键或映射值的任何特定顺序排序，而是根据它们的哈希值组织成桶，以允许直接通过键值快速访问各个元素（平均时间复杂度是常数）。

在通过键访问单个元素时，unordered_map容器比map容器更快，尽管在通过其元素子集进行范围迭代时通常效率较低。

unordered_map实现了直接访问操作符（operator[]），允许使用其键值作为参数直接访问映射值。

容器中的迭代器至少是前向迭代器。

unordered_map定义在头文件unordered_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. 哈希桶

无序容器在存储上组织为一组桶，每个桶保存零个或多个元素。无序容器使用一个哈希函数将元素映射到桶。为了访问一个元素，容器首先计算元素的哈希值，它指出应该搜索哪个桶。容器将具有一个特定哈希值的所有元素都保存在相同的桶中。如果容器允许重复关键字，所有具有相同关键字的元素也都会在同一个桶中。因此，无序容器的性能依赖于哈希函数的质量和桶的数量和大小。

对于相同的参数，哈希函数必须总是产生相同的结果。理想情况下，哈希函数还能将每个特定的值映射到唯一的桶。但是，将不同关键字的元素映射到相同的桶也是允许的。当一个桶保存多个元素时，需要顺序搜索这些元素来查找我们想要的那个。计算一个元素的哈希值和在桶中搜索通常都是很快的操作。但是，如果一个桶中保存了很多元素，那么查找一个特定元素就需要大量比较操作。

4. 无序容器对关键字类型的要求

默认情况下，无序容器使用关键字类型的==运算符来比较元素，它们还使用一个hash<key_type>类型的对象来生成每个元素的哈希值。标准库为内置类型（包括指针）提供了hash模板。还为一些标准库类型，包括string和智能指针类型定义了hash。因此，我们可以直接定义关键字是内置类型（包括指针类型）、string还有智能指针类型的无序容器。

但是，我们不能直接定义关键字类型为自定义类类型的无序容器。与容器不同，不能直接使用哈希模板，而必须提供我们自己的hash模板版本。

5. Member functions

5.1 constructor、destructor、operator=

5.1.1 constructor

// empty (1)
explicit unordered_map(size_type n,
					   const hasher& hf = hasher(),
					   const key_equal& eql = key_equal(),
					   const allocator_type& alloc = allocator_type());
explicit unordered_map(const allocator_type& alloc);
// range (2)
template <class InputIterator>
unordered_map(InputIterator first, InputIterator last,
			  size_type n,
			  const hasher& hf = hasher(),
			  const key_equal& eql = key_equal(),
			  const allocator_type& alloc = allocator_type());
// copy (3)
unordered_map(const unordered_map& ump);
unordered_map(const unordered_map& ump, const allocator_type& alloc);
// move (4)
unordered_map(unordered_map&& ump);
unordered_map(unordered_map&& ump, const allocator_type& alloc);
// initializer list (5)
unordered_map(initializer_list<value_type> il,
			  size_type n,
			  const hasher& hf = hasher(),
			  const key_equal& eql = key_equal(),
			  const allocator_type& alloc = allocator_type());

// n表示初始桶的最小数量，不是容器中元素的数量

5.1.2 destructor

~unordered_map();

5.1.3 operator= 

// copy (1)
unordered_map& operator=(const unordered_map& ump);
// move (2)
unordered_map& operator=(unordered_map&& ump);
// initializer list (3)
unordered_map& operator=(intitializer_list<value_type> il);

5.2 Capacity

​5.2.1 empty

bool empty() const noexcept;
// 检测unordered_map是否为空，是返回true，否则返回false

5.2.2 size

size_type size() const noexcept;
// 返回unordered_map中元素的个数

5.2.3 max_size

size_type max_size() const noexcept;
// 返回unordered_map能够容纳的最大元素个数

5.3 Iterators

// begin
// container iterator (1)
iterator begin() noexcept;
const_iterator begin() const noexcept;
// bucket iterator (2)
local_iterator begin(size_type n);
const_local_iterator begin(size_type n) const;

// end
// container iterator (1)
iterator end() noexcept;
const_iterator end() const noexcept;
// bucket iterator (2)
local_iterator end(size_type n);
const_local_iterator end(size_type n) const;

// cbegin
// container iterator (1)
const_iterator cbegin() const noexcept;
// bucket iterator (2)
const_local_iterator cbegin(size_type n) const;

// cend
// container iterator (1)
const_iterator cend() const noexcept;
// bucket iterator (2)
const_local_iterator cend(size_type n) const;
函数功能

begin

&

end

(1)版本begin返回一个迭代器，指向unordered_map中第一个元素

(2)版本begin返回一个迭代器，指向unordered_map中桶n的第一个元素

(1)版本end返回一个迭代器，指向unordered_map中最后一个元素的下一个位置

(2)版本end返回一个迭代器，指向unordered_map中桶n的最后一个元素的下一个位置

cbegin

&

cend

(1)版本cbegin返回一个const迭代器，指向unordered_map中第一个元素

(2)版本cbegin返回一个const迭代器，指向unordered_map中桶n的第一个元素

(1)版本cend返回一个const迭代器，指向unordered_map中最后一个元素的下一个位置

(2)版本cend返回一个const迭代器，指向unordered_map中桶n的最后一个元素的下一个位置

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

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

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

    cout << "ump's buckets contain:" << endl;
    for (int i = 0; i < ump.bucket_count(); ++i)
    {
        cout << "bucket #" << i << " contains:";
        unordered_map<string, string>::local_iterator lit = ump.begin(i);
        while (lit != ump.end(i))
        {
            cout << " " << lit->first << " " << lit->second;
            // 等价于cout << " " << (*lit).first << " " << (*lit).second;
            ++lit;
        }
        cout << endl;
    }
    // ump's buckets contain:
    // bucket #0 contains:
    // bucket #1 contains:
    // bucket #2 contains: end 结束
    // bucket #3 contains:
    // bucket #4 contains:
    // bucket #5 contains:
    // bucket #6 contains: begin 开始
    // bucket #7 contains: iterator 迭代器

    return 0;
}

5.4 Element access

5.4.1 operator[]

mapped_type& operator[](const key_type& k);
mapped_type& operator[](key_type&& k);
// 如果k与某个元素的关键字相匹配，返回对其映射值的引用
// 如果k与任何元素的关键字不匹配，插入一个关键字为k的新元素，并返回对其映射值的引用

5.4.2 at

mapped_type& at(const key_type& k);
const mapped_type& at(const key_type& k) const;
// 如果k与某个元素的关键字相匹配，返回对其映射值的引用
// 如果k与任何元素的关键字不匹配，抛异常

Element access系列函数使用示例：​

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

int main()
{
	unordered_map<char, int> ump;

	ump['b'];      // 插入一个关键字为'b'的元素，但没有对映射值进行初始化
	ump['d'] = 20; // 插入一个关键字为'd'的元素，并将映射值初始化为20	
	cout << "ump['b'] = " << ump['b'] << endl; // ump['b'] = 0
	cout << "ump['d'] = " << ump['d'] << endl; // ump['d'] = 20

	ump['b'] = 50; // 修改关键字为'b'的元素的映射值为50
	cout << "ump['b'] = " << ump.at('b') << endl; // ump['b'] = 50
	cout << "ump['d'] = " << ump.at('d') << endl; // ump['d'] = 20

	return 0;
}

5.5 Element lookup

5.5.1 find

iterator find(const key_type& k);
const_iterator find(const key_type& k) const;
// 返回一个迭代器，指向第一个关键字为k的元素，若k不在容器中，则返回end迭代器

5.5.2 count

size_type count(const key_type& k) const;
// 返回关键字等于k的元素的数量
// 对于不允许重复关键字的容器，返回值永远是0或1
#include <unordered_map>
#include <iostream>
using namespace std;

int main()
{
	unordered_map<char, int> ump;
	ump.insert({ 'g',30 });
	ump.insert(make_pair('a', 10));
	ump.insert(pair<char, int>('f', 50));
	ump['b'];
	ump['d'] = 20;

	auto it = ump.find('f');
	if (it != ump.end())
	{
		cout << "f在unordered_map中" << endl;
	}
	else
	{
		cout << "f不在unordered_map中" << endl;
	}
	// f在unordered_map中

	it = ump.find('h');
	if (it != ump.end())
	{
		cout << "h在unordered_map中" << endl;
	}
	else
	{
		cout << "h不在unordered_map中" << endl;
	}
	// h不在unordered_map中

	if (ump.count('a'))
	{
		cout << "a在unordered_map中" << endl;
	}
	else
	{
		cout << "a不在unordered_map中" << endl;
	}
	// a在unordered_map中

	if (ump.count('c'))
	{
		cout << "c在unordered_map中" << endl;
	}
	else
	{
		cout << "c不在unordered_map中" << endl;
	}
	// c不在unordered_map中

	return 0;
}

5.5.3 equal_range

pair<iterator, iterator> equal_range(const key_type& k);
pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
// 返回一个迭代器pair，表示关键字等于k的元素的范围（左闭右开的区间）
// 若k不存在，pair的两个成员均为end迭代器
// 对于不允许重复关键字的容器，返回的范围最多只包含一个元素

5.6 Modifiers

5.6.1 emplace

template <class... Args> pair<iterator, bool> emplace(Args&&... args);
// 对应insert，区别是：
// 当调用insert时，我们将元素类型的对象传递给它们，这些对象被拷贝到容器中
// 当调用emplace时，则是将参数传递给元素类型的构造函数，然后使用这些参数在容器管理的内存空间中直接构造元素

5.6.2 emplace_hint

template <class... Args> iterator emplace_hint(const_iterator position, Args&&... args);
// 对应insert的(3)和(4)，区别是：
// 当调用insert时，我们将元素类型的对象传递给它们，这些对象被拷贝到容器中
// 当调用emplace时，则是将参数传递给元素类型的构造函数，然后使用这些参数在容器管理的内存空间中直接构造元素

5.6.3 insert

// (1) 成功返回pair<插入位置, true>，失败返回pair<插入位置, false>
pair<iterator, bool> insert(const value_type& val);
// (2)
template <class P> pair<iterator, bool> insert(P&& val);
// (3)
iterator insert(const_iterator hint, const value_type& val);
// (4)
template <class P> iterator insert(const_iterator hint, P&& val);
// (5)
template <class InputIterator> void insert(InputIterator first, InputIterator last);
// (6)
void insert(initializer_list<value_type> il);

// 插入

5.6.4 erase

// by position(1)
iterator erase(const_iterator position);
// by key(2)
size_type erase(const key_type& k);
// range(3)
iterator erase(const_iterator first, const_iterator last);

// 删除

5.6.5 clear

void clear() noexcept;
// 清空

5.6.6 swap

void swap(unordered_map& ump);
// 交换

5.7 Buckets

5.7.1 bucket_count

size_type bucket_count() const noexcept;
// 返回unordered_map中桶的个数

5.7.2 max_bucket_count

size_type max_bucket_count() const noexcept;
// 返回unordered_map能够容纳的最大桶个数

5.7.3 bucket_size

size_type bucket_size(size_type n) const;
// 返回桶n中元素的个数

5.7.4 bucket

size_type bucket(const key_type& k) const;
// 返回关键字为k的元素所在的桶号

5.8 Hash policy

5.8.1 load_factor

float load_factor() const noexcept;
// 返回负载因子（每个桶平均元素的数量，元素的数量/桶的数量）

5.8.2 max_load_factor

// get(1)
float max_load_factor() const noexcept;
// set(2)
void max_load_factor(float z);

// 获取或设置最大负载因子

5.8.3 rehash

void rehash(size_type n);
// 设置桶的数量

5.8.4 reserve

void reserve(size_type n);
// 将桶数设置为最适合包含至少n个元素的桶数

5.9 Observers

5.9.1 hash_function

hasher hash_function() const;
// 返回哈希函数

5.9.2 key_eq

key_equal key_eq() const;
// 返回关键字等价比较谓词

5.9.3 get_allocator

allocator_type get_allocator() const noexcept;
// 返回空间配置器

6. Non-member function overloads

6.1 operators

// equality (1)
template <class Key, class T, class Hash, class Pred, class Alloc>
bool operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& lhs, const unordered_map<Key, T, Hash, Pred, Alloc>& rhs);
// inequality (2)
template <class Key, class T, class Hash, class Pred, class Alloc>
bool operator!=(const unordered_map<Key, T, Hash, Pred, Alloc>& lhs, const unordered_map<Key, T, Hash, Pred, Alloc>& rhs);

6.2 swap

template <class Key, class T, class Hash, class Pred, class Alloc>
void swap(unordered_map<Key, T, Hash, Pred, Alloc>& lhs, unordered_map<Key, T, Hash, Pred, Alloc>& rhs);

7. unordered_map对象的插入方法

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

int main()
{
	unordered_map<char, int> ump;

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

	for (auto& e : ump)
	{
		cout << e.first << " " << e.second << endl;
	}
	// g 30
	// a 10
	// f 50
	// h 70
	// b 0
	// d 20

	return 0;
}

8. unordered_map对象的遍历方法

8.1 迭代器

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

int main()
{
	unordered_map<char, int> ump;

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

	unordered_map<char, int>::iterator it = ump.begin();
	while (it != ump.end())
	{
		cout << it->first << " " << it->second << endl;
		++it;
	}
	// g 30
	// a 10
	// f 50
	// h 70
	// b 0
	// d 20

	return 0;
}

8.2 范围for

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

int main()
{
	unordered_map<char, int> ump;

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

	for (auto& e : ump)
	{
		cout << e.first << " " << e.second << endl;
	}
	// g 30
	// a 10
	// f 50
	// h 70
	// b 0
	// d 20

	return 0;
}
#include <unordered_map>
#include <iostream>
using namespace std;

int main()
{
	unordered_map<char, int> ump;

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

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

	return 0;
}
秋秋晗晗
关注
  • 19
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL【容器】| 【11】unordered_map
weixin_45926547的博客
04-06 568
文章目录一、unordered_map1、常用成员函数2、案例 一、unordered_map 无序映射是存储由key和映value组合形成的元素的关联容器，并且允许基于键快速检索单个元素素； 采用哈希桶的数据结构； 桶是内部哈希表中的一个槽，元素根据哈希函数计算的哈希值分配给该槽； 桶的数量直接影响哈希表的负载因子——碰撞的概率； 增加桶的数量时都会导致重新散列； template < class Key, // u
C++中unordered_map常用操作
m0_67394002的博客
04-14 3419
unordered_map介绍 unordered_map记录元素的hash值，根据hash值判断元素是否相同。map相当于java中的TreeMap，unordered_map相当于HashMap。无论从查找、插入上来说，unordered_map的效率都优于hash_map，更优于map；而空间复杂度方面，hash_map最低，unordered_map次之，map最大。 unordered_map与map的对比 存储时是根据key的hash值判断元素是否相同，即unordered_map内部元素是无序
[c++]-unordered_map用法及成员方法
ai_faker的博客
06-08 5347
创建C++ unordered_map容器的方法 1)通过调用 unordered_map 模板类的默认构造函数，可以创建空的 unordered_map 容器。比如： std::unordered_map<std::string, std::string> umap; 由此，就创建好了一个可存储 <string,string> 类型键值对的 unordered_map 容器。 2) 当然，在创建 unordered_map 容器的同时，可以完成初始化操作。比如： std::uno
C++/C--unordered_map常见用法详解
Jensen Lee的博客
04-14 9590
文章目录1. std::unordered_map 的定义与特性2. 构造 std::unordered_map3. 赋值操作4. 迭代器操作5. 容量操作6. 访问操作7. 插入操作8. 删除操作9. 查找操作 1. std::unordered_map 的定义与特性 所在头文件：<unordered_map> std::unorederd_map类模板： templat...
C++: unordered_map常见用法
道纪书生的博客
08-26 8810
1. 头文件 #include <unordered_map> 2. 初始化 unordered_map<char, int>; 3. 插入元素 //数组形式 map['a'] = 1; //直接插入 map.insert( { {'b',2} , {'c',3} } ); 4. 修改元素 map['a'] = 0; 5. 删除元素 //删除key为'a'的元素 map.erase('a'); //删除第一个元素 map.erase(map.begi
C++顺序容器，容器适配器，关联容器的操作
10-18
包括顺序容器vector，string，list，forward，deque ，array；容器适配器stack，queue，priority_queue以及关联容器map，set，multimap，unordered_multimap等的增删查改操作。
C++之STL标准库容器成员一览表.pdf
08-25
本文将对C++ STL标准库容器成员进行概述，包括array、vector、deque、list、forward_list、string、set、multiset、map、multimap、unordered_set、unordered_multiset、unordered_map、unordered_multimap等容器的...
C++ STL库知识总结
02-17
关联容器如set、multiset、map和multimap，元素按特定键值排序，其中map和multimap允许键值重复。此外，还有unordered_系列容器，如unordered_set和unordered_map，它们基于哈希表实现，提供快速的查找速度。 分配...
C++ STL 和 泛型编程1
08-03
关联容器包括`set`、`map`、`multiset`和`multimap`，它们按某种排序规则存储键值对，其中`multiset`和`multimap`允许键的重复。 无序容器如`unordered_set`和`unordered_map`是基于哈希表的数据结构，提供快速的...
c++参考手册 2018版
03-29
map − unordered_map (C++11) priority_queue − span (C++20) 其他容器： 顺序 − 关联 无序关联 − 适配器 迭代器库 范围库 (C++20) 算法库 数值库 常用数学函数 特殊数学函数 (C++17) 数值算法 伪随机...
unordered_set/map（哈希表）干货归纳+用法详解
lzq8090的博客
03-27 3439
C++哈希表（hash table）是一种数据结构，用于存储和查找键值对。它是由一个哈希函数和一个数组组成的。哈希函数将键映射到数组中的一个位置，这个位置就是键值对应的索引。
【C++】STL—— unordered_map的介绍和使用、 unordered_map的构造函数和迭代器、 unordered_map的增删查改函数
最新发布
Crocodile1006的博客
09-17 7147
STL、哈希、unordered_map的介绍、unordered_map的使用、unordered_map的构造函数、unordered_map的迭代器、unordered_map的容量和访问函数、unordered_map的增删查改函数
【C++】unordered系列容器
BebopPrimer的博客
07-10 491
【C++】unordered系列容器
unordered_map详解和性能分析
热门推荐
上官宏竹的专栏
03-12 1万+
std::unordered_map是C++标准库中的一个关联容器，它可以存储一组键值对，并且支持快速的查找、插入和删除操作。class Ty,std::hash是一个模板类，它接受一个类型参数T，用于指定需要哈希的对象类型。还提供了一个函数调用运算符（operator()），用于计算对象的哈希值。perator()接受一个常量引用key，用于指定需要计算哈希值的对象。它返回一个类型的哈希值，表示对象在哈希表中的桶位置。实现一个哈希函数。
c++ unordered_map容器函数说明
Mr____DAI的博客
03-16 387
【代码】c++ unordered_map容器函数说明。
unordered_map详解
qq_44423388的博客
09-13 1万+
unordered_map 是关联容器，含有带唯一键的键(key;it->first)-值(value;it->second) pair 。搜索、插入和元素移除拥有平均常数时间复杂度。 元素在内部不以任何特定顺序排序，而是组织进桶中。元素放进哪个桶完全依赖于其键的哈希。这允许对单独元素的快速访问，因为一旦计算哈希，则它准确指代元素所放进的桶。
STL(十一)---无序容器（Unordered Container）
浩海烟云的博客
09-01 273
简介 在头文件<unordered_set>和<unordered_map> 中定义 namespace std { template <typename T, typename Hash = hash<T>, typename EqPred = equal_to<T>, ...
算法笔记 [C++标准模板库(STL)介绍]
liuxiaocs7的博客
04-12 285
6.1 vector的常见用法详解 Vector 向量 变长数组 以邻接表的方式存储图 可以通过下标或者通过迭代器的方法访问 begin()函数取首元素地址，end() 函数取尾元素地址的下一个地址 两种遍历方法 通过下标访问 通过迭代器访问 STL中只有 vector 和 string 中允许使用vi.begin()+n(n为整数)这种写法 常用方法: push_back() ...
C++ STL unordered_map
yearning_mjw的博客
11-28 601
个人学习记录
unordered_map emplace
04-09
unordered_map emplace是一个用于向无序映射表（unordered_map）中插入元素的函数。该函数会在无序映射表中寻找相应的键，如果找到则修改其对应的值，否则新建一个键值对加入到无序映射表中。与insert函数相比，emplace函数不需要创建额外的临时对象，因此可以更高效地操作无序映射表。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值