Implementing heterogeneous lookup for spans in C++

Question

Heterogeneous lookup means that we can index into a hash map holding keys of type std::string using another compatible type that makes sense, such as absl::string_view. For example, the following code works (I'm using the Abseil library rather than C++20 in my code for some compatibility reasons):

std::string word = "bird";
absl::flat_hash_map<std::string, int> word_map;
word_map[word] = 1;
std::cout << word_map[absl::string_view(word)] << std::endl;

It makes sense that this can work (and indeed it does), since all we need to address a hash table is the ability to compute the hash function, and the ability to compare for equality. So reading the hashtable using this method should be straightforward, and writing the table also makes sense, since the hash table can create a new std::string holding the contents of the string view.

A std::vector<T> also has a lightweight analogue of a string view, the absl::Span<T> type. However, the corresponding lookup does not work:

std::vector<int> nums = {1, 2, 3, 4};
absl::flat_hash_map<std::vector<int>, int> int_map;
int_map[nums] = 1;
std::cout << int_map[absl::Span<int>(nums)] << std::endl;

The compiler complains on the last line that there is no match for operator[].

Question: How can I implement this heterogeneous lookup so that it works for vectors and spans in the same way as for strings and string views?

I can see that absl::Hash<std::vector<int>> and absl::Hash<absl::Span<int>> produce the same results, so there should not be too many obstructions to making this work.

Answer 1

You can implement Abseil's heterogeneous lookup feature by defining types to override hashing and comparing. Per documentation, they must be marked with an is_transparent trait to support conversion.

struct VectorHash {
    using is_transparent = void;

    size_t operator()(absl::Span<int> v) const {
        return absl::Hash<absl::Span<const int>>{}(v);
    }
    size_t operator()(const std::vector<int>& v) const {
        return absl::Hash<absl::Span<const int>>{}(absl::Span<const int>{ v.data(), v.size() });
    }
};

struct VectorEq {
    using is_transparent = void;

    bool operator()(const std::vector<int>& a, absl::Span<int> b) const {
        return std::equal(a.begin(), a.end(), b.begin(), b.end());
    }
    bool operator()(absl::Span<int> b, const std::vector<int>& a) const {
        return std::equal(a.begin(), a.end(), b.begin(), b.end());
    }
    bool operator()(const std::vector<int>& a, const std::vector<int>& b) const {
        return std::equal(a.begin(), a.end(), b.begin(), b.end());
    }
    bool operator()(absl::Span<int> b, absl::Span<int> a) const {
        return std::equal(a.begin(), a.end(), b.begin(), b.end());
    }
};

using int_map_t = absl::flat_hash_map<std::vector<int>, int, VectorHash, VectorEq>;

This will make lookup using at or find work. But [] will still fail. Why? Because the [] operator is an upsert - it creates the key if it doesn't exist. absl::string_view has an explicit conversion operator to std::string, so, creating a new std::string key from one works. absl::Span<int> does not have a conversion operator to std::vector<int>, so the operation fails.

If it's not an option to use at instead of [], you can still extend the type:

struct int_map_t : absl::flat_hash_map<std::vector<int>, int, VectorHash, VectorEq> {
    using absl::flat_hash_map<std::vector<int>, int, VectorHash, VectorEq>::flat_hash_map;
    using absl::flat_hash_map<std::vector<int>, int, VectorHash, VectorEq>::operator [];
    int& operator [](absl::Span<int> v) {
        return operator [](std::vector<int> { v.begin(), v.end() });
    }
};

Demo: https://godbolt.org/z/dW4av7

---

In the comments, you asked if it was possible to implement an operator [] override that doesn't copy the vector if the map entry exists, while still only doing one hash. This is a bit hacky and still might do extra comparisons, but I think you can accomplish this with a helper type that stores both a key and an already-computed hash:

struct VectorHashMemo {
    size_t hash;
    absl::Span<int> key;

    explicit operator std::vector<int>() const {
        return { key.begin(), key.end() };
    }
};

struct VectorHash {
    /* ...existing overloads... */
    size_t operator()(VectorHashMemo v) const {
        return v.hash;
    }
};

struct VectorEq {
    /* ...existing overloads... */

    bool operator()(const std::vector<int>& a, VectorHashMemo b) const {
        return operator()(a, b.key);
    }
    bool operator()(VectorHashMemo a, const std::vector<int>& b) const {
        return operator()(a.key, b);
    }
    bool operator()(VectorHashMemo b, VectorHashMemo a) const {
        return operator()(a.key, b.key);
    }
};

Then you can explicitly compute the hash only once, while accessing the map twice:

struct int_map_t : absl::flat_hash_map<std::vector<int>, int, VectorHash, VectorEq> {
    using absl::flat_hash_map<std::vector<int>, int, VectorHash, VectorEq>::flat_hash_map;
    using absl::flat_hash_map<std::vector<int>, int, VectorHash, VectorEq>::operator [];
    int& operator [](absl::Span<int> v) {
        VectorHashMemo hash = { absl::Hash<absl::Span<int>>{}(v), v };
        auto it = find(hash);
        if (it != end()) {
            return it->second;
        } else {
            // calls the explicit conversion operator
            return operator [](hash);
        }
        return operator [](std::vector<int> { v.begin(), v.end() });
    }
};

Demo: https://godbolt.org/z/fecevE