noncopyable ऑब्जेक्ट्स के "सरणी" का निर्माण

Question

मेरे पास एक ऐसी कक्षा है जो अनजाने में गैर-प्रतिलिपि योग्य है (एक थ्रेड, इसलिए कोई प्रतिलिपि नहीं है जो समझ में आता है), और मैं इनमें से एक बड़ा 'सरणी' बनाना चाहता हूं, जैसा कि समान रूप से बनाया गया है गैर-डिफ़ॉल्ट कन्स्ट्रक्टर। ध्यान दें कि सरणी निश्चित आकार है।

मैं केवल सी ++ सरणी के साथ डिफ़ॉल्ट कन्स्ट्रक्टर का उपयोग कर सकता हूं, जब तक कि मैं प्रत्येक को स्वतंत्र रूप से प्रारंभ नहीं करता।

Thread myArray[128]; // uses default constructor - wrong 

मैं स्पष्ट रूप से वस्तु निर्माणकर्ता और मानकों को सूचीबद्ध कर सकते हैं, लेकिन यह अत्यधिक शब्द और बदसूरत

Thread myArray[128] = { Thread(params,...), Thread(params,...), ... x 128 ; // ugly 

ऐसा लगता है मैं STL वैक्टर का उपयोग नहीं कर सकते क्योंकि वस्तु गैर copyable है - हालांकि वेक्टर घटना आकार कभी नहीं बदलता है। मुझे लगता है कि निर्माता वास्तव में नकल करता है!

std::vector<Thread> myVector(128, Thread(params,...));// won't compile 

तरह से मैं हालांकि ऐसा करने का है स्मार्ट संकेत की एक सरणी और एक प्रारंभ पाश के साथ है, लेकिन कुछ शायद मैं याद कर रहा हूँ:

क्या कोई अन्य रास्ता नहीं है - हो सकता है बढ़ावा कंटेनर के साथ , या एक अलग कंटेनर प्रकार?

Answer 1

प्रत्येक पॉइंट गतिशील रूप से आवंटित स्मार्ट पॉइंटर्स का एक वेक्टर, निश्चित रूप से सबसे सरल तरीका है। अन्यथा (और मैं केवल तभी ऐसा कर सकता हूं जब आप पूरी तरह से आवश्यक हों), आप अनुकरण कर सकते हैं कि std::vector आंतरिक रूप से क्या करता है। की पंक्तियों के साथ कुछ:

union 
{ 
    double just_to_ensure_alignment; 
    unsigned char data[ sizeof(Thread) * elementCount ]; 
} array; 

// construct... 
for (int i = 0; i != elementCount; ++ i) 
    new (data + i * sizeof(Thread)) Thread(params,...); 

// access... 
Thread& getAt(int i) 
{ 
    return reinterpret_cast<Thread*>(data + i * sizeof(Thread)); 
} 

समर्थन आर-मूल्य (मैं वास्तव में इस एक कक्षा में लपेट चाहते हैं, यदि केवल getAt के बजाय operator[] उपयोग करने के लिए सक्षम होने के लिए।)

Answer 2

यह पूरी तरह पागल की तरह लग सकता है (और यह शायद है), लेकिन ...

struct ThreadInitValues{ 
    // your actual params 
    int i; 
    float f; 
}; 

struct Thread{ 
    Thread(int i = _init.i, float f = _init.f) 
     : _i(i) 
     , _f(f) 
    {} 

    static ThreadInitValues _init; 

private: 
    // uncopyable 
    Thread(Thread const&); 
    Thread& operator=(Thread const& other); 

    // your actual member 
    int _i; 
    float _f; 
}; 

ThreadInitValues Thread::_init; 

int main(){ 
    Thread::_init.i = 5; 
    Thread::_init.f = 3.14f; 
    Thread arr[128]; 
} 

हो सकता है कि यह आपके लिए बाहर काम करता है। :) बेशक, अब आपको यह देखने की ज़रूरत है कि सरणी को मल्टीथ्रेड कोड में ही शुरू किया गया है ...

Answer 3

नई compilers के लिए संदर्भ, प्रतिलिपि होने के नाते वेक्टर तत्व AFAIK के लिए आवश्यक नहीं है। 128 push_back की प्रतिलिपि किए बिना इसका उपयोग करने के लिए उपयोग किया जाना चाहिए (प्रत्येक बार नई वस्तु बनाना), क्योंकि एक ही से कई ऑब्जेक्ट्स को क्रिएट करना एक प्रतिलिपि है :)।

यदि यह तरीका उपलब्ध नहीं है, तो boost::ptr_vector या std :: vector of boost :: shared_ptr आज़माएं।

Answer 4

मैं इतना बड़ा प्रोग्रामर नहीं हूं। लेकिन क्या आपने यह

std::vector<YourObject *> temp_Vec; 
for(int i=0;i<128;++i) 
    temp_Vec.push_back(new YourObject(arguments));