C++ STL源码剖析 14-myhashtable

于 2024-10-11 07:00:00 发布
阅读量557 收藏 7
点赞数 17
分类专栏： C++ 文章标签： c++ 哈希算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wesigj/article/details/142745146
版权

系列文章目录

点击直达——文章总目录

文章目录

C++ STL源码剖析 14-myhashtable

Overview

1.myhashtable

下面是一个简单的 C++ 实现哈希表的例子，它使用了链地址法来解决哈希冲突。这个哈希表支持基本的插入、查找和删除操作。

#include <vector>
#include <list>
#include <functional>
#include <iostream>

template <typename K, typename V>
class HashTable {
public:
    // 构造函数，初始化一个指定大小的哈希表
    explicit HashTable(size_t size) : table(size) {}

    // 插入键值对
    void insert(const K& key, const V& value) {
        auto& bucket = table[bucket_index(key)];
        for (auto& pair : bucket) {
            if (pair.first == key) {
                pair.second = value; // 如果键已存在，则更新值
                return;
            }
        }
        bucket.push_back({key, value}); // 否则，在链表尾部插入新元素
    }

    // 按键查找值
    V* find(const K& key) {
        auto& bucket = table[bucket_index(key)];
        for (auto& pair : bucket) {
            if (pair.first == key) {
                return &pair.second; // 找到键，返回值的指针
            }
        }
        return nullptr; // 未找到键，返回nullptr
    }

    // 删除键值对
    void remove(const K& key) {
        auto& bucket = table[bucket_index(key)];
        auto it = std::find_if(bucket.begin(), bucket.end(),
                               [&key](const std::pair<K, V>& pair) { return pair.first == key; });
        if (it != bucket.end()) {
            bucket.erase(it); // 找到元素，从链表中移除
        }
    }

private:
    // 哈希函数，返回一个键的索引位置
    size_t bucket_index(const K& key) const {
        return std::hash<K>()(key) % table.size();
    }

    // 哈希表的存储，使用链表解决冲突
    std::vector<std::list<std::pair<K, V>>> table;
};

int main() {
    HashTable<int, std::string> hash_table(10); // 创建一个大小为10的哈希表

    hash_table.insert(1, "Kimi");
    hash_table.insert(2, "Moonshot AI");

    if (auto* value = hash_table.find(1)) {
        std::cout << "Found: " << *value << std::endl;
    } else {
        std::cout << "Not found" << std::endl;
    }

    hash_table.remove(1);

    if (auto* value = hash_table.find(1)) {
        std::cout << "Found: " << *value << std::endl;
    } else {
        std::cout << "Not found" << std::endl;
    }

    return 0;
}

这个哈希表使用 std::vector 来存储桶，每个桶是一个 std::list，用于存储具有相同哈希值的键值对。哈希函数使用 std::hash 来计算键的索引位置。

请注意，这个哈希表实现是基本的，没有考虑动态扩容、哈希碰撞优化、内存分配优化、异常安全或线程安全等因素。在实际应用中，你可能需要根据具体需求添加这些高级特性。此外，C++11 标准库已经提供了 std::unordered_map，它是一个高效的哈希表实现，通常比手写的哈希表性能更好，且具有更多功能。

2.动态扩容、哈希碰撞优化、内存分配优化、异常安全或线程安全等因素

要增加这些高级功能，我们需要对之前的哈希表实现进行扩展。以下是实现这些功能的大致步骤和代码示例：

2.1. 动态扩容

动态扩容涉及到在哈希表负载因子过高时增加哈希表的大小，并重新分配现有元素。

template <typename K, typename V>
class HashTable {
    // ...
    void rehash() {
        size_t old_size = table.size();
        size_t new_size = std::max(4, 2 * old_size); // 扩容至当前大小的2倍，至少为4
        std::vector<std::list<std::pair<K, V>>> new_table(new_size);

        for (auto& bucket : table) {
            for (auto& pair : bucket) {
                size_t new_index = bucket_index(pair.first, new_size);
                new_table[new_index].push_back(std::move(pair));
            }
        }

        table.swap(new_table);
    }

    size_t bucket_index(const K& key, size_t size) const {
        return std::hash<K>()(key) % size;
    }

    // ...
};

2.2. 哈希碰撞优化

使用更好的哈希函数或引入二级哈希来优化哈希碰撞。

struct BetterHash {
    size_t operator()(const K& key) const {
        // 实现一个更好的哈希函数
    }
};

template <typename K, typename V>
class HashTable {
    // ...
    BetterHash hash_function;
    // ...
    size_t bucket_index(const K& key) const {
        return hash_function(key) % table.size();
    }
    // ...
};

2.3. 内存分配优化

使用内存池来优化内存分配。

template <typename K, typename V>
class MemoryPool {
    // 实现一个简单的内存池
    // ...
};

template <typename K, typename V>
class HashTable {
    MemoryPool<std::pair<K, V>> pool;
    // ...
    void insert(const K& key, const V& value) {
        // 使用内存池来分配内存
    }
    // ...
};

2.4. 异常安全

确保哈希表的操作不会在抛出异常时导致资源泄露。

template <typename K, typename V>
class HashTable {
    // ...
    void insert(const K& key, const V& value) {
        auto index = bucket_index(key);
        auto& bucket = table[index];
        for (auto& pair : bucket) {
            if (pair.first == key) {
                pair.second = value;
                return;
            }
        }

        bucket.push_back(pool.allocate(std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(value)));
    }

    void rehash() {
        size_t old_size = table.size();
        size_t new_size = std::max(4, 2 * old_size);
        std::vector<std::list<std::pair<K, V>>> new_table(new_size);

        for (auto& bucket : table) {
            for (auto& pair : bucket) {
                auto& new_pair = *pool.allocate(std::piecewise_construct, std::forward_as_tuple(pair.first), std::forward_as_tuple(pair.second));
                size_t new_index = bucket_index(pair.first, new_size);
                new_table[new_index].push_back(std::move(new_pair));
            }
        }

        pool.release();
        table.swap(new_table);
    }
    // ...
};

2.5. 线程安全

引入互斥锁来确保线程安全。

template <typename K, typename V>
class HashTable {
    // ...
    mutable std::mutex mutex;
    // ...
    void insert(const K& key, const V& value) {
        std::lock_guard<std::mutex> lock(mutex);
        // 插入操作
    }
    V* find(const K& key) {
        std::shared_lock<std::mutex> lock(mutex);
        // 查找操作
    }
    void remove(const K& key) {
        std::lock_guard<std::mutex> lock(mutex);
        // 删除操作
    }
    // ...
};

这些示例提供了一个基本的框架，但实现细节需要根据具体情况进行调整和优化。在实际应用中，你可能需要考虑更多的边界情况和性能问题。

3.如何确保哈希表在动态扩容过程中不会丢失数据？

确保哈希表在动态扩容过程中不会丢失数据的关键在于如何在扩容时重新分配现有元素到新的哈希表中。以下是一些关键步骤和技巧：

  1. 使用临时哈希表：在扩容时，可以创建一个新的哈希表，并将旧哈希表中的所有元素重新插入到这个临时哈希表中。这样可以确保在扩容过程中不会丢失任何数据。

  2. 重新计算哈希值：在将元素从旧哈希表迁移到新哈希表时，需要重新计算每个元素的哈希值，以确定它们在新哈希表中的位置。

  3. 保持链表结构：如果使用链表来解决哈希冲突，那么在迁移过程中，需要确保链表的顺序和结构得以保持，以避免数据丢失。

  4. 同步操作：在多线程环境中，确保扩容操作是线程安全的。可以使用锁或其他同步机制来确保在扩容过程中不会有其他线程修改哈希表。

  5. 扩容策略：可以选择在插入操作时，如果发现负载因子超过预设阈值，就先进行扩容，然后再插入新元素。这样可以避免集中一次性迁移数据导致的耗时问题。

  6. 避免数据覆盖：在迁移数据时，确保不会覆盖新哈希表中已有的元素。如果新旧哈希表的索引位置相同，则需要将旧哈希表中的元素追加到新哈希表的链表尾部。

  7. 测试和验证：在实现动态扩容后，进行彻底的测试以确保没有数据丢失。可以设计测试用例来模拟大量插入、删除和扩容操作，验证哈希表的完整性。

通过上述方法，可以确保哈希表在动态扩容过程中的数据完整性和一致性。

4.在哈希表扩容过程中，如何优化链表结构以提高性能？

在哈希表扩容过程中，优化链表结构以提高性能的关键在于如何有效地重新分配现有元素到新的哈希表中。以下是一些优化策略：

  1. 使用更好的哈希函数：选择或设计一个好的哈希函数，以减少哈希冲突和提高键值对的均匀分布。

  2. 链表与红黑树的转换：在Java 8及以后的版本中，ConcurrentHashMap 使用红黑树替换了链表，当链表长度超过一定阈值时自动转换，以降低查找时间复杂度并提高性能。

  3. 动态调整哈希表大小：当负载因子超过预设阈值时，哈希表会扩容，这有助于减少冲突和提高性能。

  4. 优化内存使用：使用内存池来管理内存分配，以减少动态内存分配的开销。

  5. 避免数据覆盖：在迁移数据时，确保不会覆盖新哈希表中已有的元素。如果新旧哈希表的索引位置相同，则需要将旧哈希表中的元素追加到新哈希表的链表尾部。

  6. 扩容策略：可以选择在插入操作时，如果发现负载因子超过预设阈值，就先进行扩容，然后再插入新元素。这样可以避免集中一次性迁移数据导致的耗时问题。

  7. 测试和验证：在实现动态扩容后，进行彻底的测试以确保没有数据丢失。可以设计测试用例来模拟大量插入、删除和扩容操作，验证哈希表的完整性。

通过上述方法，可以确保哈希表在动态扩容过程中的数据完整性和一致性，同时提高性能。

5.在多线程环境下，除了使用锁，还有哪些方法可以保证哈希表扩容的线程安全？

在多线程环境下，除了使用锁，以下是一些保证哈希表扩容线程安全的方法：

  1. 无锁编程：使用原子操作（如CAS - Compare-and-Swap）来实现无锁的哈希表扩容。这种方法可以避免锁的开销，提高并发性能，但实现复杂度较高 。

  2. 分段锁（Segmentation Locks）：将哈希表分成多个段，每个段使用独立的锁。这样，不同线程可以同时操作不同的段，从而提高并发性能 。

  3. 乐观锁：使用乐观锁，如通过版本号或时间戳来确保在扩容过程中数据的一致性。

  4. 读写锁：使用读写锁（std::shared_mutex）来允许多个读线程同时访问，但写线程需要独占访问 。

  5. 锁分离：将读操作和写操作锁分开，使得读操作不需要等待写操作完成，从而提高并发性 。

  6. 使用std::atomic：对于某些简单的哈希表操作，可以使用std::atomic类型来保证操作的原子性，从而避免使用锁 。

  7. 扩容时的线程协作：在扩容过程中，多个线程可以协作，每个线程负责迁移一部分数据，通过原子操作和同步机制来协调各个线程的工作 。

  8. 使用Lock-Free Data Structures：采用无锁数据结构库，如Intel TBB（Threading Building Blocks）库中的并发哈希表。

  9. 避免共享：如果可能，避免在多个线程之间共享同一个哈希表实例。每个线程可以使用独立的哈希表，然后通过合并结果来实现线程安全。

  10. 细粒度锁：为哈希表的每个桶或元素使用独立的锁，这样可以减少锁的粒度，提高并发性 。

通过这些方法，可以在不同的场景下提高哈希表的线程安全性，使其在多线程环境中更加高效和稳定。

关于作者

WeSiGJ
关注
专栏目录
《STL源码剖析》深入剖析理解
qq_51969153的博客
07-24 569
《STL源码剖析》是由侯捷所著，是一本经典的C++ STL源码解析书籍，它深入剖析SGI版本的C++ STL源代码，解释了STL各个组件的实现原理和设计思路。
STL源码剖析--读书笔记（1）
Mr Liu的博客
08-03 2460
写在前面的话 近段时间看了侯捷老师的《STL源码剖析》，看第一遍的时候一头雾水，反复多看几遍，似乎明白了一些。因此将学到的知识做一个记录，也算是记录自己的学习过程。本系列博客主要记录一些宏观理解性的东西，具体的代码实现还是要仔细品味原书。 概览 STL即C++标准模板库，主要由六大部件组成，分别是：分配器、容器、迭代器、算法、仿函数、适配器。 在讲述这些主要部件之前，先来了解一下面向对象编程和泛型...
STL源码剖析
baidu_16370559的博客
04-13 1149
STL可分为容器(containers)、迭代器(iterators)、空间配置器(allocator)、配接器(adapters)、算法(algorithms)、仿函数(functors)六个部分。它们之间的关系可通过下图来说明。 容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据。 算法：各种常用的算法，如sort、find、copy、for_each等 迭代器：扮演了容器与算法之间的胶合剂。 仿函数：行为类似函数，可作为算法的某种策略。 适配器：一.
侯捷——STL源码剖析 笔记
weixin_45067603的博客
02-04 1万+
侯捷——STL源码剖析 笔记 1.总览 1.STL六大部件之间的关系 在下图中，我们使用了如下： 1.一个容器vector 2.使用vector时，使用分配器分配内存 3.使用vi.begin(),vi.end()即迭代器，作为算法的参数 4.使用count_if算法 5.使用仿函数less() 6.使用函数适配器来对我们算法的结果进行进一步筛选（not1, bind2nd） 2.复杂度 3.迭代器区间 迭代器是一个左开右闭的区间，也就是说迭代器的end是最后一个元素的下一个元素。 4.容器的结构和
STL源码剖析--概述
OSKernelLAB(gatieme)
03-20 2185
学习教程凝霜–对STL源代码加了详细的注释–但是看着不方便，一篇博文只讲一个文件C++ STL源码剖析–对凝霜的详细索引，一篇博客存储了所有的文件侯捷的网站这里写链接内容Github的STL索引 c++泛型编程编译器支持检测–代码对应书中1.8~1.9节概述STL源码剖析-侯捷C++标准链接库中隶属 STL 范围者，粗估当在 80%以上。对软件开发而言，STL 是尖?利兵，可以节省你许多时间。对
STL源码剖析---多态与虚拟---泛型编程与STL中文版
ztq_12345的博客
04-27 586
链接: https://pan.baidu.com/s/1TN5FBFwXcPhSoIUY1tUrsQ 提取码: 32wr
C++ STL详解超全总结(快速入门STL)
热门推荐
行码棋
02-24 16万+
C++STL合集，包含vector，stack，queue，map，set，array，tuple，deque，priority_queue等诸多内容，全文上万字。
STL（C++标准库，体系结构及其内核分析）（STL源码剖析）（更新完毕）
世界仙境与冷酷尽头's Blog
09-03 7219
STL（C++标准库，体系结构及其内核分析）（STL源码剖析）（更新完毕）
侯捷老师——STL源码剖析
linping_的博客
06-02 1287
generic programming GP 泛型编程 object oriented OO 面向对象 C++ Standard Library C++标准库 Standard Template Library STL 标准模板库 P1 认识headers、版本、重要资源 C++标准库中有百分之八十左右都是由 STL组成的 常用网站： cplusplus.com cppreference.com gcc.gnu.org 建议阅读书籍...
STL源码剖析总结
qq_42579966的博客
06-13 1760
记录侯捷《STL源码剖析》感悟学习
STL源码剖析--侯捷_繁体和简体版集合
06-15
《STL源码剖析》是侯捷先生的经典之作，它深入解析了标准模板库（Standard Template Library，简称STL）的内部实现机制，为读者揭示了C++编程中这一重要工具的奥秘。STL是C++编程中的核心组件，包含了一系列高效的...
C++ STL源码剖析（侯捷版本）_C语言_pdf_数据结构_
10-01
《C++ STL源码剖析（侯捷版本）》是一本深度解析C++ Standard Template Library (STL) 的经典著作，作者侯捷是知名的C++专家。这本书主要针对想要深入理解STL工作原理、提高编程技能的C++程序员，通过源码分析，帮助...
STL源码剖析--侯捷pdf
09-03
《STL源码剖析》是侯捷先生撰写的一本经典编程图书，专为有志于深入理解C++标准模板库（Standard Template Library，简称STL）的程序员所编写。这本书通过对STL源码的深入剖析，揭示了STL的设计原理、实现机制以及...
C++STL源码剖析--侯捷
03-24
《C++ STL源码剖析》是著名编程专家侯捷的一部经典著作，深入解析了C++标准模板库（Standard Template Library，简称STL）的内部实现机制和设计思想。STL是C++语言中极其重要的一部分，它提供了一组高效、可重用的...
STL源码剖析--侯捷
07-18
《STL源码剖析》是侯捷先生撰写的一本深入探讨C++标准模板库（Standard Template Library，简称STL）的著作。这本书以其详尽的分析和深入的讲解，为读者揭示了STL的设计原理、实现机制以及如何高效地使用STL。 STL...
PyQt 的Tree Widget中拖放和点击的异常行为
weixin_44617651的博客
10-10 261
在 PyQt 的 ​​QTreeWidget​​ 中，如果你遇到 拖放 和 点击 的异常行为，可能是由于信号处理、事件拦截、拖放设置或树结构配置等问题导致的。以下是一些可能的常见问题和解决方案。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1254
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
c_cpp_properties.json文件的作用
最新发布
程序员黄老师的精品课！
10-10 38
IntelliSense 是 VS Code 中内置的一个有用工具，它提供各种代码编辑功能，可帮助您更快、更高效地编写代码。例如，代码完成、参数信息、语法突出显示、代码操作（灯泡）和成员列表都是使用 IntelliSense 生成的。IntelliSense 配置存储在文件中，该文件在您的工作区中自动创建。如何产生 c_cpp_properties.json文件？这里配置一下头文件，就可以自动提示了，以OpenCV为例子。其中的属性可以在界面上改,文件会自动同步。
windows C++-创建数据流代理(三)
苏洛的博客
10-08 299
控制流指的是程序中操作的执行顺序。 控制流是通过使用条件语句、循环等控制结构调节的。 此外，数据流指的是一种编程模型，在这种模型中，只有当所有需要的数据都可用时，才会进行计算。 数据流编程模型与消息传递这一概念相关，其中程序的独立组件通过发送消息相互通信。 异步代理同时支持控制流和数据流编程模型。 尽管控制流模型适用于许多情况，但数据流模型也适用于其他一些情况，例如，当代理接收数据并执行基于该数据的有效负载的操作时。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

WeSiGJ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值