SGISTL源码阅读二十三 hashtable下

最新推荐文章于 2022-07-04 10:35:08 发布
最新推荐文章于 2022-07-04 10:35:08 发布
阅读量184 收藏
点赞数
分类专栏： STL相关 STL源码阅读 文章标签： hashtable STL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyn_00/article/details/84073067
版权

SGISTL源码阅读二十三 hashtable下

前言

之前介绍了hashtable的基本结构和它的构造方法，现在我们继续来学习它的迭代器和一些常用方法。

深入源码

hashtable的迭代器
//迭代器的声明
template <class Value, class Key, class HashFcn,
          class ExtractKey, class EqualKey, class Alloc>
struct __hashtable_iterator;
//和__hashtable_iterator类似，此处只列出__hashtable_iterator的实现
template <class Value, class Key, class HashFcn,
          class ExtractKey, class EqualKey, class Alloc>
struct __hashtable_const_iterator;

  /* Value:值的类型
   * Key:键的类型
   * HashFcn:哈希函数的函数型别(对象)
   * ExtractKey:从节点取出键的方法(对象)
   * EqualKey:判断键是否相同的方法(对象)
   * Alloc:空间配置器
   * 关于函数对象,它其实就是重载了()操作符,之后便可以像函数指针一样使用了,并且可以传递附加数据
   */
template <class Value, class Key, class HashFcn,
          class ExtractKey, class EqualKey, class Alloc>
struct __hashtable_iterator {
  typedef hashtable<Value, Key, HashFcn, ExtractKey, EqualKey, Alloc>
          hashtable;
  typedef __hashtable_iterator<Value, Key, HashFcn,
                               ExtractKey, EqualKey, Alloc>
          iterator;
  typedef __hashtable_const_iterator<Value, Key, HashFcn,
                                     ExtractKey, EqualKey, Alloc>
          const_iterator;
  typedef __hashtable_node<Value> node;

  //声明相应型别
  //我们可以看到迭代器类型是forward_iterator_tag
  //因为在buckets中节点是以链表的形式存储的
  typedef forward_iterator_tag iterator_category;
  typedef Value value_type;
  typedef ptrdiff_t difference_type;
  typedef size_t size_type;
  typedef Value& reference;
  typedef Value* pointer;

  //指向当前节点
  node* cur;
  /* 迭代器指向的节点所属的hashtable节点
   * 因为涉及到跳bucket的情况
   * 需要知道迭代器指向是哪个容器,所以需要hashtable* ht这个变量
   */
  hashtable* ht;
  //构造函数
  __hashtable_iterator(node* n, hashtable* tab) : cur(n), ht(tab) {}
  __hashtable_iterator() {}
  //操作符重载
  //返回当前节点的value值
  reference operator*() const { return cur->val; }
#ifndef __SGI_STL_NO_ARROW_OPERATOR
  //重载->
  pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
  //操作符重载的声明
  iterator& operator++();
  iterator operator++(int);
  bool operator==(const iterator& it) const { return cur == it.cur; }
  bool operator!=(const iterator& it) const { return cur != it.cur; }
};
  //...
//重载前++
template <class V, class K, class HF, class ExK, class EqK, class A>
__hashtable_iterator<V, K, HF, ExK, EqK, A>&
__hashtable_iterator<V, K, HF, ExK, EqK, A>::operator++()
{
  //暂存当前按节点
  const node* old = cur;
  cur = cur->next;
  //如果当前节点的下一个节点为空
  if (!cur) {
    //获取当前节点的bucket号
    size_type bucket = ht->bkt_num(old->val);
    //跳到下一个bucket去
    while (!cur && ++bucket < ht->buckets.size())
      cur = ht->buckets[bucket];
  }
  return *this;
}
//重载后++
template <class V, class K, class HF, class ExK, class EqK, class A>
inline __hashtable_iterator<V, K, HF, ExK, EqK, A>
__hashtable_iterator<V, K, HF, ExK, EqK, A>::operator++(int)
{
  iterator tmp = *this;
  //调用前++
  ++*this;
  return tmp;
}
resize

顾名思义，该函数的作用是实现当前hashtable扩容，我们知道hashtable中的buckets底层是由vector实现的，当容量不足是，vector的扩容机制是直接扩充到它原来大小的两倍，但是在hashtable中，有28个质数，桶的大小只能从里面选取，所以我们不能使用vector内部的扩容机制，只能自己实现。

template <class V, class K, class HF, class Ex, class Eq, class A>
void hashtable<V, K, HF, Ex, Eq, A>::resize(size_type num_elements_hint)
{
  //获取当前桶的数量
  const size_type old_n = buckets.size();
  //如果要求改变的值大于原来桶的数量（扩容）
  //如果不满足则什么也不用做
  if (num_elements_hint > old_n) {
    //获取一个合适的质数
    const size_type n = next_size(num_elements_hint);
    //如果还是比原来的桶数大
    if (n > old_n) {
      //创建一个新的vector
      vector<node*, A> tmp(n, (node*) 0);
      __STL_TRY {
        //将当前buckets中的节点复制到tmp中去
        for (size_type bucket = 0; bucket < old_n; ++bucket) {
          node* first = buckets[bucket];
          while (first) {
            size_type new_bucket = bkt_num(first->val, n);
            buckets[bucket] = first->next;
            first->next = tmp[new_bucket];
            tmp[new_bucket] = first;
            first = buckets[bucket];
          }
        }
        //交换两个buckets
        //完成了扩容操作
        buckets.swap(tmp);
      }
#         ifdef __STL_USE_EXCEPTIONS
      //处理异常情况，将新申请的vector中的空间全部释放，并抛出异常
      catch(...) {
        for (size_type bucket = 0; bucket < tmp.size(); ++bucket) {
          while (tmp[bucket]) {
            node* next = tmp[bucket]->next;
            delete_node(tmp[bucket]);
            tmp[bucket] = next;
          }
        }
        throw;
      }
#         endif /* __STL_USE_EXCEPTIONS */
    }
  }
}
hashtable的插入操作
  • insert_unique_noresize
    保证唯一性
template <class V, class K, class HF, class Ex, class Eq, class A>
pair<typename hashtable<V, K, HF, Ex, Eq, A>::iterator, bool>
hashtable<V, K, HF, Ex, Eq, A>::insert_unique_noresize(const value_type& obj)
{
  //获取当前节点应该放入的的bucket号
  const size_type n = bkt_num(obj);
  node* first = buckets[n];
  //遍历该桶，判断是否有重复节点
  for (node* cur = first; cur; cur = cur->next)
    //如果有重复的节点存在，则直接返回当前节点的位置和插入失败的信息
    if (equals(get_key(cur->val), get_key(obj)))
      return pair<iterator, bool>(iterator(cur, this), false);
  //新建一个节点
  node* tmp = new_node(obj);
  //以头插法装入桶中
  tmp->next = first;
  buckets[n] = tmp;
  ++num_elements;
  //返回当前节点的位置和插入成功的信息
  return pair<iterator, bool>(iterator(tmp, this), true);
}
  • insert_unique
    保证元素唯一唯一性的插入方式，根据不同的情况有很多的重载版本，因为过多，且思想基本一致，所以只列出了一部分。
  pair<iterator, bool> insert_unique(const value_type& obj)
  {
    //判断是否需要扩容
    resize(num_elements + 1);
    return insert_unique_noresize(obj);
  }
  template <class InputIterator>
  void insert_unique(InputIterator f, InputIterator l)
  {
    insert_unique(f, l, iterator_category(f));
  }
  template <class InputIterator>
  void insert_unique(InputIterator f, InputIterator l,
                     input_iterator_tag)
  {
    for ( ; f != l; ++f)
      insert_unique(*f);
  }
  template <class ForwardIterator>
  void insert_unique(ForwardIterator f, ForwardIterator l,
                     forward_iterator_tag)
  {
    size_type n = 0;
    distance(f, l, n);
    resize(num_elements + n);
    for ( ; n > 0; --n, ++f)
      insert_unique_noresize(*f);
  }
  //...
  • insert_equal_noresize
template <class V, class K, class HF, class Ex, class Eq, class A>
typename hashtable<V, K, HF, Ex, Eq, A>::iterator
hashtable<V, K, HF, Ex, Eq, A>::insert_equal_noresize(const value_type& obj)
{
  //获取当前节点应该放入的的bucket号
  const size_type n = bkt_num(obj);
  node* first = buckets[n];

  for (node* cur = first; cur; cur = cur->next)
    if (equals(get_key(cur->val), get_key(obj))) {
      //如果有重复节点则之间插在它的前面
      node* tmp = new_node(obj);
      tmp->next = cur->next;
      cur->next = tmp;
      ++num_elements;
      return iterator(tmp, this);
    }
  //如果没用重复节点
  //就插在桶的最前面
  node* tmp = new_node(obj);
  tmp->next = first;
  buckets[n] = tmp;
  ++num_elements;
  return iterator(tmp, this);
}
  • insert_equal
    不保证元素唯一唯一性的插入方式，根据不同的情况有很多的重载版本，因为过多，且思想基本一致，所以只列出了一部分。
  iterator insert_equal(const value_type& obj)
  {
    //判断是否需要扩容
    resize(num_elements + 1);
    return insert_equal_noresize(obj);
  }
  template <class InputIterator>
  void insert_equal(InputIterator f, InputIterator l)
  {
    insert_equal(f, l, iterator_category(f));
  }
  template <class InputIterator>
  void insert_equal(InputIterator f, InputIterator l,
                    input_iterator_tag)
  {
    for ( ; f != l; ++f)
      insert_equal(*f);
  }
  template <class ForwardIterator>
  void insert_equal(ForwardIterator f, ForwardIterator l,
                    forward_iterator_tag)
  {
    size_type n = 0;
    distance(f, l, n);
    resize(num_elements + n);
    for ( ; n > 0; --n, ++f)
      insert_equal_noresize(*f);
  }
  //...
find_or_insert

查找某个值，如果没有找到则把该值插入进去

template <class V, class K, class HF, class Ex, class Eq, class A>
typename hashtable<V, K, HF, Ex, Eq, A>::reference
hashtable<V, K, HF, Ex, Eq, A>::find_or_insert(const value_type& obj)
{
 //判断是否需要扩容
 //这里不是很懂，因为不是所有的情况都需要插入元素进去
 //如果调用了这个函数那么就可能会扩容，但是要是扩容了又没有插入元素进去，岂不是很划不来
  resize(num_elements + 1);

  size_type n = bkt_num(obj);
  node* first = buckets[n];
  //遍历整个桶
  for (node* cur = first; cur; cur = cur->next)
    //如果找到就返回val
    if (equals(get_key(cur->val), get_key(obj)))
      return cur->val;
  //没有找到就新建一个节点将它插入进去
  node* tmp = new_node(obj);
  tmp->next = first;
  buckets[n] = tmp;
  ++num_elements;
  return tmp->val;
}
hashtable的删除操作
erase_bucket
//指定node范围删除桶
template <class V, class K, class HF, class Ex, class Eq, class A>
void hashtable<V, K, HF, Ex, Eq, A>::erase_bucket(const size_type n,
                                                  node* first, node* last)
{
  //指向当前bucket
  node* cur = buckets[n];
  //从桶的头部删除到last指向的位置
  if (cur == first)
    erase_bucket(n, last);
  else {
    node* next;
    //找到开始删除的位置
    for (next = cur->next; next != first; cur = next, next = cur->next)
      ;
    //依次删除节点
    while (next) {
      cur->next = next->next;
      delete_node(next);
      next = cur->next;
      --num_elements;
    }
  }
}
//从桶的头部删除到last指向的位置
template <class V, class K, class HF, class Ex, class Eq, class A>
void
hashtable<V, K, HF, Ex, Eq, A>::erase_bucket(const size_type n, node* last)
{
  //指向当前bucket
  node* cur = buckets[n];
  //释放所有节点
  while (cur != last) {
    node* next = cur->next;
    delete_node(cur);
    cur = next;
    buckets[n] = cur;
    --num_elements;
  }
}
erase

它的删除操作也有非常多重载版本，但是核心思想都是类似的，我只选取了部分拿来讲解

template <class V, class K, class HF, class Ex, class Eq, class A>
typename hashtable<V, K, HF, Ex, Eq, A>::size_type
hashtable<V, K, HF, Ex, Eq, A>::erase(const key_type& key)
{
  //获取当前key值所在的bucket号
  const size_type n = bkt_num_key(key);
  node* first = buckets[n];
  size_type erased = 0;
  //如果bucket不为空
  if (first) {
    node* cur = first;
    node* next = cur->next;
    //遍历找到key值的节点，删除它
    while (next) {
      if (equals(get_key(next->val), key)) {
        cur->next = next->next;
        delete_node(next);
        next = cur->next;
        ++erased;
        --num_elements;
      }
      else {
        cur = next;
        next = cur->next;
      }
    }
    //将头节点分开处理，因为是链表
    if (equals(get_key(first->val), key)) {
      buckets[n] = first->next;
      delete_node(first);
      ++erased;
      --num_elements;
    }
  }
  //返回删除元素的数目
  return erased;
}
//...
//指定范围删除节点
template <class V, class K, class HF, class Ex, class Eq, class A>
void hashtable<V, K, HF, Ex, Eq, A>::erase(iterator first, iterator last)
{
  //如果迭代器当前节点不为空，则返回当前桶号，否则返回当前桶的数量
  size_type f_bucket = first.cur ? bkt_num(first.cur->val) : buckets.size();
  size_type l_bucket = last.cur ? bkt_num(last.cur->val) : buckets.size();
  //如果指向了同一个位置，就什么也不做
  if (first.cur == last.cur)
    return;
  //说明两个迭代器指向的是同一个桶
  //调用 erase_bucket
  else if (f_bucket == l_bucket)
    erase_bucket(f_bucket, first.cur, last.cur);
  //两个迭代器指向的不是同一个桶
  else {
    erase_bucket(f_bucket, first.cur, 0);
    for (size_type n = f_bucket + 1; n < l_bucket; ++n)
      erase_bucket(n, 0);
    if (l_bucket != buckets.size())
      erase_bucket(l_bucket, last.cur);
  }
}
clear
//清空所有桶中的节点
template <class V, class K, class HF, class Ex, class Eq, class A>
void hashtable<V, K, HF, Ex, Eq, A>::clear()
{
  //遍历所有的桶
  for (size_type i = 0; i < buckets.size(); ++i) {
    node* cur = buckets[i];
    //释放掉桶中的节点
    while (cur != 0) {
      node* next = cur->next;
      delete_node(cur);
      cur = next;
    }
    buckets[i] = 0;
  }
  num_elements = 0;
}
操作符重载
  //重载=
  hashtable& operator= (const hashtable& ht)
  {
    if (&ht != this) {
      //先将当前hashtable清空
      clear();
      //再依次复制
      hash = ht.hash;
      equals = ht.equals;
      get_key = ht.get_key;
      //调用copy_from
      copy_from(ht);
    }
    return *this;
  }  
//重载==
template <class V, class K, class HF, class Ex, class Eq, class A>
bool operator==(const hashtable<V, K, HF, Ex, Eq, A>& ht1,
                const hashtable<V, K, HF, Ex, Eq, A>& ht2)
{
  typedef typename hashtable<V, K, HF, Ex, Eq, A>::node node;
  //如果两个hashtable的长度不等，直接返回false
  if (ht1.buckets.size() != ht2.buckets.size())
    return false;
  //依次比较两个hashtable桶中的节点
  for (int n = 0; n < ht1.buckets.size(); ++n) {
    node* cur1 = ht1.buckets[n];
    node* cur2 = ht2.buckets[n];
    for ( ; cur1 && cur2 && cur1->val == cur2->val;
          cur1 = cur1->next, cur2 = cur2->next)
      {}
    //如果存在不相等的情况直接返回false
    if (cur1 || cur2)
      return false;
  }
  return true;
}

总结

我们分析了hashtable的迭代器以及插入删除等操作。
针对不同的情况，同一种操作有很多中重载的版本，可以看出STL是非常注重效率问题的。
接下来我们将要介绍到hashset和hashmap，他们的底层容器就是hashtable。

lynalmost
关注
专栏目录
STL源码剖析-hashtable
常思考->有目标->重实践->善反思
07-01 1027
hashtable(散列表)结构，在插入、删除、搜索等操作也具有”常数平均时间”的表现。 hashtable概述 举个例子，假设所有元素都是16bits，范围0~65535,简单的使用一个array即可以满足常数时间的插入、删除、搜索。 创建数组array A,拥有65536个元素，索引号码0~65535，初始值全部为0 当插入元素i就执行A[i]++，删除元素就执行A[i]–，如果搜...
SGISTL源码探究-STL中的hashtable(上)
Move_now的博客
09-18 1340
前言关于哈希表部分,哈希函数以及解决哈希冲突的方法都有很多种,在本文中不会详细去讨论哈希表的大量知识,而是以SGISTL实现的hashtable为主,所以如果对hashtable不太了解,建议先去网上查阅相关的资料。这里只给出基本的概念。了解哈希表原理基本概念哈希表(hashtable,也称散列表):根据key来访问元素的一种数据结构。它可能先经过哈希函数计算出key,然后通过key访问表中对应ke
STL源码：hashtable
Sunshine的专栏
03-31 1644
前面介绍的RB-tree红黑树中，可以看出红黑树的插入、查找、删除的平均时间复杂度为O(nlogn)。但这是基于一个假设：输入数据具有随机性。而哈希表/散列表hash table在插入、删除、查找上具有“平均常数时间复杂度”O(1)；且不依赖输入数据的随机性。          hash函数会带来一个问题：可能有不同的元素被映射到相同位置，这就是碰撞问题。解决碰撞的方法很多，hash table
SGISTL源码探究-STL中的hashtable(下)
Move_now的博客
09-18 1041
前言在上一小节中,我们介绍了hashtable的基本概念,以及分析了在STL中,hashtable的迭代器、采用的数据结构及它的构造/析构函数,还有部分成员函数。 在本小节中,我们讲继续分析剩下的一些操作,如插入、删除、复制等。插入操作关于插入操作,有大量的重载版本,我们只分析比较关键的函数,其他的可以随便看看。/* insert_unique,插入元素(不允许重复) * 首先先判断加上新增元素
STL hashtable 源码分析
07-30 918
在stl_hash_fun.h中,定义如下 inline size_t __stl_hash_string(const char* __s) { unsigned long __h = 0; for ( ; *__s; ++__s) __h = 5*__h + *__s; return size_t(__h); } __STL_TEMPLATE_NULL struct h
SGISTL源码-容器 笔记
weixin_46065476的博客
07-04 424
本文是在阅读SGI STL v3.3源码中，遇到的一些问题及有意思的点。本文建立在已经观看过侯捷老师STL源码剖析课程的基础上。是在阅读源码过程中，对其中的内容进行补充、修饰。
C++ STL库源代码(SGI版本)
最新发布
06-04
在这个“C++ STL库源代码(SGI版本)”中，我们主要关注的是SGI（Stanford Graphics Interface）实现的版本，这是一个广泛使用的开源实现，对STL进行了优化和扩展。 1. **algorithm**: 这个目录包含了许多通用的算法...
C++ STL（第十五篇：hashtable）
热门推荐
weixin_39640298的博客
04-19 1万+
1、hashtable hashtable 的目的是为了提供任何操作都是常数级别。SGI STL 中， hash table 使用了 开链法 实现的。大致的意思如下图所示： hash table 内的元素为 桶子（bucket），每个桶子里面有很多节点。其实有点像我们前面整理的 deque（双端队列），双端队列主控是个指向指针的指针，而hash table是一个vector；双端队列缓冲区是一块...
STL源码剖析——散列表hashtable
关注校招求职，微信号：job_campus
09-26 1950
与前面介绍的底层机制基于红黑树RB-Tree容器不同，本文介绍的是哈希表hash table，在SGI STL中，给出了底层机制基于哈希表的相关容器的介绍，这里介绍hash table的源码剖析，有利于对后面容器的理解。
STL源码剖析 hashtable
CHYabc123456hh的博客
11-26 1002
二叉搜索树具有对数平均时间的表现，但是这个需要满足的假设前提是输入的数据需要具备随机性 hashtable 散列表这种结构在插入、删除、搜寻等操作层面上也具有常数平均时间的表现。而且不需要依赖元素的随机性，这种表现是以统计为基础的 hashtable的概述 hashtable可提供对任何有名项的存取和删除操作 因为操作的对象是有名项，因此hashtable可以作为一种字典结构 将一个元素映射成为一个 “大小可以接受的索引”简称为hash function散列函数 考虑到元素的个数大于array的容
《STL源码剖析》---stl_hashtable.h阅读笔记
KangRoger的专栏
08-17 3523
哈希表/散列表hash table在插入、删除、查找上具有“平均常数时间复杂度”O(1)，hash table原理大部分都了解，具体实现还是要看其源代码。
STL源码分析 哈希表(hashtable)
qq_24447809的博客
12-18 661
源代码来自sgi-2.91版本stl_hashtable.h 哈希表概念 哈希表又叫做散列表，本质来说就是充分利用空间的一种思想。 （1）一块内存分为53块，并编号#0 - #52区号，存入的object也编号，5存入#5号，25存入#25号，59%53= 6,59号object也放入#6号，108%53= 2,108号object也放入#2号，那如果继续存入2号、55号object呢？它们会共占一块空间。 为了解决空间碰撞，我们把#0-#52当成一个指针数组，每个#号指向一块链表，每次有重复号码进入时，就
stl源码分析之hash table
weixin_30300523的博客
08-21 136
本文主要分析g++ stl中哈希表的实现方法。stl中，除了以红黑树为底层存储结构的map和set，还有用哈希表实现的hash_map和hash_set。map和set的查询时间是对数级的，而hash_map和hash_set更快，可以达到常数级，不过哈希表需要更多内存空间，属于以空间换时间的用法，而且选择一个好的哈希函数也不那么容易。 一、 哈希表基本概念 哈希表，又名散列表，是根据关键字直...
STL学习——Hashtable篇
没有最好，只有更好！
05-07 3815
STL学习——Hashtable篇 概述hash table（散列表）是一种在插入，删除，搜索等操作“常数平均时间”完成的数据结构。它是一种字典结构。哈希函数是一种映射函数，它能够将大数映射为小数。负责将某一元素映射为一个“大小可接受之索引”。哈希函数使用过程中可能会出现不同的元素被映射到相同的位置（相同的索引），称为哈希碰撞。解决哈希碰撞的方法：线性探测，二次探测，开链等等。负载系统：指元素个数除
C++进阶——STL源码之hashtable
qq_25065595的博客
09-04 1171
STL源码之hashtable hashtable 是一种在插入、删除、搜寻等操作上也具有 “常数平均时间”（散列表）的数据结构，而且这种表现是以统计为基础，不需依赖输入元素的随机性。 STL中hashtable是实现hash_map和hash_set的底层。它解决冲突的方式是开链法，每个放置索引值的节点称为桶节点（也就是该索引值的头结点），桶节点里放着一个value值，一个指向下一个节点的next指针。 维护了一个vector<node *> buckets存放所有桶节点，...
STL _Hashtable源码分析
愤怒的弱鸡
09-01 638
_Hashtable STL中并没有提供直接提供hashtable，而是通过将其封装为unordered_map和unordered_set来供外部使用，也可以说它们是由_Hashtable来实现的。 其_Hashtable的结构如下，其与传统的hash list有相同点但也存在些许不同。 同： _M_buckets为nodes指针数组，其保存了node的地址。而nodes中主要保存了2个元素，分别为next指针和value。 增删改查过程基本相似，主要分为两个步骤。首先计算hash(key)，获取的bu
STL源码剖析：hashtable
qq_32284397的博客
02-12 276
hashtable(散列表)数据结构，在插入、删除、搜寻操作上具有常数时间表现，而且这种表现是以统计为基础的，不需要依赖输入元素的随机性。 使用hash function，可能会使得不同的元素被映射到相同的位置（也就是相同的索引），这就是碰撞问题，通常有以下的解决方法：线性探测、二次探测、开链等做法。 线性探测 负载系数，元素个数除以表格大小，负载系数永远在0-1之间，除非采用开链策略。 当has...
STL源码剖析之哈希表 hashtable【2013.12.06】
木心[ mx1024 ] 欢迎
12-06 3480
STL源码剖析之哈希表 hashtable【2013.12.06】 欢迎加入我们的QQ群，无论你是否工作，学生，只要有c / vc / c++ 编程经验，就来吧！158427611  哈希表，一种键值对用的关系。具有关联性。 也称散列表，主要是通过特殊算法建立值和键的关系，然后根据键值对应存储和搜索。 因为是键值对应的关系，所以再键的存储上面，会出现一种【碰撞】问题，即
SGISTL源码阅读五 迭代器上（迭代器的五种相应型别associated types）
Lyn&Xx
11-11 484
SGISTL源码阅读五 迭代器上（迭代器的五种相应型别associated types） 前言 之前在对STL的简介中说到过，迭代器的作用是将数据结构（容器）和算法粘合在一起，我们可以将它理解成smart pointer，它是一种行为类似指针的对象。 什么是相应型别？ 最初看到这个翻译觉得这个概念特别高大上，但是我们不要把它想得太复杂。 大家应该比较熟悉sizeof()吧，我们可以调用它来获取变量...
STL中hashtable的实现
09-11
STL中的`hashtable`实现是基于开放寻址法和链表法的哈希表，用来实现关联容器`unordered_map`和`unordered_set`。 哈希表使用一个桶数组来存储数据，每个桶中可以存储多个元素。在哈希表中，元素被散列到特定的桶中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值