Trộn các kiểu và các kiểu nontypes trong các tham số mẫu của Denisdic?

Question

Có thể trộn các kiểu và các kiểu nontypes trong các tham số mẫu của Denisdic không? Nếu tôi đã vượt qua một ví dụ std::array cho lớp này như tham số T, tôi cũng sẽ cần phải vượt qua một loại cho mảng và độ dài, nhưng cách tôi đã thử nó dưới đây gây ra lỗi khi gặp phải một giá trị, vì nó chỉ mong đợi loại cho Types:

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

    T<Types...> storage; 
}; 

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

thông báo lỗi:

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

có cách nào để vượt qua các loại và giá trị trong một bối cảnh variadic?

Answer 1

Như tôi thấy, bạn đã đọc mã hóa số lượng và loại thông số mà lớp T phải lấy làm tham số mẫu. Bạn không cần các mẫu variadic tại đây. Chỉ cần làm điều này thay vì:

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! 
} 

Nếu bạn muốn sử dụng các mẫu variadic, sau đó đặt nó trong các mẫu tham số mẫu quá:

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

    T<Types...> storage; 
}; 

Nếu bạn muốn sử dụng phiên bản đó nhưng vẫn muốn sử dụng std::array , bạn có thể tạo một bí danh để std::array rằng đã có một kích thước:

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

C<array3, int> c; 

Ngoài ra, bạn cũng có thể tạo một số loại mẫu template alias cho phép y ou chọn kích thước:

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

Có thể làm pha trộn của các loại và nontypes trong các thông số mẫu variadic?

Không. Bạn không thể trộn và kết hợp. Nhưng kể từ khi bạn có thể quấn một giá trị trong một kiểu nhưng không phải là cách khác xung quanh, bạn chỉ có thể ở trong thế giới của các loại:

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

Và sau đó nó chỉ là một vấn đề làm cho std::array làm việc chỉ với các loại:

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>; 

Vì vậy, ví dụ ban đầu của bạn trở thành:

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