C++ STL系列之 boost:unordered_map和 std::map区别详解（***）

最新推荐文章于 2024-09-08 14:36:35 发布

ken2232

最新推荐文章于 2024-09-08 14:36:35 发布

阅读量662

点赞数 1

分类专栏： C/C++ Qt 文章标签： c++ 开发语言 qt

原文链接：https://blog.csdn.net/yz930618/article/details/84783947

版权

Qt 同时被 2 个专栏收录

177 篇文章 13 订阅

订阅专栏

C/C++

121 篇文章 12 订阅

订阅专栏

C++ STL系列之 boost:unordered_map和 std::map区别详解（***）

Linux下map hash_map和unordered_map效率比较

boost中的unordered_map使用方法

map和 unordered_map的使用对比（**）

---------------------------------------------------------

当不需要结果排好序时，最好用 unordered_map。但有 hash计算的耗时、即内存占用问题。

按插入排序，和 unordered不是一个概念。

按插入排序也是一种排序，而 unordered不是任何一种规则排序。

=================================

C++ STL系列之 boost:unordered_map和 std::map区别详解（***）

开发C++时，选择合适的数据结构是一个十分重要的步骤。因此，必须对每一个数据结构的原理及应用场景都有所了解。

boost::unordered_map和 std::map都是一种关联式容器，且原理类似，通过存储key-value键值对，可通过key快速检索到value，并且key是不重复的。但是，它们之间有一些区别，下面将逐一介绍。

排序区别：

map是有序的：按照 operator<比较判断元素的大小，并选择合适的位置插入到树中；
unordered_map是无序的：计算元素的Hash值，根据Hash值判断元素是否相同。

用法区别：

对于key是自定义的类型， map的key需要定义 operator<，内置类型(如,int)是自带operator<;
对于key是自定义的类型，unordered_map需要定义hash_value函数并且重载operator==，内置类型都自带该功能。

应用区别：

如果元素需要排序，则使用map；
如果需要高效率和低内存（错误？：高效是有代价的，即高内存），则使用unordered_map。

关联：

1. c++ - std :: unordered_map的内存使用率很高 - 堆栈内存溢出

2. 哈希表最大的优点，就是把数据的存储和查找消耗的时间大大降低，几乎可以看成是常数时间；而代价仅仅是消耗比较多的内存。

c++ - 如何测量std :: unordered_map的内存使用情况

https://mlog.club/article/184435

————————————————
版权声明：本文为CSDN博主「yz930618」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/yz930618/article/details/84783947

boost中的unordered_map使用方法

1. minGW导入 boost库 http://blog.csdn.net/rumswell/article/details/8282831

2. 在cpp文件首部加入

#include <boost/unordered_set.hpp>
#include <boost/unordered_map.hpp>
using namespace std;
using namespace boost;

Linux下 map hash_map和 unordered_map效率比较

原理介绍

map介绍

Map是STL[1]的一个关联容器，它提供一对一（其中第一个可以称为关键字，每个关键字只能在map中出现一次，第二个可能称为该关键字的值）的数据处理能力，由于这个特性，它完成有可能在我们处理一对一数据的时候，在编程上提供快速通道。这里说下map内部数据的组织，map内部自建一颗红黑树（一种非严格意义上的平衡二叉树），这颗树具有对数据自动排序的功能，所以在map内部所有的数据都是有序的，后边我们会见识到有序的好处。

hash_map介绍

hash_map基于hash table（哈希表）。哈希表最大的优点，就是把数据的存储和查找消耗的时间大大降低，几乎可以看成是常数时间；而代价仅仅是消耗比较多的内存。然而在当前可利用内存越来越多的情况下，用空间换时间的做法是值得的。另外，编码比较容易也是它的特点之一。

其基本原理是：使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数，也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下标，hash值）相对应，于是用这个数组单元来存储这个元素；也可以简单的理解为，按照关键字为每一个元素“分类”，然后将这个元素存储在相应“类”所对应的地方，称为桶。

但是，不能够保证每个元素的关键字与函数值是一一对应的，因此极有可能出现对于不同的元素，却计算出了相同的函数值，这样就产生了“冲突”，换句话说，就是把不同的元素分在了相同的“类”之中。总的来说，“直接定址”与“解决冲突”是哈希表的两大特点。

hash_map，首先分配一大片内存，形成许多桶。是利用hash函数，对key进行映射到不同区域（桶）进行保存。其插入过程是：

1.得到key
2.通过hash函数得到hash值
3.得到桶号(一般都为hash值对桶数求模)
4.存放key和value在桶内。
其取值过程是:
1.得到key
2.通过hash函数得到hash值
3.得到桶号(一般都为hash值对桶数求模)
4.比较桶的内部元素是否与key相等，若都不相等，则没有找到。
5.取出相等的记录的value。
hash_map中直接地址用hash函数生成，解决冲突，用比较函数解决。这里可以看出，如果每个桶内部只有一个元素，那么查找的时候只有一次比较。当许多桶内没有值时，许多查询就会更快了(指查不到的时候).

由此可见，要实现哈希表, 和用户相关的是：hash函数和比较函数。这两个参数刚好是我们在使用hash_map时需要指定的参数。

unordered_map介绍

Unordered maps are associative containers that store elements formed by the combination of a key value and a mapped value, and which allows for fast retrieval of individual elements based on their keys.

In an unordered_map, the key value is generally used to uniquely identify the element, while the mapped value is an object with the content associated to this key. Types of key and mapped value may differ.

Internally, the elements in the unordered_map are not sorted in any particular order with respect to either their key or mapped values, but organized into buckets depending on their hash values to allow for fast access to individual elements directly by their key values (with a constant average time complexity on average).

unordered_map containers are faster than map containers to access individual elements by their key, although they are generally less efficient for range iteration through a subset of their elements.

Unordered maps implement the direct access operator (operator[]) which allows for direct access of the mapped value using its key value as argument.

unordered_map与 map的区别

boost::unordered_map，它与 stl::map的区别就是，stl::map是按照operator<比较判断元素是否相同，以及比较元素的大小，然后选择合适的位置插入到树中。所以，如果对map进行遍历（中序遍历）的话，输出的结果是有序的。顺序就是按照operator< 定义的大小排序。

而boost::unordered_map是计算元素的Hash值，根据Hash值判断元素是否相同。所以，对unordered_map进行遍历，结果是无序的。

用法的区别就是，stl::map 的key需要定义operator< 。而boost::unordered_map需要定义hash_value函数并且重载operator==。对于内置类型，如string，这些都不用操心。对于自定义的类型做key，就需要自己重载operator< 或者hash_value()了。

最后，说，当不需要结果排好序时，最好用 unordered_map。

其实，stl::map对于与java中的TreeMap，而boost::unordered_map对应于java中的HashMap。
测试代码

。。。。。。省略。。。。。。

————————————————
版权声明：本文为CSDN博主「whizchen」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/whizchen/article/details/9286557

map和 unordered_map的使用对比（**）

unordered_map 类模板和 map 类模板都是描述了这么一个对象：它是由 std::pair<const Key, value> 组成的可变长容器，这个容器中每个元素存储两个对象，也就是 key - value 对。

map

使用map 而言，要引用头文件，它的类模板声明以及部分函数声明如下：

/**
* 程序来自C++源码 bits/stl_map.h
*/
template<typename _Key, // key 类型
        typename _Tp,    // value 类型
        typename _Compare = std::less<_Key>, // 用于比较两个元素的比较函数
        typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > > // 分配器，同样的描述了容器在内存管理上的细节，不应该自己来处理，除非写自己的容器
class map {
private:
    /// 将一个红黑树转换成 [multi]map.
    typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
    rebind<value_type>::other _Pair_alloc_type;

typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
key_compare, _Pair_alloc_type> _Rep_type;
};

在 map 的内部，使用了红黑树（red-black tree）来组织数据，因此默认的就已经实现了数据的排序。从下面例子中可以看出，它默认实现了在 key 上排序实现递增：

int main() {
    map<int, string> mapper;
    mapper.insert(make_pair(0, "Alice"));
    mapper[1] = "Bob";
    mapper.insert(map<int, string>::value_type(2, "Candy"));
    for (auto &iter : mapper) {
        cout << iter.first << " - " << iter.second << endl;
        /*
         * >: 输出如下，很明显的，它们在 key 的排序上是递增排列的
         * 0 - Alice
         * 1 - Bob
         * 2 - Candy
         */
    }
}

不过，在存储上 map 却比较占用空间，因为在红黑树中，每一个节点都要额外保存父节点和子节点的连接，因此使得每一个节点都占用较大空间来维护红黑树性质。
unordered_map

在头文件上，引入 <unordered_map> 来使用它。对于 unordered_map 而言，最大的特点在于内部实现上，使用到了哈希表（散列表、hash_table ）来进行映射存储，它的模板类声明及其参数如下：

/**
* 程序来自STL源码 bits/unordered_map.h
*/
template<typename _Key, // key 类型
        typename _Tp,    // value 类型
        typename _Hash = hash <_Key>,     // 哈希函数
        typename _Pred = equal_to <_Key>, // 用于比较两者是否相同的函数
        typename _Alloc = allocator <std::pair<const _Key, _Tp>>> // 分配器，描述了容器在内存管理上的细节，不应该自己来处理，除非写自己的容器
class unordered_map {
};

在 unordered_map 内部，使用的 Hash Table 对数据进行组织，通过把键值 key 映射到 hash 表中的一个位置进行访问，根据 hash 函数的特点， unordered_map 对于元素查找的时间复杂度可以达到 O(1) ，但是，它的元素排列是无序的。具体例子如下：

int main() {
    using namespace std;
    // 首先创建一个无序 map，它的 key 使用 int 类型，value 使用 string 类型
    unordered_map<int, string> unorderedMap;

    // 三种插入新元素的方法，“茴”字有三种写法~
    unorderedMap.insert(make_pair(0, "Alice"));
    unorderedMap[1] = "Bob";
    unorderedMap.insert(unordered_map<int, string>::value_type(2, "Candy"));

    // 对内部元素挨个输出
    for (auto iter = unorderedMap.begin(); iter != unorderedMap.end(); iter++) {
        cout << iter->first << " - " << iter->second << endl;
        /*
         * >: 输出如下，可以得知它们在 key 的排序上并没有顺序
         * 2 - Candy
         * 0 - Alice
         * 1 - Bob
         */
    }
}

unordered_map 由于建立了哈希表，所以它在最开始建立的时候比较耗时间，但是它查询速度快呀~，一般情况下用 unordered_map 是没有问题的。

总结

map:

元素有序，并且具有自动排序的功能（因为红黑树具有自动排序的功能）
元素按照二叉搜索树存储的，也就是说，其左子树上所有节点的键值都小于根节点的键值，右子树所有节点的键值都大于根节点的键值，使用中序遍历可将键值按照从小到大遍历出来
空间占用率高，因为map内部实现了红黑树，虽然提高了运行效率，但是因为每一个节点都需要额外保存父节点、孩子节点和红/黑性质，使得每一个节点都占用大量的空间
适用情况:对顺序有要求的情况下，如排序等