विविधता टेम्पलेट पैरामीटर में मिक्सिंग प्रकार और नॉनटाइप?

Question

क्या विविधता टेम्पलेट पैरामीटर में प्रकारों और नॉनटिप्स का मिश्रण करना संभव है? अगर मुझे std::array को पैरामीटर T के रूप में इस वर्ग के लिए std::array पास करना था, तो मुझे सरणी और लंबाई के लिए एक प्रकार भी पास करना होगा, लेकिन जिस तरह से मैंने इसे आजमाया है, वह मान का सामना करते समय त्रुटि का कारण बनता है, क्योंकि यह केवल अपेक्षा करता है Types के लिए प्रकार:

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

    T<Types...> storage; 
}; 

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

त्रुटि संदेश:

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

वहाँ एक variadic संदर्भ में प्रकारों और मानों के पारित करने के लिए कोई तरीका है?

Answer 1

जैसा कि मैंने देखा, आप कक्षा T पैरामीटर पैरामीटर के रूप में ले जाने के पैरामीटर के संख्या और प्रकारों को हार्डकोड किया है। आपको यहां विविध चरमपंथियों की आवश्यकता नहीं है। बस इस के बजाय कार्य करें:

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

आप variadic टेम्पलेट का उपयोग करने के लिए है, तो इच्छा टेम्पलेट टेम्पलेट पैरामीटर में भी डालते हैं तो:

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

    T<Types...> storage; 
}; 

आप उस संस्करण का उपयोग करना चाहते, लेकिन अभी भी std::array उपयोग करना चाहते हैं , आप std::array पहले से ही एक आकार की है कि करने के लिए एक उपनाम बना सकते हैं: वैकल्पिक रूप से

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

C<array3, int> c; 

, आप भी कि y जाने टेम्पलेट टेम्पलेट उर्फ ​​किसी प्रकार बना सकते हैं कहां आकार का चयन:

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

यह प्रकार और variadic टेम्पलेट मानकों में nontypes का मिश्रण करने के लिए संभव है?

नहीं। आप मिश्रण और मिलान नहीं कर सकते। लेकिन जब से तुम एक प्रकार में एक मूल्य है, लेकिन चारों ओर नहीं दूसरी तरह लपेट कर सकते हैं, तो आप सिर्फ प्रकार की दुनिया में रह सकते हैं:

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

और फिर यह सिर्फ प्रकार के साथ std::array काम करने का मामला है:

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

तो अपने मूल उदाहरण बन जाता है:

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