What needs to be implemented in a class to use it as…

To use a class as a key in associative containers (e.g., std::map, std::unordered_map, std::set, std::unordered_set), the following must be implemented:

For ordered associative containers (std::map, std::set):
- Comparison operator "less than" (operator<): This operator defines the order of elements and is used by default by the comparator std::less. Containers use it to order keys. Alternatively:
- Specialization of std::less: You can specialize the std::less template for your class type, implementing the comparison logic there instead of inside the class.

For unordered associative containers (std::unordered_map, std::unordered_set):

Hash function: You need a way to obtain a hash from your class object. This can be:

Specialization of the std::hash template for your class type. This is the preferred way for integration with the standard library.

#include <functional>

// Example class
class MyKey {
public:
    int x;
    int y;

    bool operator==(const MyKey& other) const {
        return x == other.x && y == other.y;
    }
};

namespace std {
    template <>
    struct hash<MyKey> {
        size_t operator()(const MyKey& k) const {
            // Simple combination of field hashes
            // More complex combinations can provide better hash distribution
            return hash<int>()(k.x) ^ (hash<int>()(k.y) << 1);
        }
    };
}

User-defined hash structure: Passed as an additional template parameter to the container.

struct MyKeyHasher {
    size_t operator()(const MyKey& k) const {
        return std::hash<int>()(k.x) ^ (std::hash<int>()(k.y) << 1);
    }
};

// Usage: std::unordered_map<MyKey, ValueType, MyKeyHasher>

Equality operator (operator==): Needed to resolve hash collisions, allowing the container to determine if two objects with the same hash are truly equal.

#include <iostream>
#include <map>
#include <unordered_map>
#include <functional> // For std::hash

// Example class suitable for std::map
class KeyForMap {
public:
    int id;
    std::string name;

    // Comparison operator "less than" for std::map
    bool operator<(const KeyForMap& other) const {
        if (id != other.id) {
            return id < other.id;
        }
        return name < other.name;
    }

    // Equality operator can also be useful but is not strictly required for std::map by default
    bool operator==(const KeyForMap& other) const {
        return id == other.id && name == other.name;
    }
};

// Example class suitable for std::unordered_map
class KeyForUnorderedMap {
public:
    int x;
    int y;

    // Equality operator for std::unordered_map
    bool operator==(const KeyForUnorderedMap& other) const {
        return x == other.x && y == other.y;
    }
};

// Specialization of std::hash for KeyForUnorderedMap
namespace std {
    template <>
    struct hash<KeyForUnorderedMap> {
        size_t operator()(const KeyForUnorderedMap& k) const {
            // Combine hashes of fields
            return hash<int>()(k.x) ^ (hash<int>()(k.y) << 1);
        }
    };
}

int main() {
    // Usage in std::map
    std::map<KeyForMap, int> map_example;
    map_example[{1, "apple"}] = 10;
    map_example[{2, "banana"}] = 20;
    map_example[{1, "apple"}] = 15; // Replaces existing element

    // Usage in std::unordered_map
    std::unordered_map<KeyForUnorderedMap, int> unordered_map_example;
    unordered_map_example[{10, 20}] = 100;
    unordered_map_example[{30, 40}] = 200;
    unordered_map_example[{10, 20}] = 150; // Replaces existing element

    return 0;
}

What needs to be implemented in a class to use it as a key in associative containers?