STL之关联容器

最新推荐文章于 2022-12-01 19:56:52 发布
最新推荐文章于 2022-12-01 19:56:52 发布
阅读量287 收藏
点赞数
分类专栏： STL源码剖析 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Spring_24/article/details/105557821
版权

目录

一、关联容器概述

关联容器支持高效的关键字查找和访问。两个主要的关联容器类型是 map 和 set。map中的元素是一些关键字-值(key-value)对：关键字起到索引的作用，值则表示与索引相关联的数据。set 中每个元素只包含一个关键字。

标准库提供8个关联容器，这8个关联容器间的不同体现在三个维度上：每个容器(1)或者是一个 set，或者是一个 map；(2)或者要求不重复的关键字，或者允许重复的关键字；(3)按顺序保存元素，或无序保存。允许重复关键字的容器的名字中都包含单词 multi；不保持关键字按顺序存储的容器的名字都以单词 unordered 开头。

在这里插入图片描述

有序关联容器基于一个序标准(默认是小于比较操作<)进行查找。这类容器用平衡二叉树实现，通常是红黑树(有关红黑树的内容请参看 STL之红黑树)。

无序关联容器基于一个哈希函数进行查找。这类容器用哈希表实现，采用溢出链表策略(有关哈希表的内容请参看STL之哈希表)。

二、关联容器

2.1、set

set 的特性是，所有元素都会根据元素的键值自动被排序。由于 set 元素值就是其键值，关系到 set 元素的排列规则，因此不可以通过 set 的迭代器改变 set 的值。

标准库的 set 以 RB-tree 为底层机制，set 操作通过调用 RB-tree 的接口实现：

template <typename _Key, typename _Compare = std::less<_Key>,
          typename _Alloc = std::allocator<_Key>>
class set
{
  typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_Key>::other _Key_alloc_type;

  typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
                   key_compare, _Key_alloc_type> _Rep_type;
  _Rep_type _M_t; // Red-black tree representing set.

  std::pair<iterator, bool>
  insert(value_type &&__x)
  {
    std::pair<typename _Rep_type::iterator, bool> __p =
        _M_t._M_insert_unique(std::move(__x));
    return std::pair<iterator, bool>(__p.first, __p.second);
  }
  ...
};

2.2、multiset

multiset 的特性以及用法和 set 完全相同，唯一的差别在于它允许键值重复，因此它的插入操作采用的是底层机制 RB-tree 的 _M_insert_equal() 而非 _M_insert_unique()。

template <typename _Key, typename _Compare = std::less<_Key>,
          typename _Alloc = std::allocator<_Key>>
class multiset
{
  /// This turns a red-black tree into a [multi]set.
  typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_Key>::other _Key_alloc_type;

  typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
                   key_compare, _Key_alloc_type> _Rep_type;
  /// The actual tree structure.
  _Rep_type _M_t;

  iterator
  insert(value_type &&__x)
  {
    return _M_t._M_insert_equal(std::move(__x));
  }
  ...
};

2.3、map

map 的特性是，所有元素都会根据元素的键值自动被排序。map 的所有元素都是 pair，同时拥有实值和键值。

标准库的 map 以 RB-tree 为底层机制，map 操作通过调用 RB-tree 的接口实现：

template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
          typename _Alloc = std::allocator<std::pair<const _Key, _Tp>>>
class map
{
  /// This turns a red-black tree into a [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;

  /// The actual tree structure.
  _Rep_type _M_t;

  std::pair<iterator, bool>
  insert(value_type &&__x)
  {
    return _M_t._M_insert_unique(std::move(__x));
  }
  ...
};

2.4、multimap

multimap的特性以及用法和 map 完全相同，唯一的差别在于它允许键值重复，因此它的插入操作采用的是底层机制 RB-tree 的 _M_insert_equal() 而非 _M_insert_unique()。

template <typename _Key, typename _Tp,
          typename _Compare = std::less<_Key>,
          typename _Alloc = std::allocator<std::pair<const _Key, _Tp>>>
class multimap
{
  /// This turns a red-black tree into a [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;
  /// The actual tree structure.
  _Rep_type _M_t;

  iterator
  insert(value_type &&__x)
  {
    return _M_t._M_insert_equal(std::move(__x));
  }
  ...
};

2.5、unordered_set

unordered_set以哈希表为底层机制，unordered_set操作通过调用哈希表的接口实现：

/// Base types for unordered_set.
template <bool _Cache>
using __uset_traits = __detail::_Hashtable_traits<_Cache, true, true>;

template <typename _Value,
          typename _Hash = hash<_Value>,
          typename _Pred = std::equal_to<_Value>,
          typename _Alloc = std::allocator<_Value>,
          typename _Tr = __uset_traits<__cache_default<_Value, _Hash>::value>>
using __uset_hashtable = _Hashtable<_Value, _Value, _Alloc,
                                    __detail::_Identity, _Pred, _Hash,
                                    __detail::_Mod_range_hashing,
                                    __detail::_Default_ranged_hash,
                                    __detail::_Prime_rehash_policy, _Tr>;

template <typename _Value,
          typename _Hash = hash<_Value>,
          typename _Pred = equal_to<_Value>,
          typename _Alloc = allocator<_Value>>
class unordered_set
{
  typedef __uset_hashtable<_Value, _Hash, _Pred, _Alloc> _Hashtable;
  _Hashtable _M_h;

  std::pair<iterator, bool>
  insert(value_type &&__x)
  {
    return _M_h.insert(std::move(__x));
  }
  ...
};

2.6、unordered_multiset

unordered_multiset的特性以及用法和 unordered_set完全相同，唯一的差别在于它允许键值重复。

/// Base types for unordered_multiset.
template <bool _Cache>
using __umset_traits = __detail::_Hashtable_traits<_Cache, true, false>;

template <typename _Value,
          typename _Hash = hash<_Value>,
          typename _Pred = std::equal_to<_Value>,
          typename _Alloc = std::allocator<_Value>,
          typename _Tr = __umset_traits<__cache_default<_Value, _Hash>::value>>
using __umset_hashtable = _Hashtable<_Value, _Value, _Alloc,
                                     __detail::_Identity,
                                     _Pred, _Hash,
                                     __detail::_Mod_range_hashing,
                                     __detail::_Default_ranged_hash,
                                     __detail::_Prime_rehash_policy, _Tr>;

template <typename _Value,
          typename _Hash = hash<_Value>,
          typename _Pred = equal_to<_Value>,
          typename _Alloc = allocator<_Value>>
class unordered_multiset
{
  typedef __umset_hashtable<_Value, _Hash, _Pred, _Alloc> _Hashtable;
  _Hashtable _M_h;

  iterator
  insert(value_type &&__x)
  {
    return _M_h.insert(std::move(__x));
  }
  ...
};

2.7、unordered_map

unordered_map以哈希表为底层机制，unordered_map操作通过调用哈希表的接口实现：

/// Base types for unordered_map.
template <bool _Cache>
using __umap_traits = __detail::_Hashtable_traits<_Cache, false, true>;

template <typename _Key,
          typename _Tp,
          typename _Hash = hash<_Key>,
          typename _Pred = std::equal_to<_Key>,
          typename _Alloc = std::allocator<std::pair<const _Key, _Tp>>,
          typename _Tr = __umap_traits<__cache_default<_Key, _Hash>::value>>
using __umap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>,
                                    _Alloc, __detail::_Select1st,
                                    _Pred, _Hash,
                                    __detail::_Mod_range_hashing,
                                    __detail::_Default_ranged_hash,
                                    __detail::_Prime_rehash_policy, _Tr>;

template <typename _Key, typename _Tp,
          typename _Hash = hash<_Key>,
          typename _Pred = equal_to<_Key>,
          typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
class unordered_map
{
  typedef __umap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable;
  _Hashtable _M_h;

  template <typename _Pair>
  __enable_if_t<is_constructible<value_type, _Pair &&>::value,
                pair<iterator, bool>>
  insert(_Pair &&__x)
  {
    return _M_h.emplace(std::forward<_Pair>(__x));
  }
  ...
};

2.8、unordered_multimap

unordered_multimap的特性以及用法和 unordered_map完全相同，唯一的差别在于它允许键值重复。

/// Base types for unordered_multimap.
template <bool _Cache>
using __ummap_traits = __detail::_Hashtable_traits<_Cache, false, false>;

template <typename _Key,
          typename _Tp,
          typename _Hash = hash<_Key>,
          typename _Pred = std::equal_to<_Key>,
          typename _Alloc = std::allocator<std::pair<const _Key, _Tp>>,
          typename _Tr = __ummap_traits<__cache_default<_Key, _Hash>::value>>
using __ummap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>,
                                     _Alloc, __detail::_Select1st,
                                     _Pred, _Hash,
                                     __detail::_Mod_range_hashing,
                                     __detail::_Default_ranged_hash,
                                     __detail::_Prime_rehash_policy, _Tr>;

template <typename _Key, typename _Tp,
          typename _Hash = hash<_Key>,
          typename _Pred = equal_to<_Key>,
          typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
class unordered_multimap
{
  typedef __ummap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable;
  _Hashtable _M_h;

  template <typename _Pair>
  __enable_if_t<is_constructible<value_type, _Pair &&>::value, iterator>
  insert(_Pair &&__x)
  {
    return _M_h.emplace(std::forward<_Pair>(__x));
  }
  ...
};
Spring_24
关注
专栏目录
C++ | STL之顺序容器、关联容器、容器适配器
ZY-JIMMY
03-23 1952
文章目录STL简述STL六大组件顺序容器（序列式容器）vectordequelist关联容器容器适配器 STL简述 STL是Standard Template Library的简称，中文名标准模板库，从根本上说，STL是一些“容器”的集合，这些“容器”有list、vector、set、map等，STL也是算法和其他一些组件的集合。STL的目的是标准化组件，这样就不用重新开发，可以使用现成的组件。...
C++ | STL标准库之关联容器
weixin_44742670的博客
12-21 825
文章目录前言一、map二、set三、关联容器迭代器四、无序容器总结 前言 上一篇顺序容器中，元素按照它们在容器中的位置来顺序保存和访问。本文关联容器中，元素是按照关键字来保存和访问的。 关联式容器支持高效的关键字查找和访问，标准库提供了8个关联容器，4个有序：map、set、multimap、multiset ; 4个无序：unordered_map、unordered_set、unordered_multimap、unordered_multiset。这些容器都基于两个主要的关联容器：map和set。
STL之关联式容器（一）
qq_44739053的博客
07-24 284
关联式容器 所谓关联式容器，观念上类似关联式数据库（实则更为简单）：每笔数据或每个元素都有一个键值（key）和一个实值（value）。当元素被插入到关联式容器中时，容器内部结构（可能RB-tree，也可能是hash-table）便依照其键值大小，某种特定的规则将这个元素放置于适当的位置。关联式容器没有所谓的头尾，只有最大和最小元素，所以不会有所谓push_back()、push_front()、p...
STL的三个基本容器 vector list deque
gumingyaotangwei 的专栏
03-31 1089
vector和built-in数组类似，它拥有一段连续的内存空间，并且起始地址不变，因此它能非常好的支持随机存取，即[]操作符，但由于它的内存空间是连续的，所以在中间进行插入和删除会造成内存块的拷贝，另外，当该数组后的内存空间不够时，需要重新申请一块足够大的内存并进行内存的拷贝。这些都大大影响了vector的效率。   list就是数据结构中的双向链表(根据sgi  stl源代码)，因
STL之set、multiset学习总结（C++）
ZeroGor的博客
03-17 1502
STL之set、multiset用法概述具体用法（以set为例）0. 头文件1. 声明和初始化2. 常用函数（查询）2.1 empty()2.2 size()2.3 find()2.4 lower_bound()2.5 upper_bount()2.6 equal_range()2.7 count()2.8 迭代器2.9 输出3. 常用函数（操作）3.1 insert()3.2 swap()3.9...
c++ map iterator 获取key_C++ STL源码剖析之map、multimap、initializer_list
weixin_39793638的博客
11-20 354
C++ STL源码剖析之map、multimap、initializer_list大家好我是光城，欢迎关注公众号：guangcity。map/multimap 以rb_tree为底层结构，因此有元素自动排序特点，排序的依据是key。map/multimap提供"遍历"操作及iterators。按正常规则(++iter)遍历，便能够获得排序状态。我们无法使用map/multimap的iterator...
【C++】二十五、标准模板库STL之关联容器
qq_43411555的博客
08-06 532
一、关联容器简介 （一）基本概念 （二）关联容器都有的函数 二、set （一）对set容器的操作 1. 增 2. 删 3. 访问 （二）特点 （四）演示 三、multiset 四、map （一）对map容器的操作 1. 增 2. 删 3. 访问 （二）特点 （四）演示 五、multimap
STL：STL关联容器 set
凯凯在此
06-26 415
文章目录STL关联容器 set1. 操作1.1 使用迭代器遍历1.2 插入1.3 查找2. 相关练习2.1 力扣217：存在重复元素2.2 力扣448：找到所有数组中消失的数字2.3 力扣287：寻找重复数2.4 力扣349：两个数组的交集 STL关联容器 set 集合容器（set）：快速查找，不允许重复值 set 的特点：有序且不重复 1. 操作 1.1 使用迭代器遍历 #include <iostream> #include <set> using namespace std;
SGI STL 关联式容器源码
05-26
通过对SGI STL关联式容器源码的学习，我们可以理解这些数据结构的内部实现，从而更好地利用它们来解决实际编程问题，提高程序效率。同时，这也是深入理解C++模板元编程和STL设计模式的一个宝贵资源。
STL关联容器概述1
08-08
STL关联容器是C++ Standard Template Library中的一类重要容器，它们主要负责通过键值(key)来存储和检索元素。关联容器与序列式容器（如vector、list、deque等）不同，后者是通过元素在容器内的位置顺序来存取元素。...
multiset源码分析
愤怒的弱鸡
08-19 512
set是一个关联容器，其内部保存了一系列排序了的不重复的类型为key的对象，其排序使用构造时传入的compare函数。其插入、删除、查找在log时间复杂度内完成。在STL中其使用红黑树来实现此结构，对于红黑树这里不多做介绍，其实质上就是带有平衡功能的二叉排序树，所以说红黑树的中序遍历有序，其属于二叉树。 container set的实现就是借助红黑树实现，在如下定义中，我们可以看到如下信息 其定义了_Rep_type _M_t这一数据成员变量，其类型为typedef _Rb_tree<key_typ
红黑树并没有我们想象的那么难(下)
weixin_33991418的博客
09-29 206
&lt;红黑树并没有我们想象的那么难&gt; 上、下两篇已经完成, 希望能帮助到大家. 红黑树并没有我们想象的那么难(上): http://daoluan.net/blog/?p=2057 红黑树并没有我们想象的那么难(下): http://daoluan.net/blog/?p=2112 SGI STL map 实现概述 根据上一节的红黑树分析, 结合 sgi stl map 的...
C++ multimap equal_range() 删除
weixin_41977938的博客
02-18 479
#include <iostream> #include <map> #include <vector> #include <fstream> #include <assert.h> #include <algorithm> using namespace std; int main() { multimap<int,int> m; m.insert(pair<int,int>(1,12));.
C++容器的分类
最新发布
C++的知识
12-01 512
c++有哪些容器
C++进阶——STL源码之unordered_set与unordered_multiset
qq_25065595的博客
09-11 770
STL源码之unordered_set与unordered_multiset std::set 是关联容器，含有 Key 类型对象的已排序集。用比较函数 Compare 进行排序。搜索、移除和插入拥有对数复杂度。 set 通常以红黑树实现，红黑树具有自动排序的功能，因此set内部所有的数据，在任何时候，都是有序的。 std::unordered_set 是含有 Key 类型唯一对象集合的关联容器，依赖于哈希表。搜索、插入和移除拥有平均常数时间复杂度。在内部，元素并不以任何特别顺序排序，而是组织进桶中，元
程序设计与算法（三）第九周 标准模板库STL（二）（1）
abc15766228491的博客
06-04 451
set和multiset 关联容器：set, multiset, map, multimap 内部元素有序排列，新元素插入的位置取决于它的值，查找速度块 除了各容器都有的函数外，还支持以下成员函数 find:查找等于某个值的元素（x小于y和y小于x同时不成立即为相等） lower_bound:查找某个下界 upper_bound:查找某个上界 equal_range:同时查找上界和下界 co...
C++中常见stl关联容器的比较
青阳的博客
05-05 396
关联容器 c++11标准库中主要介绍了以下8种关联容器，其区别如下： set与multiset（有序，节点只存一个值） 实现：平衡二叉树。 优点：自动排序使得查找有良好性能。 缺点：不能直接改变元素值，改变树则乱。 set与multiset的区别：前者每一个元素只能出现一次，不允许重复；后者元素可以重复。 map与multimap（有序，key/value可以任意） 实现：平衡二叉树。 优点：自动...
关联式容器--树形结构(map&set)
Sock的博客
07-29 814
关联式容器 什么是关联式容器: 关联式容器也是用来存储数据的，与序列式容器(vector, list, deque…)不同的是，其里面存储的是<key, value>结构的键值对，在 数据检索时比序列式容器效率更高 键值对: 用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值， value表示与key对应的信息, 这类似于字典中的一一对...
hypertable的配置与安装
lemo的专栏
03-04 3947
一、安装依赖代码：    1、BerkeleyDB 4.6+ 即：libdb4.6++-dev    2、Boost version 1.34.1+，       以及libboost-filesystem-dev 、 libboost-iostreams-dev 、 libboost-program-options-dev、        libboost-python-dev
C++ STL入门：关联容器解析
"关联容器是C++ STL中的重要组成部分，包括集合(set)、多重集合(multiset)、映射(map)和多重映射(multimap)。这些容器以不同的方式组织数据，提供高效的数据操作。集合和多重集合是基于红黑树的数据结构，存储单个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值