Problem mit ungültiger Verwendung eines unvollständigen Typs bei Verwendung von std :: tuple_element

Question

Der folgende Code implementiert eine Hash-Funktion für eine std::tuple, die dann in einem anderen Segment meiner Codebasis in einer std::unordered_map von std::tuple s verwendet wird.

// compute hash function recursively through each std::tuple element 
template<class Tuple, std::size_t N> 
struct tuple_hash_compute { 
    static std::size_t hash_compute(const Tuple& t) { 
     using type = typename std::tuple_element<N-1, decltype(t)>::type; // OFFENDING LINE 
     return tuple_hash_compute<Tuple, N-1>::hash_compute(t) 
      + std::hash<type>()(std::get<N-1>(t)); 
    } 
}; 
// base helper 
template<class Tuple> 
struct tuple_hash_compute<Tuple, 1> { 
    static std::size_t hash_compute(const Tuple& t) { 
     using type = typename std::tuple_element<0, decltype(t)>::type; // OFFENDING LINE 
     return 51U + std::hash<type>()(std::get<0>(t))*51U; 
    } 
}; 
// tuple_hash function object 
struct tuple_hash { 
    template<class... Args> 
    std::size_t operator()(const std::tuple<Args...>& t) const { 
     return tuple_hash_compute<decltype(t), sizeof...(Args)>::hash_compute(t); 
    } 
    // will use std::unordered_map of std::pair too, so overload reqd 
    template<class Ty1, class Ty2> 
    std::size_t operator()(const std::pair<Ty1, Ty2>& p) const { 
     return tuple_hash_compute<decltype(t), 2>::hash_compute(p); 
    } 
}; 

Dann, als ein Beispiel, würde ich dieses Hash-Funktion-Objekt verwenden, wie so,

std::unordered_map<std::tuple<int,int,int>, std::size_t, tuple_hash> agg_map; 
agg_map.insert(std::make_pair(std::make_tuple(1,2,3), 0U)); 
agg_map.insert(std::make_pair(std::make_tuple(4,5,6), 1U)); 

jedoch sowohl in GCC 6.1.0 und MSVC2015, erhalte I die folgenden Fehler (beide das gleiche für jede Codezeile oben):

error: invalid use of incomplete type ' class std::tuple_element<2ul, const std::tuple<int,int,int>&> '

ich nicht ganz sicher bin, was diesen Fehler verursacht (obwohl es aufgrund von „Abstraktion“ sein kann, die std::tuple v vorbei ia der Vorlagenparameter Tuple) oder, wie es gelöst werden kann, damit jede mögliche Hilfe geschätzt wird.

Answer 1

Für einen Parameter, wie unten erklärt:

const Tuple& t 

decltype(t) ergibt:

const Tuple& 

ähnliche Weise für einen Parameter, wie erklärt:

const std::pair<Ty1, Ty2>& t 

decltype(t) Ausbeuten:

const std::pair<Ty1, Ty2>& 

In beiden Fällen ist der erzeugte Typ ein Verweis auf einen Tupel-ähnlichen Typ. Allerdings ist std::tuple_element nicht nach Referenzen spezialisiert, das heißt, der Compiler fällt zurück auf die primäre, undefinierte Klasse Vorlage:

template <size_t I, typename T> class tuple_element; 

Was Sie wollen, ist eine schlichtes Tuple im ersteren Fall und std::pair<Ty1, Ty2> im letzteren Fall .