Пара для неупорядоченных строк в качестве ключа для unordered_map

Question

Возможно связано: [ Unordered-MultiMap of Pairs, C++ unordered_map с использованием пользовательского типа класса в качестве ключа ]

Я хотел бы использовать пару строк без порядка в качестве ключа для моего unordered_map.

Например, я бы хотел, чтобы key1 был таким же, как key2

key1 = {"john", "doe"}; key2 = {"doe", "john"};

Может быть, мне здесь не хватает чего-то действительно глупого.

Вот мой тестовый код (работает не так, как хотелось бы):

struct Key {
    std::string first;
    std::string second;

    Key(std::string a, std::string b)
    {
        first = a;
        second = b;
    }

    bool operator==(const Key k) const
    {
        return ((first == k.first && second == k.second) ||
                (first == k.second && second == k.first));

    }

};

struct KeyHash {
    std::size_t operator()(const Key& k) const
    {
        return std::hash<std::string>()(k.first) ^
            (std::hash<std::string>()(k.second) << 1);
    }
};

struct KeyEqual {
    bool operator()(const Key& lhs, const Key& rhs) const
    {
        //return (lhs.first == rhs.first && lhs.second == rhs.second);  // not this

        return ((lhs.first == rhs.first && lhs.second == rhs.second) ||
            (lhs.first == rhs.second && lhs.second == rhs.first));

    }
};

void test_unorderedMap()
{
    Key s1("John", "Doe");
    Key s2("Doe", "John");
    Key s3("Mary", "Sue");
    Key s4("Sue", "Mary");

    // first attempt
    std::unordered_map<Key, std::string, KeyHash> m1;
    m1[s1] = "a";
    m1[s2] = "b";
    m1[s3] = "c";
    m1[s4] = "d";

    std::cout << "m6[s1] : " << m1.find(s1)->second << std::endl;   // prints .. a
    std::cout << "m6[s2] : " << m1.find(s2)->second << std::endl;   // prints .. b
    std::cout << "m6[s3] : " << m1.find(s3)->second << std::endl;   // prints .. c
    std::cout << "m6[s4] : " << m1.find(s4)->second << std::endl;   // prints .. d

    // second attempt
    std::unordered_map<Key, std::string, KeyHash, KeyEqual> m2;
    m2[s1] = "a";
    m2[s2] = "b";
    m2[s3] = "c";
    m2[s4] = "d";

    std::cout << "m2[s1] : " << m2.find(s1)->second << std::endl;   // prints .. a
    std::cout << "m2[s2] : " << m2.find(s2)->second << std::endl;   // prints .. b 
    std::cout << "m2[s3] : " << m2.find(s3)->second << std::endl;   // prints .. c
    std::cout << "m2[s4] : " << m2.find(s4)->second << std::endl;   // prints .. d
}

Answer 1

Для идентичных объектов хеш всегда должен быть равен. Так что, если вы считаете, что эти случаи равны:

Key s1("John", "Doe");
Key s2("Doe", "John");

Вы также должны убедиться, что оба хеша идентичны. Для этого вы можете, например, сначала отсортировать обе строки и создать хэш на основе отсортированных строк.