STL源码剖析（十四）关联式容器之set、map、multiset、multimap

最新推荐文章于 2022-09-13 20:54:08 发布
最新推荐文章于 2022-09-13 20:54:08 发布
阅读量139 收藏
点赞数
分类专栏： STL源码剖析 文章标签： c++ 算法 stl set map
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mei_true/article/details/120470445
版权

set特性
set所有元素都会根据元素的键值自动被排序，set元素的键值就是实值，实值就是键值。
set不可通过迭代器修改set元素值，set元素值就是其键值，关系到set元素的排列规则，源码中set<T>::iterator被定义为底层RB-tree的const_iterator，杜绝写入操作。
STL特别提供了一组set/mulset的相关算法，包括交集set_intersection、联集set_union、差集set_difference、对称差集set_symmetric_difference。

set与list相同的性质：元素新增（insert）和删除（erase）操作时，操作之前的所有迭代器，在操作之后依然有效，被删除元素的迭代器除外。

set以RB-tree为底层机制，set开放的各种接口几乎是转调用RB-tree的操作行为。

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

map的键值不可修改，实值可以修改，因此map的迭代器既不是constant iterators，也不是mutable iterators。
map与list相同的性质：元素新增（insert）和删除（erase）时，操作之前的所有迭代器，在操作之后依然有效，被删除元素的迭代器除外。

map以RB-tree为底层机制，map开放的各种接口几乎是转调用RB-tree的操作行为。

插入操作，返回一个pair，第一个元素是个迭代器，指向插入成功的新元素或插入失败键值重复的旧元素，第二个元素返回插入成功或失败的bool值。
下标运算符，用法有两种，可能作为左值运用内容可被修改，也可能作为右值使用内容不可被修改。
下标运算符，先插入键值和临时实值对象，插入操作返回一个pair，第一个元素是个迭代器，指向插入成功的新元素或插入失败（键值重复）的旧元素。下标运算符作为左值使用时，正好赋值新插入点实值；下标运算作右值使用时，返回插入失败键值重复旧元素的实值。

multiset特性
multiset特性和用法与set完全相同，唯一差别在于它允许键值重复，因此它的插入操作采用的是底层RT-tree的insert_equal()而不是insert_unique()。

multimap
multimap的特性和用法与map完全相同，唯一差别在于它允许键值重复，因此它的插入操作采用的是底层RT-tree的insert_equal()而不是insert_unique()。

下面stl_pari的pair定义

namespace std _GLIBCXX_VISIBILITY(default)
{
  /// piecewise_construct_t
  struct piecewise_construct_t { };
  constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();

  // Forward declarations.
  template<typename...>
    class tuple;

  template<std::size_t...>
    struct _Index_tuple;

  template<class _T1, class _T2>
    struct pair
    {
      typedef _T1 first_type;    /// @c first_type is the first bound type
      typedef _T2 second_type;   /// @c second_type is the second bound type

      _T1 first;                 /// @c first is a copy of the first object
      _T2 second;                /// @c second is a copy of the second object

      _GLIBCXX_CONSTEXPR pair() //默认构造函数
      : first(), second() { }

      _GLIBCXX_CONSTEXPR pair(const _T1& __a, const _T2& __b)
      : first(__a), second(__b) { }

      /** There is also a templated copy ctor for the @c pair class itself.  */
      template<class _U1, class _U2, class = typename
	       enable_if<__and_<is_convertible<const _U1&, _T1>,
				is_convertible<const _U2&, _T2>>::value>::type>
	constexpr pair(const pair<_U1, _U2>& __p)
	: first(__p.first), second(__p.second) { }

      constexpr pair(const pair&) = default;
      constexpr pair(pair&&) = default;

      template<class _U1, class = typename
	       enable_if<is_convertible<_U1, _T1>::value>::type>
	constexpr pair(_U1&& __x, const _T2& __y)
	: first(std::forward<_U1>(__x)), second(__y) { }

      template<class _U2, class = typename
	       enable_if<is_convertible<_U2, _T2>::value>::type>
	constexpr pair(const _T1& __x, _U2&& __y)
	: first(__x), second(std::forward<_U2>(__y)) { }

      template<class _U1, class _U2, class = typename
	       enable_if<__and_<is_convertible<_U1, _T1>,
				is_convertible<_U2, _T2>>::value>::type>
	constexpr pair(_U1&& __x, _U2&& __y)
	: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }

      template<class _U1, class _U2, class = typename
	       enable_if<__and_<is_convertible<_U1, _T1>,
				is_convertible<_U2, _T2>>::value>::type>
	constexpr pair(pair<_U1, _U2>&& __p)
	: first(std::forward<_U1>(__p.first)),
	  second(std::forward<_U2>(__p.second)) { }

      template<typename... _Args1, typename... _Args2>
        pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);

      pair&
      operator=(const pair& __p)
      {
		first = __p.first;
		second = __p.second;
		return *this;
      }

      pair&
      operator=(pair&& __p)
      noexcept(__and_<is_nothrow_move_assignable<_T1>,
	              is_nothrow_move_assignable<_T2>>::value)
      {
		first = std::forward<first_type>(__p.first);
		second = std::forward<second_type>(__p.second);
		return *this;
      }

      template<class _U1, class _U2>
	pair&
	operator=(const pair<_U1, _U2>& __p)
	{
	  first = __p.first;
	  second = __p.second;
	  return *this;
	}

      template<class _U1, class _U2>
	pair&
	operator=(pair<_U1, _U2>&& __p)
	{
	  first = std::forward<_U1>(__p.first);
	  second = std::forward<_U2>(__p.second);
	  return *this;
	}

      void
      swap(pair& __p)
      noexcept(noexcept(swap(first, __p.first))
	       && noexcept(swap(second, __p.second)))
      {
		using std::swap;
		swap(first, __p.first);
		swap(second, __p.second);
      }

    private:
      template<typename... _Args1, std::size_t... _Indexes1,
               typename... _Args2, std::size_t... _Indexes2>
        pair(tuple<_Args1...>&, tuple<_Args2...>&,
             _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
    };

  /// Two pairs of the same type are equal iff their members are equal.
  template<class _T1, class _T2>
    inline _GLIBCXX_CONSTEXPR bool
    operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return __x.first == __y.first && __x.second == __y.second; }

  template<class _T1, class _T2>
    inline _GLIBCXX_CONSTEXPR bool
    operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return __x.first < __y.first
	     || (!(__y.first < __x.first) && __x.second < __y.second); }

  /// Uses @c operator== to find the result.
  template<class _T1, class _T2>
    inline _GLIBCXX_CONSTEXPR bool
    operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return !(__x == __y); }

  /// Uses @c operator< to find the result.
  template<class _T1, class _T2>
    inline _GLIBCXX_CONSTEXPR bool
    operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return __y < __x; }

  /// Uses @c operator< to find the result.
  template<class _T1, class _T2>
    inline _GLIBCXX_CONSTEXPR bool
    operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return !(__y < __x); }

  /// Uses @c operator< to find the result.
  template<class _T1, class _T2>
    inline _GLIBCXX_CONSTEXPR bool
    operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return !(__x < __y); }

  template<class _T1, class _T2>
    inline void
    swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }


  template<class _T1, class _T2>
    constexpr pair<typename __decay_and_strip<_T1>::__type,
                   typename __decay_and_strip<_T2>::__type>
    make_pair(_T1&& __x, _T2&& __y)
    {
      typedef typename __decay_and_strip<_T1>::__type __ds_type1;
      typedef typename __decay_and_strip<_T2>::__type __ds_type2;
      typedef pair<__ds_type1, __ds_type2> 	      __pair_type;
      return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
    }
} // namespace std
花花...
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++STL容器篇(三)
qq_57558831的博客
12-19 649
1.set与mulset set(集合):数据自动去重，自动排序，默认从小到大，创建方式如下 #include<iostream> #include<set> using namespace std; int main() { set<int> s; s.insert(10); s.insert(10); s.insert(30); s.insert(20); for (set<int>::iterator it = s.begin();
AVL_Tree实现STL中的map, set, multimap和multiset
01-10
用AVL-tree数据结构作为底层机制，以STL底层空间配置器和iterator_traits编程技法实作出一个独立的关联式容器(map, set, multimap, multiset)，并对外提供接口实现和STL完全兼容的容器。
必读篇！STL关联式容器set、map、multiset、multimap源码剖析
董哥的黑板报
02-10 934
set语法使用参阅：https://blog.csdn.net/qq_41453285/article/details/100620892 map语法使用参阅：https://blog.csdn.net/qq_41453285/article/details/100609447 一、set set的特性 set所有元素都会根据元素的键值自动被排序 set中的键值就是实值，实值就是键值 ...
C++11 make_pair和pair
qq_41221841的博客
09-01 2111
先看这段代码： #include <iostream> int main() { std::string str = "hello world"; auto error = std::make_pair<int, std::string>(0, str); // error auto success = std::pair<int, std::string>(0, str); return 0; } 在`make_pair`时会报错： err
c++11:unordered_map和pair合用的坑
12-22 6794
事情是这样的， 今天在编译的时候报错，很长，报错的地方是std::ordered_map的insert操作，但换成stdmap就没问题， 大概是跟std::unordered_map和std::pair有关，我截取几段， error: no matching function for call to ‘std::pair<key, std::_List_iterator<long long int> >::pair(const key&, std::_List_ite
【C++自学笔记】STL-详细解析set、mulitset（关联式容器）
C/C++菜鸟养成记
08-22 891
一、set和multiset 的介绍和使用 1、set 1、set的介绍 set是按照一定次序存储元素的容器，在set 中，元素的 value也标识它（value就是key，类型为T），并且每个value必须是唯一的，set 中的元素不能在容器中修改（元素总是const），但是可以从容器中插入或者删除他们； 在内部，set中的元素总是按照其内部比较对象（类型比较）所指示的特定严格弱排序准则...
C++ STL入门教程(7) multimap、multiset的使用
12-31
C++ multimap和map所支持的操作相同（除了multimap不支持下标运算），但是multimap允许重复的元素。 完整程序代码： /*请务必运行以下程序后对照阅读*/ ///头文件依旧是map #include <map> #include #include ...
STL源码剖析.pdg
01-12
第5章 关联式容器（associated containers） 197 5.1 树的导览 199 5.1.1 二元搜寻树（binary search tree） 200 5.1.2 平衡二元搜寻树（balanced binary search tree） 203 5.1.3 avl tree（adelson-velskii-...
STL 源码剖析(侯捷先生译著)
09-09
第5章 关联式容器（associated containers） 197 5.1 树的导览 199 5.1.1 二元搜寻树（binary search tree） 200 5.1.2 平衡二元搜寻树（balanced binary search tree） 203 5.1.3 AVL tree（Adelson-Velskii-...
C++模板（vector、map、multimap、set、multiset）
08-05
一共四个doc文件，list综合实例、multimap和map的实例、set和multiset的综合实例、vector综合实例
set/multiset（集与多集）
枫闲言的博客
08-26 456
集与多集（set/multiset） v 与基本容器相比， 关联容器更注重快速和高效地检索数据的能力。 这些容器是根据键值 （key） 来检索数据的， 键可以是值也可以是容器中的某一成员。 这一类中的成员在初始化后都是按一定顺序排好序的。 v set和multiset容器类(集和多集):#include n 内部实现:红黑树 u 插入删除查找复杂度log(n) u 它
multiset用法总结
热门推荐
二喵君的博客
12-04 10万+
       c++语言中，multiset是&lt;set&gt;库中一个非常有用的类型，它可以看成一个序列，插入一个数，删除一个数都能够在O(logn)的时间内完成，而且他能时刻保证序列中的数是有序的，而且序列中可以存在重复的数。 简单应用： 通过一个程序来看如何使用multiset： #include &lt;string&gt; #include &lt;iostream&gt; ...
multiset的介绍及使用
gp1330782530的博客
05-28 1万+
multiset的介绍及使用 1、multiset的介绍 1、multiset是按照特定顺序存储元素的容器，其中元素是可以重复的 2、在multiset在，元素的value也会识别它组成的键值对，multiset元素的值不能在容器中进行修改，但可以插入和删除 3、在内部，multiset按照特定的严格弱排序准则进行排序 4、multiset容器通过key访问单个元素比unordered_multiset容器慢，但当使用迭代器遍历的时候，会得到一个有序序列 5、multiset的底层是二叉搜索树（红黑树）
Set和multiset容器
m0_46376834的博客
05-27 402
Set和multiset容器set/multiset容器概念Set 和 multiset 特点set/multiset对象的默认构造Set/multiset 对象的带参构造函数set对象的拷贝构造与赋值仿函数概念set的插入和pair的用法set与迭代器set/multiset的大小set/multiset的查找 set/multiset容器概念 set和multiset是一个集合容器，其中set所包含的元素是唯一的，集合中的元素按一定的顺序排列。set采用红黑树变体的数据结构实现，红黑树属于平衡二叉树。
【C++ STL学习之五】容器set和multiset
计算机专业同学的充电站。
04-14 7万+
一、set和multiset基础 set和multiset会根据特定的排序准则，自动将元素进行排序。不同的是后者允许元素重复而前者不允许。 需要包含头文件： #include set和multiset都是定义在std空间里的类模板： template<class _Kty, class _Pr = less, class _Alloc = allocator
set,multiset,map,multimap的区别 和基本的使用
qq_44065088的博客
10-16 239
#include <iostream> #include <set> #include <Windows.h> #include <string> #include <map> using namespace std; int main(void) { //值域 不重复 set set<int> ...
C++之set和multiset容器初学
sum_TW的博客
02-17 2200
Set和multiset容器 set/multiset的简介 set是一个集合容器，其中所包含的元素是唯一的，集合中的元素按一定的顺序排列。元素插入过程是按排序规则插入，所以不能指定插入位置。 set采用红黑树变体的数据结构实现，红黑树属于平衡二叉树。在插入操作和删除操作上比vector快。 set不可以直接存取元素。（不可以使用at.(pos)与[]操作符）。  multiset与se
STL六大组件与底层原理
geek！
09-13 1398
STL，即标准模板库(Standard Template Library)，是一些常用数据结构和算法模板的集合，主要由6大组成部分组成。
使用C++中的std::pair，返回两个不同类型的变量
W_Tortoise的博客
09-29 3193
1 前言 今天，遇到在一个函数中返回两个不同类型的变量的问题。其实，可以通过结构体解决此问题。 除了结构体，还可以使用C++中的std::pair。 当要返回多个变量（≥3）时，虽然std::pair可以通过嵌套实现，但最好还是用结构体。 2 std::pair的用法 2.1 介绍 pair能将2个数据组合成一个数据，stl中的map就是将key和value放在一起来保存。 另外，当一个函数需要返...
set multiset unorderedset map multimap unorderedmap
最新发布
11-01
set是一个关键字集合，其中每个关键字只能出现一次。multiset与set类似，但是允许关键字重复出现。unordered_set是一个无序的关键字集合，其中每个关键字只能出现一次。map是一个关键字-值对的集合，其中每个关键字只能出现一次。multimap与map类似，但是允许关键字重复出现。unordered_map是一个无序的关键字-值对的集合，其中每个关键字只能出现一次。 需要注意的是，unordered_set、unordered_map、unordered_multiset和unordered_multimap是使用哈希函数组织的，因此它们的元素是无序的。而set、map、multiset和multimap是使用红黑树组织的，因此它们的元素是有序的。 这些容器都可以在C++ STL中使用，它们都有自己的头文件。set和map的头文件是<set>和<map>，multiset和multimap的头文件是<set>和<map>，unordered_set和unordered_map的头文件是<unordered_set>和<unordered_map>，unordered_multiset和unordered_multimap的头文件是<unordered_set>和<unordered_map>。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值