C++ unordered_map/unordered_set 自定义键类型

1. unordered_map 和 unordered_set

template < class Key,                                    // unordered_map::key_type
           class T,                                      // unordered_map::mapped_type
           class Hash = hash<Key>,                       // unordered_map::hasher
           class Pred = equal_to<Key>,                   // unordered_map::key_equal
           class Alloc = allocator< pair<const Key,T> >  // unordered_map::allocator_type
           > class unordered_map;

template < class Key,                        // unordered_set::key_type/value_type
           class Hash = hash<Key>,           // unordered_set::hasher
           class Pred = equal_to<Key>,       // unordered_set::key_equal
           class Alloc = allocator<Key>      // unordered_set::allocator_type
           > class unordered_set;

2. 方法1

struct Bytes {
    size_t _nbytes;
    const char* _data;

    // key_equal
    bool operator==(const Bytes& bytes) const {
        if (_nbytes != bytes._nbytes) {
            return false;
        }
        return memcmp(_data, bytes._data, _nbytes) == 0;
    }
};

namespace std {
    // hasher
    template <>
    struct hash<Bytes> {
        // 与 string 的 hash 函数具有一致的结果
        size_t operator()(const Bytes& bytes) const {
            size_t value = 2166136261U;
            size_t prime = 16777619U;
            const char* data = bytes._data;

            for (size_t i = 0; i < bytes._nbytes; i++) {
                value ^= static_cast<size_t>(data[i]);
                value *= prime;
            }

            return value;
        }
    };
};

3. 方法2

struct Bytes {
    size_t _nbytes;
    const char* _data;
};

// key_equal
bool bytes_key_equal(const Bytes& bs1, const Bytes& bs2) {
    if (bs1._nbytes != bs2._nbytes) {
        return false;
    }
    return memcmp(bs1._data, bs2._data, bs1._nbytes) == 0;
}

// hasher
size_t bytes_hash(const Bytes& bytes) {
    size_t value = 2166136261U;
    size_t prime = 16777619U;
    const char* data = bytes._data;

    for (size_t i = 0; i < bytes._nbytes; i++) {
        value ^= static_cast<size_t>(data[i]);
        value *= prime;
    }

    return value;
}

int main() {
    size_t init_cap = 16;
    unordered_map<Bytes, string, function<size_t(const Bytes&)>, function<bool(const Bytes&, const Bytes&)>> umap(init_cap, bytes_hash, bytes_key_equal);

    Bytes bs;
    bs._data = "hello";
    bs._nbytes = 5;

    umap[bs] = "world";

    return 0;
}

参考资料

http://www.cplusplus.com/reference/unordered_set/unordered_set/

http://www.cplusplus.com/reference/unordered_map/

https://blog.csdn.net/y109y/article/details/82669620