Mieszanie typów i nietypów w parametrach szablonu variadic?

Question

Czy możliwe jest mieszanie typów i nietypów w parametrach szablonu wariasu? Gdybym miał przekazać std::array na przykład do tej klasy jako parametr T, musiałbym również przekazać typ tablicy i długość, ale sposób, w jaki ją wypróbowałem, powoduje błąd podczas napotykania wartości, ponieważ tylko ona oczekuje typy na Types:

template < 
    template<class, std::size_t> class T, 
    class ... Types> 
class C { 

    T<Types...> storage; 
}; 

int main(){ 
    C<std::array, int, 3> c; 
} 

komunikat o błędzie:

error: template argument for template type parameter must be a 
     type 
    Container<std::array, int, 3> c; 
          ^

Czy istnieje sposób, aby przekazać typy i wartości w zmiennej liczbie argumentów kontekście?

Answer 1

Jak widzisz, masz już na stałe zakodowany numer i typy parametrów, które klasa T musi przyjąć jako parametr szablonu. Nie potrzebujesz tutaj szablonów variadic. Wystarczy zrobić to zamiast:

template < 
    template<class, std::size_t> class T, 
    class A, std::size_t N> 
class C { 

    T<A, N> storage; 
}; 

int main(){ 
    C<std::array, int, 3> c; // works! 
} 

Jeśli chcesz użyć zmiennej liczbie argumentów szablonów, a następnie umieścić go w parametrze szablon szablon też:

template < 
    template<typename...> class T, 
    typename... Types> 
class C { 

    T<Types...> storage; 
}; 

Jeśli chcesz korzystać z tej wersji, ale nadal chcą korzystać std::array można utworzyć alias do std::array który ma już rozmiar:

template<typename T> 
using array3 = std::array<T, 3>; 

C<array3, int> c; 

Alternatywnie, można również stworzyć jakiś szablon szablon alias który niech Y ou wybrać rozmiar:

template<std::size_t n> 
struct sized_array { 
    template<typename T> 
    using array = std::array<T, n>; 
}; 

C<sized_array<5>::array, int>; 

Answer 2

Czy można zrobić mieszanie rodzajów i nontypes w zmiennej liczbie argumentów parametrów szablonu?

Nie. Nie można łączyć ze sobą. Ale ponieważ można owinąć wartości w rodzaju, ale nie na odwrót, można po prostu zatrzymać się w świecie typów:

template <template<class...> class T, class ... Types> 
class C {  
    T<Types...> storage; 
}; 

A potem to tylko kwestia dokonywania std::array pracy z zaledwie typów:

template <class T, class N> 
using my_array = std::array<T, N::value>; 

template <size_t N> 
using size_ = std::integral_constant<size_t, N>; 

Więc oryginalny przykład postać:

C<my_array, int, size_<3>> c;