C++ 如何使用矢量变量作为无序_图中的键？

如何使用变量向量作为无序_图中的键

例如，我想让下面的代码正常工作

using VariantType = std::variant<int, std::string, unsigned int>;
using VecVariantType = std::vector<VariantType>;
std::unordered_map<VecVariantType, int, $some_hash_function$> m;

使用VariantType=std:：variant；
使用VecVariantType=std:：vector；
std：：无序映射m；

---

我如何实现$some\u hash\u function$？

我喜欢一个好主意

我不知道除了一个“我想知道我是否可以让它编译并运行”的示例之外，您将如何或为什么使用这样的东西

#包括
#包括
#包括
#包括
使用VariantType=std:：variant；
使用VecVariantType=std:：vector；
结构哈希器
{
size_t运算符（）（常量VecVariantType&v）常量
{
大小\u t散列=0；
用于（自动和val:v）
{
hash^=std:：hash（）（val）；
}
返回散列；
}
};
std:：ostream&Operator建议：不清楚或不清楚，不经修改就重新发布不是一个好主意。您确定需要这样的地图吗？这没有任何意义。将变量向量映射为int的示例是什么？这与你昨天问的问题本质上不一样吗@昨天的问题基本上是一个错误。代码示例省略了
向量
，在更正之前，问题的回答没有
向量
。由于答案是正确的，我回复了问题，并建议再次使用与上述相同的
向量
@Mansoor提问。这两种情况下的问题都缺乏MRE，但既然提问者知道这一点，并且知道他们所做的不会起作用，这应该足够清楚。是的，这可能仍然是一个XY问题，使用
变量的
向量
作为映射键很可能是一个糟糕的设计决策，具有更简单的替代方案，但问题的目标是明确的。至少对我来说这很清楚。好主意，也许不是。
#include <iostream>
#include <vector>
#include <unordered_map>
#include <variant>

using VariantType = std::variant<int, std::string, unsigned int>;
using VecVariantType = std::vector<VariantType>;

struct Hasher
{
    size_t operator()(const VecVariantType &v) const
    {
        size_t hash = 0;
        for (auto &val : v)
        {
            hash ^= std::hash<VariantType>()(val);
        }
        return hash;
    }
};

std::ostream& operator<<(std::ostream& out, std::pair<const VecVariantType, int> &p)
{
    out << "key: { ";
    bool needs_comma = false;
    for (auto &var : p.first)
    {
        if (needs_comma)
        {
            out << ", ";
        }
        if (std::holds_alternative<int>(var))
        {
            out << "int: " << std::get<int>(var);
            needs_comma = true;
        }
        if (std::holds_alternative<std::string>(var))
        {
            out << "string: " << std::get<std::string>(var);
            needs_comma = true;
        }
        if (std::holds_alternative<unsigned int>(var))
        {
            out << "uint: " << std::get<unsigned int>(var);
            needs_comma = true;
        }
    }
    out << " }, value: " << p.second;
    return out;
}

void lookup(const VecVariantType &var, std::unordered_map<VecVariantType, int, Hasher> &m)
{
    std::cout << "Lookup ";
    auto it = m.find(var);
    if (it != m.end())
    {
        std::cout << "success - " << *it << "\n";
    }
    else
    {
        std::cout << "failure\n";
    }
}

int main()
{
    std::unordered_map<VecVariantType, int, Hasher> m;
    auto one = VecVariantType { 1, "one", 1u };
    auto two = VecVariantType { 2, "two", 2u };
    auto three = VecVariantType { 3, "three", 3u };
    auto nnn = VecVariantType { 1, "one", 1u, 2, "two", 2u, 3, "three", 3u };
    m.emplace(one, 1);
    m.emplace(two, 2);
    m.emplace(three, 3);
    m.emplace(nnn, 999);

    std::cout << "Enumerating:\n";
    for (auto& item : m)
    {
        std::cout << "    " << item << "\n";
    }

    lookup(one, m);
    lookup(two, m);
    lookup(three, m);
    lookup(nnn, m);
}