在 unordered_map 中使用元组

Question

我想使用由 int 、 char 、 char 组成的元组在我的 unordered_map 中。我正在这样做：

 #include <string>
#include <unordered_map>
#include <cstring>
#include <iostream>
#include <tuple>

using namespace std;

tuple <int,char,char> kk;
unordered_map<kk,int> map;

int main()
{
    map[1,"c","b"]=23;
    return 0;
}

但这给了我以下错误：

 map.cpp:9:21: error: type/value mismatch at argument 1 in template parameter list     for ‘template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc> class    std::unordered_map’
map.cpp:9:21: error:   expected a type, got ‘kk’
map.cpp:9:21: error: template argument 3 is invalid
map.cpp:9:21: error: template argument 4 is invalid
map.cpp:9:21: error: template argument 5 is invalid
map.cpp:9:26: error: invalid type in declaration before ‘;’ token
map.cpp: In function ‘int main()’:
map.cpp:14:16: error: assignment of read-only location ‘"b"[map]’

我在这做错了什么？

原文由 Xara 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

unordered_map 的模板参数如下所示：

 template<

    class Key,
    class T,
    class Hash = std::hash<Key>,
    class KeyEqual = std::equal_to<Key>,
    class Allocator = std::allocator< std::pair<const Key, T> >
> class unordered_map;

std::hash 不适用于元组（向下滚动到库类型的标准特化）。因此，您需要提供自己的，如下所示：

 typedef std::tuple<int, char, char> key_t;

struct key_hash : public std::unary_function<key_t, std::size_t>
{
 std::size_t operator()(const key_t& k) const
 {
   return std::get<0>(k) ^ std::get<1>(k) ^ std::get<2>(k);
 }
};
// ..snip..
typedef std::unordered_map<const key_t,data,key_hash,key_equal> map_t;
//                                             ^ this is our custom hash

最后，正如 Benjamin Lindley 已经回答的那样，您需要使用 std::make_tuple ：

 // d is data
m[std::make_tuple(1, 'a', 'b')] = d;
auto itr = m.find(std::make_tuple(1, 'a', 'b'));

代码是从 Using a std::tuple as key for std::unordered_map 中获取的，这里是 Live Example 。

原文由 user1508519 发布，翻译遵循 CC BY-SA 3.0 许可协议

Answer 2

使用 std::integer_sequence 可以帮助：

 struct hash_tuple {
    template <std::size_t...Index>
    size_t recursive_hash(const auto &x) const{
        return (boost::get<Index>(x) ^ ... );
    }

    template <template <typename> class Ts,typename...Args>
    size_t operator()(const Ts<Args...>& x) const{
        return recursive_hash<std::make_integer_sequence<int,sizeof...(Args)>>(x);
    }
};

using Map = std::unordered_map<Key, int, hash_tuple>;

此代码对于所有用作键的元组都是通用的

原文由 Benjamin-Elias Probst 发布，翻译遵循 CC BY-SA 4.0 许可协议