सी ++ सरणी निर्माता

Question

मैं बस सोच रहा था, कि क्या एक वर्ग की एक सरणी सदस्य वर्ग निर्माण के तुरंत बाद ही बनाया जा सकता है:

class C 
{ 
     public: 
      C(int a) : i(a) {} 

     private: 
      int i; 
}; 

class D 
{ 
public: 
     D() : a(5, 8) {} 
     D(int m, int n) : a(m,n) {} 

    private: 
    C a[2]; 

}; 

जहां तक ​​मेरा googled है, इस तरह के ऊपर के रूप में निर्माता के भीतर सरणी निर्माण सी में है ++ असंभव। वैकल्पिक रूप से, सरणी सदस्य को निम्नानुसार कन्स्ट्रक्टर ब्लॉक के भीतर प्रारंभ किया जा सकता है।

class D 
    { 
    public: 
     D() { 
       a[0] = 5; 
       a[1] = 8; 
      } 
     D(int m, int n) { 
          a[0] = m; 
          a[1] = n; 
         } 
     private: 
     C a[2]; 

    }; 

लेकिन फिर, यह अब एक सरणी निर्माण नहीं है, लेकिन सरणी असाइनमेंट है। सरणी elemnts स्वचालित रूप से संकलक द्वारा उनके डिफ़ॉल्ट कन्स्ट्रक्टर के माध्यम से बनाए जाते हैं और बाद में उन्हें मैन्युअल रूप से C'tor ब्लॉक के भीतर विशिष्ट मानों को असाइन किया जाता है। कष्टप्रद क्या है; इस तरह के कामकाज के लिए, कक्षा सी को एक डिफ़ॉल्ट निर्माता प्रदान करना है।

क्या कोई भी ऐसा विचार है जो निर्माण पर सरणी सदस्यों को बनाने में मेरी मदद कर सकता है। मुझे पता है कि std :: वेक्टर का उपयोग एक समाधान हो सकता है लेकिन, परियोजना स्थितियों के कारण मुझे किसी मानक, बूस्ट या तृतीय पक्ष लाइब्रेरी का उपयोग करने की अनुमति नहीं है।

Answer 1

Arrays - सी ++ से पुरानी अवधारणा, सीधे सी से विरासत में मिली - वास्तव में उपयोग करने योग्य रचनाकार नहीं हैं, क्योंकि आप मूल रूप से ध्यान दे रहे हैं। आपके द्वारा उल्लेख की जाने वाली अजीब बाधाओं के बारे में कुछ कार्यवाही बाकी हैं (कोई मानक लाइब्रेरी नहीं?!?!?) - आप aपॉइंटर सी के बजाय सी के लिए सी हो सकते हैं, कच्ची मेमोरी आवंटित कर सकते हैं इसके लिए, फिर प्रत्येक सदस्य को "प्लेसमेंट न्यू" के साथ प्रारंभ करें (जो सी के मुद्दे के आसपास काम करता है, कम से कम डिफॉल्ट कन्स्ट्रक्टर नहीं है)।

Answer 2

आप एक सरणी लपेटने और अपनी पसंद के अनुसार निर्माण करने के लिए एक कक्षा बना सकते हैं। यहां एक शुरुआत है; यह कोड आप जो देखते हैं उससे अलग नहीं है।

#include <iostream> 
using namespace std; 

template< class T, int N > 
struct constructed_array { 
     char storage[ sizeof(T[N]) ]; // careful about alignment 
     template< class I > 
     constructed_array(I first) { 
       for (int i = 0; i < N; ++ i, ++ first) { 
         new(&get()[i]) T(*first); 
       } 
     } 
     T *get() const { return reinterpret_cast< T const* >(storage); } 
     T *get() { return reinterpret_cast< T * >(storage); } 
     operator T *() const { return get(); } 
     operator T *() { return get(); } 
}; 

char const *message[] = { "hello", ", ", "world!" }; 

int main(int argc, char ** argv) { 
     constructed_array< string, 3 > a(message); 
     for (int i = 0; i < 3; ++ i) { 
       cerr << a[i]; 
     } 
     cerr << endl; 
     return 0; 
}