क्या एक अभिन्न टेम्पलेट पैरामीटर के आधार पर सदस्य सरणी के तत्वों का निर्माण करना संभव है?

Question

मान लें:

template<class T,int N> 
struct A { 
    A(): /* here */ {} 

    T F[N]; 
}; 

मैं {0,1,2,...,N-1} साथ निर्माण करने F[] के तत्वों की जरूरत है। यदि संभव हो तो मैं पिछले स्तर को template<class T> struct A<T,0> के रूप में परिभाषित करने और कुछ जटिल टेम्पलेट चाल के रूप में परिभाषित करने के साथ पुनरावर्ती परिभाषित टेम्पलेट structs से बचना चाहता हूं। क्या C++ 11 प्रारंभकर्ता सूचियां मदद कर सकती हैं?

यह समान Template array initialization with a list of values है, लेकिन यह बढ़ते मूल्य वाले तत्वों का निर्माण नहीं करता है। यह इसे बाद में रन-टाइम लूप में सेट करता है।

Answer 1

indices समाधान किसी तरह मान लिया जाये कि उपलब्ध है:

A(): A(make_indices<N>()) {} 

// really a private constructor 
template<int... Indices> 
explicit A(indices<Indices...>) 
    // Can be an arbitrary expression or computation, too, like 
    // (Indices + 3)... 
    : F {{ Indices... }} 
{} 

अपने संकलक सौंपने कंस्ट्रक्टर्स का समर्थन नहीं करता है, तो एक ही विकल्प std::array<T, N> करने के लिए स्विच और एक निजी स्थिर सहायक है कि एक initialized सरणी देता है उपयोग करने के लिए है, कि डिफ़ॉल्ट कन्स्ट्रक्टर बन जाएगा:

A(): F(helper(make_indices<N>())) {} 

यह निश्चित रूप से एक अतिरिक्त (चाल) निर्माण करेगा।

Answer 2

आप एक variadic मूल्य टेम्पलेट और निर्माता प्रतिनिधिमंडल के साथ ऐसा कर सकते हैं:

template<int... I> struct index { 
    template<int n> using append = index<I..., n>; }; 
template<int N> struct make_index { typedef typename 
    make_index<N - 1>::type::template append<N - 1> type; }; 
template<> struct make_index<0> { typedef index<> type; }; 
template<int N> using indexer = typename make_index<N>::type; 

template<class T, int N> 
struct A { 
    template<T...I> A(index<I...>): F{I...} {} 

    A(): A(indexer<N>{}) {} 

    T F[N]; 
}; 

यह Calling a function for each variadic template argument and an array