Comment détecter si un type est std :: tuple ou non?

Question

Pourquoi j'ai une sortie étrange pour ce code? Comment tester un type dans le bon sens?

#include <iostream> 
#include <tuple> 
#include <type_traits> 

template<typename T> struct is_tuple : std::false_type {}; 
template<typename... Ts> struct is_tuple<std::tuple<Ts...>> : std::true_type {}; 

struct TraitBlock { 
    using BlockLocation = struct { std::uint64_t x, y, z; }; 
}; 

struct TraitRock {}; 

struct ItemTemplate{ 
    static constexpr auto traits = std::make_tuple(
     TraitBlock{}, 
     TraitRock{} 
    ); 
}; 

int main(){ 
    using A = std::tuple<char, int,double,char>; 
    std::cout << is_tuple<decltype(ItemTemplate::traits)>::value 
    << is_tuple<decltype(std::make_tuple(
     TraitBlock{}, 
     TraitRock{} 
    ))>::value 
    << std::endl; 
} 

J'utilise mingw64-gcc 7.2.0 avec std = C++ 17, je me suis sortie "01" Pourquoi je suis arrivé deux sorties différentes? Ne sont-ils pas du même type?

Answer 1

decltype(ItemTemplate::traits) est const std::tuple<TraitBlock, TraitRock>.

Vous devez donc gérer le qualificatif cv quelque part.

Answer 2

On notera que le type de ItemTemplate::traits (à savoir decltype(ItemTemplate::traits)) est const std::tuple<TraitBlock, TraitRock>, ce qui ne correspond pas au type spécifié (à savoir std::tuple<Ts...>) dans la spécialisation de is_tuple. Vous pouvez supprimer la constance par std::remove_const, par exemple.

std::cout << is_tuple<std::remove_const_t<decltype(ItemTemplate::traits)>>::value; 

ou ajouter une autre spécialisation pour const (et pourrait volatile aussi):

template<typename... Ts> struct is_tuple<std::tuple<Ts...>> : std::true_type {}; 
template<typename... Ts> struct is_tuple<const std::tuple<Ts...>> : std::true_type {}; 
template<typename... Ts> struct is_tuple<volatile std::tuple<Ts...>> : std::true_type {}; 
template<typename... Ts> struct is_tuple<const volatile std::tuple<Ts...>> : std::true_type {}; 

Answer 3

Vous devez supprimer tous les qualificatifs. Au lieu de faire tout cela vous-même, vous devez utiliser std::decay_t qui supprime tous les qualificatifs pour vous et l'envoi à votre trait. Par exemple

template<typename T> 
struct is_tuple_impl : std::false_type {}; 

template<typename... Ts> 
struct is_tuple_impl<std::tuple<Ts...>> : std::true_type {}; 

template<typename T> 
struct is_tuple : is_tuple_impl<std::decay_t<T>> {}