C++ 为什么对std:：unordered_集使用std:：hash函数时不区分大小写？

我的问题不是关于使用不区分大小写的std:：unordered_集，而是它是如何工作的

#include "stdafx.h"
#include <string>
#include <iostream>
#include <unordered_set>
#include "boost/algorithm/string.hpp"


struct case_insensitive_comparer
{
    bool operator () (const std::string& x, const std::string& y) const
    {
        return boost::iequals(x, y);
    }
};

using case_insensitive_set = std::unordered_set<std::string, std::hash<std::string>, case_insensitive_comparer>;

std::vector<std::string> permute_case(const std::string& s)
{
    std::vector<std::string> strs;

    // Iterate through all bitmasks, 1 for uppercase, 0 for lowercase
    int msb = 1 << (s.length() - 1);
    int upper = 1 << s.length();
    std::locale loc;
    for (int i = 0; i < upper; i++)
    {
        int bit = msb;
        std::string current = "";
        for (size_t j = 0; j < s.length(); j++, bit >>= 1)
            current += (bit & i) ? std::toupper(s[j], loc) : std::tolower(s[j], loc);

        strs.push_back(current);
    }

    return strs;
}

int main()
{
    std::vector<std::string> strs = permute_case("awesome");

    case_insensitive_set set(strs.begin(), strs.end());

    // Check the hash
    for (auto& s : strs)
        std::cout << s << " :" << std::hash<std::string>()(s) << "\n";

    // Check the element
    for (auto& s : set)
        std::cout << s << "\n";

    return 0;
}

#包括“stdafx.h”
#包括
#包括
#包括
#包括“boost/algorithm/string.hpp”
不区分大小写的结构比较器
{
布尔运算符（）（常数std:：string&x，常数std:：string&y）常数
{
返回升压：equals（x，y）；
}
};
使用不区分大小写的集合=std:：无序集合；
std:：vector permute_case（const std:：string&s）
{
std：：载体strs；
//遍历所有位掩码，1表示大写，0表示小写
int msb=1=1）
电流+=（位&i）？标准：：通电（s[j]，loc）：标准：：通电（s[j]，loc）；
strs.推回（当前）；
}
返回STR；
}
int main（）
{
std：：vector strs=置换案例（“可怕”）；
不区分大小写的集合（strs.begin（），strs.end（））；
//检查散列
用于（自动和s:strs）
问题是你有一个区分大小写的哈希器和一个不区分大小写的比较器。如果你使哈希器不区分大小写，那么你只会得到一个条目

例如：

#include <boost/algorithm/string/case_conv.hpp>

struct case_insensitive_hasher
{
  size_t operator()(const std::string& key) const
    {
      std::string keyCopy(key);
      boost::to_lower(keyCopy);
        return std::hash<std::string>()(keyCopy);
    }
};

using case_insensitive_set = std::unordered_set<std::string, case_insensitive_hasher, case_insensitive_comparer>;

#包括
结构大小写不敏感\u哈希器
{
大小运算符（）（常量std:：字符串和键）常量
{
std：：字符串键副本（key）；
升压：：至_下部（按键复制）；
返回std:：hash（）（keyCopy）；
}
};
使用不区分大小写的集合=std:：无序集合；

输出将只包含插入的第一个条目AWESOME。
让我们回忆一下a是如何工作的

容量为N的哈希表是一个bucket数组。bucket通常是一个链表或二叉搜索树。从概念上讲，您可以将哈希表视为

template <typename T>
class HashTable {
    std::vector<std::forward_list<T>> _buckets;

public:
    HashTable(size_t capacity = 16) : _buckets(capacity) {}
    size_t bucket_count() const { return _buckets.size(); }


bucket\u index
函数通常根据散列函数实现，然后使用容量取模：

private:
    static size_t bucket_index(const T& key, size_t cap) {
        return std::hash<T>()(key) % cap;
    }
};

因此，
hash%8
将始终是
4
，即所有128个键都将选择八个相同的bucket。还记得选择bucket后会发生什么吗？我们检查链接列表中是否已经存在一个键，这始终是真的，因此只有第一个键“AWESOME”将出现

太棒了

这就产生了一种错觉，仅仅替换
==
就可以了，而真正发生的只是MSVC的哈希函数质量非常差


为了进一步说明OP的代码“不起作用”，让我们切换到另一个标准库

AWESOME:1a285ecfc4bab378
真棒：acb9b7f4f69b16e2
真棒：fd66d9186a434601
真棒：254b008bd66d1e29
真棒：27cac8154bb934d0
...
真棒：a4e8c2140834341e
真棒：cfd12a83da4a4b0f
真棒：b4c4eb4c60968581
棒极了：BDCA27CD606F42
真棒：14ddc089ab5badb5

与MSVC的散列不同，libc++的散列分布非常均匀。libc++的无序_集的初始容量为2，并且两个存储桶都已填充，因此该集有两个元素：

太棒了
令人惊叹的

OP的代码一般不起作用


注意：这里我假设散列冲突是通过单独的链接处理的，并且没有动态调整大小，尽管这两种方法都不会进入图片，因为
=
总是返回
true
您是如何证明“它有效”的？在我的机器上，它打印出
AWESOmE
和
AWESOmE
，所以它不工作。你说的
不区分大小写的工作是什么意思？
？请解释你期望的内容和观察到的内容。这个解释非常…太棒了！太棒了！谢谢你的精彩解释。它确实回答了我的问题。你可以使用reserve（）增加无序_集合中的bucket数，然后MSVC显示原始代码不起作用。
private:
    static size_t bucket_index(const T& key, size_t cap) {
        return std::hash<T>()(key) % cap;
    }
};