Déterminer si un pack est vide ou non

Question

Quelqu'un peut-il expliquer pourquoi cette assertion statique est fausse? Comment redéfinir is_empty pour qu'il fonctionne comme je le souhaite (sans changer la syntaxe)? Un type qui n'est pas un pack que je veux évaluer à false par défaut (par exemple is_empty<int>::value doit être faux).

#include <type_traits> 
template <typename Pack> struct is_empty : std::false_type {}; 

template <typename T, template <T...> class Z, T... Is> 
struct is_empty<Z<Is...>> : std::true_type {}; 

template <typename T, template <T...> class Z, T First, T... Rest> 
struct is_empty<Z<First, Rest...>> : std::false_type {}; 

template <int...> struct Z; 

int main() { 
    static_assert(is_empty<Z<>>::value); 
} 

Answer 1

Le problème est le type T contenu dans Z ne peut pas être déduit.

Fonctionne si vous l'explicite et je ne sais pas comment éviter d'explicite.

#include <type_traits> 

template <typename...> 
struct is_empty : std::false_type 
{ }; 

template <typename T, template <T...> class Z, T... Is> 
struct is_empty<T, Z<Is...>> : std::true_type 
{ }; 

template <typename T, template <T...> class Z, T First, T... Rest> 
struct is_empty<T, Z<First, Rest...>> : std::false_type 
{ }; 

template <int...> struct Z; 

int main() { 
    static_assert(is_empty<int, Z<>>::value, "!"); 
} 

- EDIT -

Works si votre Z exigent un premier type d'argument (la manière de std::integer_sequence); De cette façon, la déduction fonctionne

#include <type_traits> 

template <typename> 
struct is_empty : std::false_type 
{ }; 

template <typename T, template <typename U, U...> class Z, T... Is> 
struct is_empty<Z<T, Is...>> 
    : std::integral_constant<bool, sizeof...(Is) == 0U> 
{ }; 

template <typename T, T ...> 
struct X 
{ }; 

template <int ... Is> 
using Y = X<int>; 

int main() 
{ 
    static_assert(is_empty<X<int>>::value, "!"); 
    static_assert(is_empty<Y<>>::value, "!"); 
} 

- EDIT 2-

Dans 17 œuvres C + avec auto

#include <type_traits> 

template <typename Pack> 
struct is_empty : std::false_type 
{ }; 

template <template <auto...> class Z, auto... Is> 
struct is_empty<Z<Is...>> : std::bool_constant<sizeof...(Is) == 0U> 
{ }; 

template <int...> 
struct X; 

int main() 
{ 
    static_assert(true == is_empty<X<>>::value); 
    static_assert(false == is_empty<X<1>>::value); 
    static_assert(false == is_empty<int>::value); 
} 

Answer 2

Pourquoi faites-vous cela?

Vous pouvez faire sizeof...(args) pour déterminer la longueur du bloc de paramètres .. S'il est 0, alors il est vide:

#include <iostream> 

template<typename... Args> 
void func(Args... args) 
{ 
    std::cout<<(sizeof...(args)); 
} 

int main() { 

    func(1, 2, 3); 
    func(); 
    func(1); 
    func(1, 2); 
    func(1, 2, 3, 4); 

    return 0; 
}