c++ templates variadic

c++ - Verificar el tipo de argumentos en una declaración de plantilla variadic



templates (2)

Obtuve una declaración de plantilla variad simple, como la clásica:

template <typename... Arguments> class VariadicTemplate;

Lo que necesito lograr es dejar que la clase VariadicTemplate realice alguna comprobación de tipos; la plantilla variadica debería verificar en alguna forma iterativa que todos los argumentos recibidos deben ser, por ejemplo, del tipo <Foo> .

He visto algo similar en alguna parte pero ahora no puedo reconocer dónde estaba: P


Aquí hay otra solución: P

Aquí está:

template <bool... b> struct static_all_of; // do recursion if the first argument is true template <bool... tail> struct static_all_of<true, tail...> : static_all_of<tail...> {}; // end recursion if first argument is false template <bool... tail> struct static_all_of<false, tail...> : std::false_type {}; // end recursion if no more arguments need to be processed template <> struct static_all_of<> : std::true_type {}; // First template argument is given as the type checking for the is_base_of() function template <typename Type, typename... Requirements> class CollectionOfCommonBase : public Requirements... { static_assert(static_all_of<std::is_base_of<Type, Requirements>::value...>::value, "One or more template arguments are not base_of the one specified - given template specialization is not allowed."); };

Entonces lo tienes trabajando para:

class Foo {}; class AFoo : public Foo {}; class BFoo : public Foo {}; class MyCollection : public CollectionOfCommonBase<Foo, AFoo, BFoo> {};


struct Foo {}; #include <type_traits> template<class T, class...> struct are_same : std::true_type {}; template<class T, class U, class... TT> struct are_same<T, U, TT...> : std::integral_constant<bool, std::is_same<T,U>{} && are_same<T, TT...>{}> {}; template<typename... Arguments> class VariadicTemplate { static_assert(are_same<Foo, Arguments...>{}, "a meaningful error message"); }; int main() { VariadicTemplate<Foo, Foo, Foo, Foo> v0{}; (void)v0; VariadicTemplate<Foo, int, Foo, double> v1{}; (void)v1; }

Pero algo me dice que quieres saber si los argumentos son todos especializaciones de una plantilla de clase Foo :

template<class T, class U> struct Foo {}; #include <type_traits> template<template<class...> class T, class U> struct is_template_of { template<class... TT> static std::true_type test(T<TT...>*); static std::false_type test(...); constexpr static bool value = decltype(test((U*)nullptr)){}; }; template<template<class...> class T, class...> struct is_template_of_N : std::true_type {}; template<template<class...> class T, class U, class... TT> struct is_template_of_N<T, U, TT...> : std::integral_constant<bool, is_template_of<T,U>::value && is_template_of_N<T, TT...>{}> {}; template<typename... Arguments> class VariadicTemplate { static_assert(is_template_of_N<Foo, Arguments...>{}, "a meaningful error message"); }; int main() { VariadicTemplate<Foo<int, double>, Foo<int, int>> v0; (void)v0; VariadicTemplate<Foo<int, double>, int> v1; (void)v1; }