À l'aide d'un tuple dans unordered_map

Les arguments de modèle pour une unordered_map ressemble à ceci:

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 est pas spécialisé pour les n-uplets (faites défiler vers le bas à la Norme spécialisations pour les types de bibliothèques). Par conséquent, vous devez fournir votre propre, quelque chose comme ceci:

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

Et enfin, Benjamin Lindley réponse déjà des adresses, vous devez utiliser std::make_tuple:

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

Le code a été saisi de À l'aide d'un std::tuple comme la clé de std::unordered_map et voici le Live Exemple.

OriginalL'auteur

Comme l'a souligné, std::hash n'est pas spécialisé pour les n-uplets. Toutefois, si votre tuple se compose de la norme hashable des types comme string et int, le code suivant à partir de générique-hash-pour-tuples-en-non-ordonnée-carte-non-ordonnée-set ajoutera automatiquement un tel soutien en c++11.

Il suffit de coller le code dans un fichier d'en-tête et de les inclure à chaque fois que nécessaire:

#include <tuple>
//function has to live in the std namespace 
//so that it is picked up by argument-dependent name lookup (ADL).
namespace std{
namespace
{
//Code from boost
//Reciprocal of the golden ratio helps spread entropy
//    and handles duplicates.
//See Mike Seymour in magic-numbers-in-boosthash-combine:
//    https://stackoverflow.com/questions/4948780
template <class T>
inline void hash_combine(std::size_t& seed, T const& v)
{
seed ^= hash<T>()(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
}
//Recursive template code derived from Matthieu M.
template <class Tuple, size_t Index = std::tuple_size<Tuple>::value - 1>
struct HashValueImpl
{
static void apply(size_t& seed, Tuple const& tuple)
{
HashValueImpl<Tuple, Index-1>::apply(seed, tuple);
hash_combine(seed, get<Index>(tuple));
}
};
template <class Tuple>
struct HashValueImpl<Tuple,0>
{
static void apply(size_t& seed, Tuple const& tuple)
{
hash_combine(seed, get<0>(tuple));
}
};
}
template <typename ... TT>
struct hash<std::tuple<TT...>> 
{
size_t
operator()(std::tuple<TT...> const& tt) const
{                                              
size_t seed = 0;                             
HashValueImpl<std::tuple<TT...> >::apply(seed, tt);    
return seed;                                 
}                                              
};
}

OriginalL'auteur Leo Goodstadt

Ici est une méthode à utiliser un tuple comme un élément clé pour une unordered_map sans l'aide d'un hachage de spécialisation:

#include <string>
#include <tuple>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <vector>
#include <unordered_map>
using namespace std;
string fToStr(unordered_map<double,int>& dToI,float x)
{
static int keyVal=0;
stringstream ss;
auto iter = dToI.find(x);
if(iter == dToI.end()) {
dToI[x]=++keyVal;
ss << keyVal;
} else {
ss <<  iter->second;
}
return ss.str();
}
typedef tuple<int,char,char> TICC;
const char ReservedChar=',';
string getKey(TICC& t)
{
stringstream ss;
ss << get<0>(t) << ReservedChar << get<1>(t) << ReservedChar << get<2>(t);
return ss.str();
}
int main()
{
unordered_map< string,TICC > tupleMp;
vector<TICC> ticc={make_tuple(1, 'a', 'b'),make_tuple(1, 'b', 'c'),make_tuple(2, 'a', 'b')};
for(auto t : ticc)
tupleMp[getKey(t)]=t;
for(auto t : ticc) {
string key = getKey(t);
auto val = tupleMp[key];
cout << "tupleMp[" << key << "]={" << get<0>(val) << "," << get<1>(val) <<  ","<< get<2>(val) << "} ";
}
cout << endl;
//for float tuple elements use a second float to int key map 
unordered_map< double,int > dToI;
vector<float> v{1.234,1.234001,1.234001};
cout << "\nfloat keys: ";
for(float f : v)
cout <<  setprecision(7) << f << "=" << fToStr(dToI,f) << " ";
cout << endl;
return 0;
}

De sortie est:

tupleMp[1,a,b]={1,a,b} tupleMp[1,b,c]={1,b,c} tupleMp[2,a,b]={2,a,b}
float keys: 1.234=1 1.234001=2 1.234001=2

OriginalL'auteur edW