C++哈希表实现：从原理到unordered_map/unordered

C++哈希表实现：从原理到unordered_map/unordered_set

随缘惜情·2026-08-18·阅读 22 GEO检测（免费）

C++哈希表unordered_map实现哈希冲突处理

|难度：普通|阅读约 18 分钟

1. 为什么需要自己实现哈希表容器？

在C++标准库中，unordered_map和unordered_set是两种非常实用的关联容器，它们基于哈希表实现，提供了O(1)时间复杂度的查找操作。但很多开发者只是停留在使用层面，对底层实现原理知之甚少。自己动手实现这两个容器，能带来几个显著好处：

首先，能深入理解哈希冲突处理的多种策略。标准库采用的是开链法（separate chaining），每个桶位置维护一个链表来处理冲突。通过实现这个过程，你会真正掌握负载因子（load factor）的意义，以及为什么当元素数量超过桶数量与最大负载因子的乘积时，需要进行rehash操作。

其次，可以优化迭代器失效问题。标准库容器在rehash时所有迭代器都会失效，自己实现时可以设计更灵活的迭代器策略。比如通过记录版本号，或者使用更智能的指针管理方式。

最后，这种实现过程能极大提升模板编程能力。unordered_map和unordered_set的底层结构高度相似，通过模板技巧可以复用大部分代码。这涉及到模板参数萃取、迭代器分类等高级技巧的实战应用。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 哈希表核心结构设计

2.1 节点与桶的基本结构

哈希表的核心是节点和桶数组。对于unordered_map，节点需要存储键值对；对于unordered_set，只需存储键。通过模板设计，可以让两者共享相同的底层结构：

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

桶数组使用vector存储节点指针，这样可以利用vector的动态扩容特性：

cpp复制std::vector<Node*> _table;

2.2 哈希函数与键值提取

不同类型的键需要不同的哈希策略。对于整数类型可以直接使用标准库的hash；对于字符串需要使用FNV或MurmurHash等算法。通过模板特化实现：

cpp复制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& str) {
        // FNV-1a哈希算法实现
        size_t hash = 14695981039346656037ULL;
        for(char c : str) {
            hash ^= c;
            hash *= 1099511628211ULL;
        }
        return hash;
    }
};

对于unordered_map，需要从pair中提取key；对于unordered_set，key就是元素本身。通过模板参数KeyOfT实现：

cpp复制template <class K, class T, class KeyOfT>
class HashTable {
    // ...
};

3. 关键操作实现细节

3.1 插入操作的完整流程

插入元素时需要处理三种情况：键已存在、发生哈希冲突、需要扩容。完整流程如下：

计算键的哈希值并定位桶位置
遍历链表检查键是否已存在
如果不存在则创建新节点
检查负载因子决定是否扩容
执行头插法插入新节点

cpp复制bool Insert(const T& data) {
    KeyOfT kot;
    const K& key = kot(data);
    
    // 检查负载因子
    if(_size == _table.size()) {
        size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
        Rehash(newSize);
    }
    
    size_t hashi = HashFunc<K>()(key) % _table.size();
    Node* cur = _table[hashi];
    while(cur) {
        if(kot(cur->_data) == key) {
            return false; // 键已存在
        }
        cur = cur->_next;
    }
    
    // 头插法
    Node* newnode = new Node(data);
    newnode->_next = _table[hashi];
    _table[hashi] = newnode;
    ++_size;
    
    return true;
}

3.2 扩容与重哈希策略

当元素数量超过负载因子（通常设为1.0）与桶数量的乘积时，需要扩容并重哈希。这个过程需要：

创建新的更大的桶数组（通常是2倍）
遍历所有现有节点，重新计算哈希位置
将节点转移到新数组
交换新旧数组

cpp复制void Rehash(size_t newSize) {
    std::vector<Node*> newTable(newSize, nullptr);
    for(size_t i = 0; i < _table.size(); ++i) {
        Node* cur = _table[i];
        while(cur) {
            Node* next = cur->_next;
            KeyOfT kot;
            size_t hashi = HashFunc<K>()(kot(cur->_data)) % newSize;
            
            cur->_next = newTable[hashi];
            newTable[hashi] = cur;
            
            cur = next;
        }
    }
    _table.swap(newTable);
}

4. 迭代器设计与实现

哈希表迭代器的核心挑战在于需要跨桶遍历。实现要点包括：

维护当前节点指针和桶数组引用
当当前链表遍历完毕时，需要找到下一个非空桶
需要处理空表和在尾部的特殊情况

cpp复制template <class K, class T, class KeyOfT>
struct __HashIterator {
    typedef HashNode<T> Node;
    typedef HashTable<K, T, KeyOfT> HT;
    
    Node* _node;
    HT* _pht;
    
    __HashIterator(Node* node, HT* pht)
        : _node(node), _pht(pht)
    {}
    
    T& operator*() {
        return _node->_data;
    }
    
    T* operator->() {
        return &_node->_data;
    }
    
    __HashIterator& operator++() {
        if(_node->_next) {
            _node = _node->_next;
        } else {
            KeyOfT kot;
            size_t hashi = HashFunc<K>()(kot(_node->_data)) % _pht->_table.size();
            ++hashi;
            while(hashi < _pht->_table.size()) {
                if(_pht->_table[hashi]) {
                    _node = _pht->_table[hashi];
                    return *this;
                }
                ++hashi;
            }
            _node = nullptr;
        }
        return *this;
    }
};

5. 完整容器封装

5.1 unordered_map的封装

基于哈希表实现map接口，主要工作是定义键值对类型和键提取方式：

cpp复制template <class K, class V>
class unordered_map {
    struct MapKeyOfT {
        const K& operator()(const std::pair<K, V>& kv) {
            return kv.first;
        }
    };
    
    HashTable<K, std::pair<K, V>, MapKeyOfT> _ht;
    
public:
    typedef typename HashTable<K, std::pair<K, V>, MapKeyOfT>::iterator iterator;
    
    iterator begin() { return _ht.begin(); }
    iterator end() { return _ht.end(); }
    
    std::pair<iterator, bool> insert(const std::pair<K, V>& kv) {
        return _ht.Insert(kv);
    }
    
    V& operator[](const K& key) {
        auto ret = _ht.Insert(std::make_pair(key, V()));
        return ret.first->second;
    }
};

5.2 unordered_set的封装

set的实现更简单，因为元素本身就是键：

cpp复制template <class K>
class unordered_set {
    struct SetKeyOfT {
        const K& operator()(const K& key) {
            return key;
        }
    };
    
    HashTable<K, K, SetKeyOfT> _ht;
    
public:
    typedef typename HashTable<K, K, SetKeyOfT>::iterator iterator;
    
    iterator begin() { return _ht.begin(); }
    iterator end() { return _ht.end(); }
    
    std::pair<iterator, bool> insert(const K& key) {
        return _ht.Insert(key);
    }
};

6. 性能优化与测试

6.1 素数桶数量策略

使用素数作为桶数量可以减少哈希冲突。可以预定义一组素数，在扩容时选择下一个更大的素数：

cpp复制const size_t PRIMES[] = {
    53, 97, 193, 389, 769, 1543, 3079, 6151, 12289, 24593
};

size_t GetNextPrime(size_t num) {
    for(size_t prime : PRIMES) {
        if(prime > num) return prime;
    }
    return PRIMES[sizeof(PRIMES)/sizeof(PRIMES[0]) - 1];
}

6.2 测试用例设计

需要覆盖各种边界条件：

插入重复键
插入大量数据触发多次rehash
各种类型的键（整数、字符串等）
迭代器遍历的正确性

cpp复制void TestUnorderedMap() {
    unordered_map<std::string, int> countMap;
    std::string arr[] = {"apple", "banana", "apple", "cherry"};
    
    for(auto& str : arr) {
        countMap[str]++;
    }
    
    for(auto& kv : countMap) {
        std::cout << kv.first << ":" << kv.second << std::endl;
    }
}

7. 常见问题与解决方案

7.1 迭代器失效问题

在哈希表扩容时，所有迭代器都会失效。解决方案：

记录版本号，迭代器保存创建时的版本
在每次修改操作时检查版本
如果版本不匹配则抛出异常

cpp复制class HashTable {
    size_t _version = 0;
    
    void Rehash() {
        ++_version;
        // ... rehash实现
    }
};

class iterator {
    size_t _version;
    HashTable* _pht;
    
    void CheckVersion() {
        if(_version != _pht->_version) {
            throw std::runtime_error("iterator invalid after rehash");
        }
    }
};

7.2 自定义类型作为键

当使用自定义类型作为键时，需要提供两个东西：

哈希函数特化
相等比较运算符

cpp复制struct Point {
    int x, y;
    bool operator==(const Point& other) const {
        return x == other.x && y == other.y;
    }
};

template <>
struct HashFunc<Point> {
    size_t operator()(const Point& p) {
        return p.x * 31 + p.y;
    }
};

8. 进阶优化方向

8.1 开放寻址法实现

除了开链法，还可以实现开放寻址法（open addressing）版本。核心区别在于：

不使用链表处理冲突
使用线性探测、二次探测或双重哈希寻找空位
需要标记已删除元素的位置

cpp复制enum State { EMPTY, EXIST, DELETE };

template <class T>
struct HashData {
    T _data;
    State _state = EMPTY;
};

template <class K, class T, class KeyOfT>
class HashTable {
    std::vector<HashData<T>> _table;
    
    size_t FindPos(const K& key) {
        size_t hashi = HashFunc<K>()(key) % _table.size();
        size_t i = 1;
        while(_table[hashi]._state != EMPTY) {
            if(_table[hashi]._state == EXIST && 
               KeyOfT()(_table[hashi]._data) == key) {
                return hashi;
            }
            hashi += i; // 线性探测
            hashi %= _table.size();
            ++i;
        }
        return hashi;
    }
};

8.2 局部性优化

标准库实现通常会对小对象进行优化，比如：

对于小的键值对，直接在桶数组存储数据而非指针
使用更紧凑的内存布局
针对特定平台优化缓存行使用

cpp复制// 小对象优化示例
union Slot {
    Node* node;
    T value;
    
    Slot() : node(nullptr) {}
    ~Slot() {}
};

constexpr size_t SmallSize = sizeof(T) <= sizeof(void*) * 2;
std::vector<Slot> _table;

void InsertSmall(const T& data) {
    if constexpr (SmallSize) {
        // 直接存储值
    } else {
        // 存储指针
    }
}

实现一个完整的哈希表容器是深入理解C++模板编程和数据结构的最佳实践之一。通过这个过程，你不仅会掌握标准库容器的内部工作原理，还能学习到如何设计高性能、可复用的数据结构。在实际项目中，这种底层实现经验能帮助你做出更合理的技术选型和性能优化决策。