容器库(11)-std::unordered_map

Lucy_stone

于 2024-02-25 21:11:40 发布

阅读量1k

点赞数 26

分类专栏： c++标准库基础文章标签： c++ 标准库 unordered_map 容器

本文链接：https://blog.csdn.net/Lucy_stone/article/details/136213286

版权

c++标准库基础专栏收录该内容

33 篇文章 0 订阅

订阅专栏

unordered_map是含有唯一key的键值对的无序关联容器，搜索、移除和插入操作是平均常数的时间复杂度。unordered_map在内部没有按任何顺序排列，而是放在桶当中的，放进哪个桶是通过计算key的hash值来决定的。

template<
    class Key,
    class T,
    class Hash = std::hash<Key>,
    class KeyEqual = std::equal_to<Key>,
    class Allocator = std::allocator<std::pair<const Key, T>>
> class unordered_map;

本文章的代码库：

https://gitee.com/gamestorm577/CppStd

成员函数

构造、析构和赋值

构造函数

可以构造一个空的unordered_map，也可以用迭代器、另一个unordered_map或者元素列表来构造一个unordered_set。构造的时候还可以指定最小桶数、hash函数、比较函数或者分配器。代码示例：

std::unordered_map<int, float> m1;
std::unordered_map<int, float> m2{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}};
std::unordered_map<int, float> m3(m2);
std::unordered_map<int, float> m4(m2.begin(), std::next(m2.begin(), 2));

std::cout << "m1 size = " << m1.size() << std::endl;
std::cout << "m2 size = " << m2.size() << std::endl;
std::cout << "m3 size = " << m3.size() << std::endl;
std::cout << "m4 size = " << m4.size() << std::endl;

输出结果：

m1 size = 0
m2 size = 3
m3 size = 3
m4 size = 2

对于自定义的类型，需要定义hash函数以及比较函数。代码示例：

struct MyStruct
{
    int Num1;
    double Num2;
};

struct MyHash
{
    std::size_t operator()(const MyStruct& val) const
    {
        return std::hash<int>()(val.Num1) + std::hash<double>()(val.Num2);
    }
};

struct MyEqual
{
    bool operator()(const MyStruct& lhs, const MyStruct& rhs) const
    {
        return true;
    }
};

std::unordered_map<MyStruct, int, MyHash, MyEqual> m;

析构函数

销毁unordered_map时，会调用各元素的析构函数。代码示例：

struct MyStruct
{
    MyStruct(int i)
        : Num(i)
    {
    }

    ~MyStruct()
    {
        std::cout << "destruct, Num = " << Num << std::endl;
    }

    int Num = 0;
};

struct MyHash
{
    std::size_t operator()(const MyStruct& val) const
    {
        return std::hash<int>()(val.Num);
    }
};

struct MyEqual
{
    bool operator()(const MyStruct& lhs, const MyStruct& rhs) const
    {
        return lhs.Num == rhs.Num;
    }
};

std::unordered_map<MyStruct, float, MyHash, MyEqual> m;
m.emplace(MyStruct(1), 1.1f);
m.emplace(MyStruct(2), 2.1f);
m.emplace(MyStruct(3), 3.1f);
std::cout << "end" << std::endl;

输出结果：

destruct, Num = 1
destruct, Num = 2
destruct, Num = 3
end
destruct, Num = 3
destruct, Num = 2
destruct, Num = 1

赋值函数

可以用另一个unordered_map或者元素列表给unordered_map赋值。代码示例：

std::unordered_map<int, float> tmp{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}};
std::unordered_map<int, float> m1;
std::unordered_map<int, float> m2;
m1 = tmp;
m2 = {{1, 1.1f}, {2, 1.2f}};
std::cout << "m1 size = " << m1.size() << std::endl;
std::cout << "m2 size = " << m2.size() << std::endl;

输出结果：

m1 size = 3
m2 size = 2

迭代器

接口begin、cbegin指向unordered_map起始的迭代器，end、cend指向末尾的迭代器。代码示例：

std::unordered_map<int, float> tmp{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}};
for (auto iter = tmp.begin(); iter != tmp.end(); ++iter)
{
    iter->second += 10.f;
}

for (auto iter = tmp.cbegin(); iter != tmp.cend(); ++iter)
{
    std::cout << "value = " << iter->second << std::endl;
}

输出结果：

value = 11.3
value = 11.2
value = 11.1

容量

empty

检查容器是否为空。代码示例：

std::unordered_map<int, float> m1{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}};
std::unordered_map<int, float> m2;
std::cout << std::boolalpha;
std::cout << "m1 empty: " << m1.empty() << std::endl;
std::cout << "m2 empty: " << m2.empty() << std::endl;

输出结果：

m1 empty: false
m2 empty: true

size

返回容器的元素个数。代码示例：

std::unordered_map<int, float> m1{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}};
std::unordered_map<int, float> m2;
std::cout << "m1 size: " << m1.size() << std::endl;
std::cout << "m2 size: " << m2.size() << std::endl;

输出结果：

m1 size: 3
m2 size: 0

max_size

返回容器可容纳的最大元素个数。代码示例：

std::unordered_map<char, char> m1;
std::unordered_map<double, double> m2;
std::cout << "m1 max size = " << m1.max_size() << std::endl;
std::cout << "m2 max size = " << m2.max_size() << std::endl;

输出结果：

m1 max size = 768614336404564650
m2 max size = 576460752303423487

修改器

clear

清除所有的元素。代码示例：

std::unordered_map<int, float> m{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}};
std::cout << "m size = " << m.size() << std::endl;
m.clear();
std::cout << "m size = " << m.size() << std::endl;

输出结果：

m size = 3
m size = 0

insert

插入元素，参数可以是元素、迭代器或者元素节点。代码示例：

std::unordered_map<int, float> m1{{1, 1.1f}, {2, 1.2f}};
std::unordered_map<int, float> m2{{3, 1.1f}, {4, 1.2f}};
std::cout << "m1 size = " << m1.size() << std::endl;
m1.insert(m2.begin(), m2.end());
std::cout << "m1 size = " << m1.size() << std::endl;
m1.insert({5, 1.2f});
std::cout << "m1 size = " << m1.size() << std::endl;

输出结果：

m1 size = 2
m1 size = 4
m1 size = 5

insert_or_assign

插入元素，如果和给定key值相同的元素以及存在，那么对该元素重新赋值。代码示例：

std::unordered_map<int, float> m{{1, 1.1f}, {2, 1.2f}};
m.insert_or_assign(3, 1.3f);
m.insert_or_assign(2, 21.3f);
for (auto& [key, value] : m)
{
    std::cout << "key: " << key << ", value: " << value << std::endl;
}

输出结果：

key: 3, value: 1.3
key: 2, value: 21.3
key: 1, value: 1.1

emplace

如果容器中没有给定的key值，那么将元素构造到容器中。代码示例：

std::unordered_map<int, float> m{{1, 1.1f}, {2, 1.2f}};
m.emplace(1, 1.5f);
m.emplace(3, 1.5f);
for (auto& [key, value] : m)
{
    std::cout << "key: " << key << ", value: " << value << std::endl;
}

输出结果：

key: 3, value: 1.5
key: 2, value: 1.2
key: 1, value: 1.1

emplace_hint

向容器中尽可能靠近hint之前的位置插入新元素：

template <class... Args>
iterator emplace_hint(const_iterator hint, Args&&... args);

不同的hint会导致插入元素的效率不同。代码示例：

auto timer = [](std::function<std::size_t()> func, std::string tag) -> void
{
    auto start = std::chrono::system_clock::now();
    std::size_t size = func();
    auto end = std::chrono::system_clock::now();
    std::chrono::duration<double, std::milli> time = end - start;
    std::cout << tag << ", size: " << size << ", use time: " << time.count()
              << std::endl;
};

const int count = 1000000;

auto unordered_map_emplace = [=]() -> std::size_t
{
    std::unordered_map<int, float> m;
    for (int i = 0; i < count; ++i)
    {
        m.emplace(i, 1.1f);
    }
    return m.size();
};

auto unordered_map_emplace_hint1 = [=]() -> std::size_t
{
    std::unordered_map<int, float> m;
    auto iter = m.begin();
    for (int i = 0; i < count; ++i)
    {
        m.emplace_hint(iter, i, 1.1f);
        iter = m.end();
    }
    return m.size();
};

auto unordered_map_emplace_hint2 = [=]() -> std::size_t
{
    std::unordered_map<int, float> m;
    auto iter = m.begin();
    for (int i = 0; i < count; ++i)
    {
        m.emplace_hint(iter, i, 1.1f);
        iter = m.begin();
    }
    return m.size();
};

auto unordered_map_emplace_hint3 = [=]() -> std::size_t
{
    std::unordered_map<int, float> m;
    auto iter = m.begin();
    for (int i = 0; i < count; ++i)
    {
        iter = m.emplace_hint(iter, i, 1.1f);
    }
    return m.size();
};

timer(unordered_map_emplace, "unordered_map_emplace");
timer(unordered_map_emplace_hint1, "unordered_map_emplace_hint1");
timer(unordered_map_emplace_hint2, "unordered_map_emplace_hint2");
timer(unordered_map_emplace_hint3, "unordered_map_emplace_hint3");

输出结果：

unordered_map_emplace, size: 1000000, use time: 182.061
unordered_map_emplace_hint1, size: 1000000, use time: 193.999
unordered_map_emplace_hint2, size: 1000000, use time: 198.093
unordered_map_emplace_hint3, size: 1000000, use time: 189.81

try_emplace

插入元素，如果key值已经存在，则不做任何事。代码示例：

std::unordered_map<int, float> m{{1, 1.1f}, {2, 1.2f}};
m.try_emplace(1, 1.5f);
m.try_emplace(3, 1.5f);
for (auto& [key, value] : m)
{
    std::cout << "key: " << key << ", value: " << value << std::endl;
}

输出结果：

key: 3, value: 1.5
key: 2, value: 1.2
key: 1, value: 1.1

erase

移除指定位置的元素或者移除指定key值的元素。代码示例：

std::unordered_map<int, float> m{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}, {4, 1.4f}, {5, 1.5f}};
std::cout << "m size = " << m.size() << std::endl;
m.erase(m.begin());
std::cout << "m size = " << m.size() << std::endl;
m.erase(m.begin(), std::next(m.begin(), 2));
std::cout << "m size = " << m.size() << std::endl;
m.erase(m.begin()->first);
std::cout << "m size = " << m.size() << std::endl;

输出结果：

m size = 5
m size = 4
m size = 2
m size = 1

swap

和另一个unordered_map交换元素内容。代码示例：

std::unordered_map<int, float> m1{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}};
std::unordered_map<int, float> m2{{1, 1.1f}, {2, 1.2f}};
m1.swap(m2);
std::cout << "m1 size = " << m1.size() << std::endl;
std::cout << "m2 size = " << m2.size() << std::endl;

输出结果：

m1 size = 2
m2 size = 3

extract

提取unordered_map中的某个元素节点，提取后unordered_map不再拥有该元素。代码示例：

std::unordered_map<int, float> m{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}};
auto node1 = m.extract(m.begin());
std::cout << "node1 key: " << node1.key() << ", value: " << node1.mapped() << std::endl;
std::cout << "m size " << m.size() << std::endl;
auto node2 = m.extract(m.begin()->first);
std::cout << "m size " << m.size() << std::endl;
node2.key() += 20;
node2.mapped() += 20;
m.insert(std::move(node2));
std::cout << "m size " << m.size() << std::endl;
for (auto& [key, value] : m)
{
    std::cout << "key: " << key << ", value: " << value << std::endl;
}

输出结果：

node1 key: 3, value: 1.3
m size 2
m size 1
m size 2
key: 22, value: 21.2
key: 1, value: 1.1

merge

合并另一个unordered_map或者unordered_multimap的元素。代码示例：

std::unordered_map<int, float> m1{{1, 1.1f}, {2, 1.2f}};
std::unordered_map<int, float> m2{{3, 1.2f}, {4, 1.3f}};
m1.merge(m2);
std::cout << "m1 size = " << m1.size() << std::endl;
std::cout << "m2 size = " << m2.size() << std::endl;

输出结果：

m1 size = 4
m2 size = 0

查找

at

返回指定key值的value值的引用，如果没有该key值，会抛出异常。代码示例：

std::unordered_map<int, float> m{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}};
m.at(2) = 20.5f;
std::cout << "m key 2 = " << m.at(2) << std::endl;

输出结果：

m key 2 = 20.5

operator[]

返回指定key值的value值的引用，如果该没有key值，会插入该key值。代码示例：

std::unordered_map<int, float> m{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}};
std::cout << "m key 2 = " << m[2] << std::endl;
std::cout << "m key 20 = " << m[20] << std::endl;

输出结果：

m key 2 = 1.2
m key 20 = 0

count

获取给定key值的元素数量。由于unordered_map的元素是不重复的，结果只能是0或者1。代码示例：

std::unordered_map<int, float> m{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}};
std::cout << "m key 1 count: " << m.count(1) << std::endl;
std::cout << "m key 4 count: " << m.count(4) << std::endl;

输出结果：

m key 1 count: 1
m key 4 count: 0

find

获取指定key值的元素的迭代器。代码示例：

std::unordered_map<int, float> m{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}};
auto iter1 = m.find(1);
auto iter2 = m.find(4);
std::cout << std::boolalpha;
std::cout << "elment has key 1: " << (iter1 == m.end()) << std::endl;
std::cout << "elment has key 4: " << (iter2 == m.end()) << std::endl;

输出结果：

elment has key 1: false
elment has key 4: true

contains

检查是否包含特定key的元素。代码示例：

std::unordered_map<int, float> m{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}};
std::cout << std::boolalpha;
std::cout << "contain key 1: " << m.contains(1) << std::endl;
std::cout << "contain key 4: " << m.contains(4) << std::endl;

输出结果：

contain key 1: true
contain key 4: false

equal_range

获取容器中等于给定key值的元素范围。返回第一个迭代器指向范围的首元素，第二个迭代器指向范围的最后一个元素。代码示例：

std::unordered_map<int, float> m{
    {1, 1.1f}, {2, 1.2f}, {3, 1.3f}, {4, 1.4f}, {5, 1.5f}};
for (auto item : m)
{
    std::cout << item.first << " ";
}

std::cout << std::endl;
auto [iter1, iter2] = m.equal_range(3);
std::cout << "iter1 key = " << iter1->first << std::endl;
std::cout << "iter2 key = " << iter2->first << std::endl;

输出结果：

5 4 3 2 1 
iter1 key = 3
iter2 key = 2

桶接口

bucket_count

返回unordered_map的桶数量。代码示例：

std::unordered_map<int, float> m{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}};
std::cout << "bucket count = " << m.bucket_count() << std::endl;

输出结果：

bucket count = 5

max_bucket_count

返回unordered_map可以容纳的最大桶数量。代码示例：

std::unordered_map<int, float> m;
std::cout << "max bucket count = " << m.max_bucket_count() << std::endl;

输出结果：

max bucket count = 768614336404564650

bucket_size

返回给定索引的桶中的元素数量。代码示例：

std::unordered_map<int, float> m{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}};
for (int i = 0; i < m.bucket_count(); ++i)
{
    std::cout << "bucket " << i << " has item num " << m.bucket_size(i)
              << std::endl;
}

输出结果：

bucket 0 has item num 0
bucket 1 has item num 1
bucket 2 has item num 1
bucket 3 has item num 1
bucket 4 has item num 0

bucket

返回给定key值的元素所在桶的索引。代码示例：

std::unordered_map<int, float> m{{11, 1.1f}, {21, 1.2f}, {31, 1.3f}};
auto n = m.bucket(21);
std::cout << "item 21 is in bucket " << n << std::endl;

输出结果：

item 21 is in bucket 1

begin、cbegin、end、cend

begin和cbegin返回索引为n的桶中的首个元素的迭代器。end和cend返回索引为n的桶中的末尾迭代器。代码示例：

std::unordered_map<int, float> m{
    {11, 1.1f}, {21, 1.2f}, {31, 1.3f}, {12, 1.1f}, {22, 1.2f}};
auto cnt = m.bucket(31);
auto iter_begin = m.begin(cnt);
auto iter_end = m.end(cnt);
for (auto iter = iter_begin; iter != iter_end; ++iter)
{
    std::cout << "num = " << iter->first << std::endl;
}

输出结果：

num = 31
num = 21
num = 11

散列策略

load_factor

返回每个桶的平均元素数量。代码示例：

std::unordered_map<int, float> m{{11, 1.1f}, {21, 1.2f}, {31, 1.3f}};
float num = m.load_factor();
std::cout << "load factor is: " << num << std::endl;

输出结果：

load factor is: 0.6

max_load_factor

没有参数的情况下返回最大平均桶数。参数为float类型时设置每个桶的平均最大元素数量，如果超出了该数量，容器就会自己增加桶数。代码示例：

int n_count = 200;

std::unordered_map<int, float> m1;
m1.max_load_factor(1);
for (int i = 0; i < n_count; ++i)
{
    m1.emplace(i, 1.0f);
}
std::cout << "m1 max load factor is: " << m1.max_load_factor() << std::endl;
std::cout << "m1 bucket count: " << m1.bucket_count() << std::endl;

std::unordered_map<int, float> m2;
m2.max_load_factor(20);
for (int i = 0; i < n_count; ++i)
{
    m2.emplace(i, 1.0f);
}
std::cout << "m2 max load factor is: " << m2.max_load_factor() << std::endl;
std::cout << "m2 bucket count: " << m2.bucket_count() << std::endl;

输出结果：

m1 max load factor is: 1
m1 bucket count: 397
m2 max load factor is: 20
m2 bucket count: 11

rehash

设置桶的最小数量并重新散列容器。代码示例：

std::unordered_map<int, float> m;
for (int i = 0; i < 200; ++i)
{
    m.emplace(i, 1.0f);
}
std::cout << "bucket cnt: " << m.bucket_count() << std::endl;

m.rehash(m.bucket_count() / 2);
std::cout << "bucket cnt: " << m.bucket_count() << std::endl;
m.rehash(m.bucket_count() * 4);
std::cout << "bucket cnt: " << m.bucket_count() << std::endl;

输出结果：

bucket cnt: 397
bucket cnt: 211
bucket cnt: 853

reserve

设置桶的最小元素个数，并重新散列容器。重新散列后的容器的平均元素数量不能超过设定的值。代码示例：

std::unordered_map<int, float> m;
for (int i = 0; i < 200; ++i)
{
    m.emplace(i, 1.0f);
}
std::cout << "bucket cnt: " << m.load_factor() << std::endl;

m.rehash(5);
std::cout << "bucket cnt: " << m.load_factor() << std::endl;

输出结果：

bucket cnt: 0.503778
bucket cnt: 0.947867

观察器

hash_function

返回hash计算函数。代码示例：

std::unordered_map<std::string, float> m;
auto hash_func = m.hash_function();
std::cout << "hash is: " << hash_func("hello world") << std::endl;

输出结果：

hash is: 12386028635079221413

key_eq

返回用于比较key相等性的函数。代码示例：

std::unordered_map<int, std::string> m;
auto key_eq_func = m.key_eq();
std::cout << std::boolalpha;
std::cout << key_eq_func(1, 1) << std::endl;
std::cout << key_eq_func(1, 2) << std::endl;

输出结果：

true
false

非成员函数

比较运算符

比较两个unordered_map是否相等。代码示例：

std::unordered_map<int, float> m1{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}};
std::unordered_map<int, float> m2{{1, 1.1f}, {2, 1.2f}};
std::cout << std::boolalpha;
std::cout << "m1 == m2: " << (m1 == m2) << std::endl;
std::cout << "m1 != m2: " << (m1 != m2) << std::endl;

输出结果：

m1 == m2: false
m1 != m2: true

swap

交换两个unordered_map。代码示例：

std::unordered_map<int, float> m1{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}};
std::unordered_map<int, float> m2{{1, 1.1f}, {2, 1.2f}};
std::swap(m1, m2);
std::cout << "m1 size = " << m1.size() << std::endl;
std::cout << "m2 size = " << m2.size() << std::endl;

输出结果：

m1 size = 2
m2 size = 3

erase_if

删除满足条件的元素。代码示例：

std::unordered_map<int, float> m{{1, 1.1f}, {2, 1.2f}, {3, 1.3f}};
std::cout << "m size = " << m.size() << std::endl;
std::erase_if(m,
              [](const std::pair<int, float>& pair)
              {
                  return pair.second > 1.15;
              });
std::cout << "m size = " << m.size() << std::endl;

输出结果：

m size = 3
m size = 1

Lucy_stone

关注

26
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
容器库(11)-std::unordered_map

unordered_map是含有唯一key的键值对的无序关联容器，搜索、移除和插入操作是平均常数的时间复杂度。unordered_map在内部没有按任何顺序排列，而是放在桶当中的，放进哪个桶是通过计算key的hash值来决定的。
复制链接

扫一扫