C++ 哈希表封装实战：模拟实现 unordered_map 与 unordered_set

2.2 迭代器实现难点

哈希表的迭代器是单向迭代器。其核心逻辑在于 operator++ 的实现：

1. 如果当前桶下还有节点，直接指向下一个节点。
2. 如果当前桶遍历完了，需要找到下一个不为空的桶。

这需要迭代器持有哈希表对象的指针，以便计算当前桶位置并线性探测下一个有效桶。同时要注意 begin() 返回第一个非空桶的第一个节点，end() 通常用空指针表示。

对于 unordered_set，迭代器不支持修改元素；对于 unordered_map，key 不可修改，value 可以修改。这通过模板参数的 const 限定来控制。

2.3 支持 [] 操作符

unordered_map 的 [] 操作符依赖于 insert 的返回值。我们需要修改 HashTable 的 Insert 方法，使其返回 pair<Iterator, bool>，这样 operator[] 就能方便地判断是否插入成功并返回引用。

3. 完整代码实现

以下是核心组件的实现，包括 HashTable、unordered_set 和 unordered_map。

HashTable.h

这是最底层的哈希表实现，负责管理桶数组、节点链表以及扩容逻辑。

#pragma once
#include <vector>
#include <algorithm>

static const int __stl_num_primes = 28;
static const unsigned long __stl_prime_list[__stl_num_primes] = {
    53, 97, 193, 389, 769, 1543, 3079, 6151, 12289, 24593,
    49157, 98317, 196613, 393241, 786433, 1572869, 3145739,
    6291469, 12582917, 25165843, 50331653, 100663319, 201326611,
    402653189, 805306457, 1610612741, 3221225473, 4294967291
};

inline unsigned long __stl_next_prime(unsigned long n) {
    const unsigned long* first = __stl_prime_list;
    const unsigned long* last = __stl_prime_list + __stl_num_primes;
    const unsigned long* pos = std::lower_bound(first, last, n);
    return pos == last ? *(last - 1) : *pos;
}

template<class K>
struct HashFunc {
    size_t operator()(const K& key) { return (size_t)key; }
};

template<>
struct HashFunc<std::string> {
    size_t operator()(const std::string& key) {
        size_t hash = 0;
        for (auto ch : key) {
            hash += ch;
            hash *= 131;
        }
        return hash;
    }
};

namespace Hash_bucket {
    template<class T>
    struct HashNode {
        T _data;
        HashNode<T>* _next;
        HashNode(const T& data) :_data(data), _next(nullptr) {}
    };

    template<class K, class T, class Ref, class Ptr, class KeyOfT, class Hash>
    struct HTIterator {
        typedef HashNode<T> Node;
        typedef HashTable<K, T, KeyOfT, Hash> HT;
        typedef HTIterator Self;

        Node* _node;
        const HT* _pht;

        HTIterator(Node* node, const HT* pht) :_node(node), _pht(pht) {}

        Ref operator*() { return _node->_data; }
        Ptr operator->() { return &_node->_data; }

        Self& operator++() {
            if (_node->_next) {
                _node = _node->_next;
            } else {
                KeyOfT kot;
                Hash hs;
                size_t hashi = hs(kot(_node->_data)) % _pht->_tables.size();
                ++hashi;
                while (hashi < _pht->_tables.size()) {
                    if (_pht->_tables[hashi]) {
                        _node = _pht->_tables[hashi];
                        break;
                    } else {
                        ++hashi;
                    }
                }
                if (hashi == _pht->_tables.size()) {
                    _node = nullptr;
                }
            }
            return *this;
        }

        bool operator!=(const Self & s) const { return _node != s._node; }
        bool operator==(const Self & s) const { return _node == s._node; }
    };

    template<class K, class T, class KeyOfT, class Hash>
    class HashTable {
        template<class K, class T, class Ref, class Ptr, class KeyOfT, class Hash>
        friend struct HTIterator;

        typedef HashNode<T> Node;
    public:
        typedef HTIterator<K, T, T&, T*, KeyOfT, Hash> Iterator;
        typedef HTIterator<K, T, const T&, const T*, KeyOfT, Hash> ConstIterator;

        Iterator Begin() {
            if (_n == 0) return End();
            for (size_t i = 0; i < _tables.size(); i++) {
                if (_tables[i]) return Iterator(_tables[i], this);
            }
            return End();
        }

        Iterator End() { return Iterator(nullptr, this); }

        ConstIterator Begin() const {
            if (_n == 0) return End();
            for (size_t i = 0; i < _tables.size(); i++) {
                if (_tables[i]) return ConstIterator(_tables[i], this);
            }
            return End();
        }

        ConstIterator End() const { return ConstIterator(nullptr, this); }

        HashTable() :_tables(__stl_next_prime(1), nullptr), _n(0) {}

        ~HashTable() {
            for (size_t i = 0; i < _tables.size(); i++) {
                Node* cur = _tables[i];
                while (cur) {
                    Node* next = cur->_next;
                    delete cur;
                    cur = next;
                }
                _tables[i] = nullptr;
            }
            _n = 0;
        }

        pair<Iterator, bool> Insert(const T& data) {
            KeyOfT kot;
            if (auto it = Find(kot(data)); it != End()) return { it, false };

            Hash hs;
            // 负载因子接近 1 时扩容
            if (_n >= _tables.size()) {
                std::vector<Node*> newtables(__stl_next_prime(_tables.size() + 1), nullptr);
                for (size_t i = 0; i < _tables.size(); i++) {
                    Node* cur = _tables[i];
                    while (cur) {
                        Node* next = cur->_next;
                        size_t hashi = hs(kot(cur->_data)) % newtables.size();
                        cur->_next = newtables[hashi];
                        newtables[hashi] = cur;
                        cur = next;
                    }
                    _tables[i] = nullptr;
                }
                _tables.swap(newtables);
            }

            size_t hashi = hs(kot(data)) % _tables.size();
            Node* newnode = new Node(data);
            newnode->_next = _tables[hashi];
            _tables[hashi] = newnode;
            ++_n;
            return { Iterator(newnode, this), true };
        }

        Iterator Find(const K& key) {
            KeyOfT kot;
            Hash hs;
            size_t hashi = hs(key) % _tables.size();
            Node* cur = _tables[hashi];
            while (cur) {
                if (kot(cur->_data) == key) return { cur, this };
                cur = cur->_next;
            }
            return { nullptr, this };
        }

        bool Erase(const K& key) {
            KeyOfT kot;
            Hash hs;
            size_t hashi = hs(key) % _tables.size();
            Node* prev = nullptr;
            Node* cur = _tables[hashi];
            while (cur) {
                if (kot(cur->_data) == key) {
                    if (prev == nullptr) _tables[hashi] = cur->_next;
                    else prev->_next = cur->_next;
                    --_n;
                    delete cur;
                    return true;
                }
                prev = cur;
                cur = cur->_next;
            }
            return false;
        }

    private:
        std::vector<Node*> _tables;
        size_t _n;
    };
}

unordered_set.h

封装 HashTable，限制 key 为唯一且不可变。

#pragma once
#include "HashTable.h"

namespace jqj {
    template<class K, class Hash = HashFunc<K>>
    class unordered_set {
        struct SetKeyOfT {
            const K& operator()(const K& key) { return key; }
        };
    public:
        typedef typename Hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::Iterator iterator;
        typedef typename Hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::ConstIterator const_iterator;

        iterator begin() { return _ht.Begin(); }
        iterator end() { return _ht.End(); }
        const_iterator begin() const { return _ht.Begin(); }
        const_iterator end() const { return _ht.End(); }

        pair<iterator, bool> insert(const K& key) { return _ht.Insert(key); }
        iterator find(const K& key) { return _ht.Find(key); }
        bool erase(const K& key) { return _ht.Erase(key); }

    private:
        Hash_bucket::HashTable<K, const K, SetKeyOfT, Hash> _ht;
    };
}

unordered_map.h

封装 HashTable，支持 key-value 映射及 [] 操作符。

#pragma once
#include "HashTable.h"

namespace jqj {
    template<class K, class V, class Hash = HashFunc<K>>
    class unordered_map {
        struct MapKeyOfT {
            const K& operator()(const std::pair<K, V>& kv) { return kv.first; }
        };
    public:
        typedef typename Hash_bucket::HashTable<K, std::pair<const K, V>, MapKeyOfT, Hash>::Iterator iterator;
        typedef typename Hash_bucket::HashTable<K, std::pair<const K, V>, MapKeyOfT, Hash>::ConstIterator const_iterator;

        iterator begin() { return _ht.Begin(); }
        iterator end() { return _ht.End(); }
        const_iterator begin() const { return _ht.Begin(); }
        const_iterator end() const { return _ht.End(); }

        pair<iterator, bool> insert(const std::pair<K, V>& kv) { return _ht.Insert(kv); }

        V& operator[](const K& key) {
            pair<iterator, bool> ret = _ht.Insert(std::make_pair(key, V()));
            return ret.first->second;
        }

        iterator find(const K& key) { return _ht.Find(key); }
        bool erase(const K& key) { return _ht.Erase(key); }

    private:
        Hash_bucket::HashTable<K, std::pair<const K, V>, MapKeyOfT, Hash> _ht;
    };
}

Test.cpp

测试用例展示基本功能。

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

#include "unordered_map.h"
#include "unordered_set.h"

void Print(const jqj::unordered_set<int>& s) {
    jqj::unordered_set<int>::const_iterator it = s.begin();
    while (it != s.end()) {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
}

int main() {
    // 测试 unordered_set
    jqj::unordered_set<int> us;
    us.insert(3);
    us.insert(1000);
    us.insert(2);
    us.insert(102);
    us.insert(2111);
    us.insert(22);

    auto it = us.begin();
    while (it != us.end()) {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
    Print(us);

    // 测试 unordered_map
    jqj::unordered_map<string, string> dict;
    dict.insert({ "string", "" });
    dict.insert({ "left", "左边" });
    dict.insert({ "right", "右边" });

    dict["map"] = "地图";
    dict["left"] = "左边修改";

    for (auto& [k, v] : dict) {
        cout << k << ":" << v << endl;
    }
    return 0;
}

运行结果会显示插入的元素顺序（取决于哈希分布）以及 map 的键值对输出。通过这段代码，你可以直观地看到自定义容器与标准库行为的一致性。