गतिशील सरणी

Question

का डिफ़ॉल्ट मान सेट करें यह कोड 100 तत्वों की एक सरणी बनाएगा और प्रत्येक के मान को गलत पर सेट करेगा।

bool boolArray[100] = false; 

मैं गतिशील सरणी का डिफ़ॉल्ट मान कैसे सेट कर सकता हूं?

void Foo(int size) 
{ 
    bool boolArray = new bool[size]; 
    //Now what? 
} 

Answer 1

मानक सी ++ आप कर सकते हैं डिफ़ॉल्ट आरंभ कर देगा सिर्फ कुछ के बारे में, कि सरणी सहित में:

bool* boolArray = new bool[size]();  // Zero-initialized 

पूरा प्रोग्राम है जो भी परिणाम की जाँच करता है, और सरणी deallocates:

bool foo(int size) 
{ 
    bool* boolArray = new bool[size]();  // Zero-initialized 

    // Check that it is indeed zero-initialized: 
    for(int i = 0; i < size; ++i) 
    { 
     if(boolArray[i]) { delete[] boolArray; return false; } 
    } 
    delete[] boolArray; return true; 
} 

#include <iostream> 
int main() 
{ 
    using namespace std; 
    cout << (foo(42)? "OK" : "Ungood compiler") << endl; 
} 

क्या आपके कंपाइलर स्वीकार करेगा या सही चीज भी करेगा एक और मामला है।

तो, व्यवहार में, अगर आप एक कच्चे सरणी का उपयोग करने के लिए एक अनूठा आग्रह करता हूं महसूस करते हैं, तो शायद बेहतर std::fill या कुछ इस तरह, या यहाँ तक कि एक कच्चे पाश का उपयोग करें।

लेकिन दोहराए गए delete[] -expressions नोट करें। इस तरह के अनावश्यक कोड गलत होने के लिए बहुत आसान है: यह बुराई ™ है। और कच्चे सरणी के उपयोग के साथ गलत हो सकता है, इसलिए नौसिखिया के रूप में, कच्चे सरणी और कच्चे पॉइंटर्स और ऐसे में केवलकहें।

इसके बजाय, मानक लाइब्रेरी कंटेनर का उपयोग करें, जो आपके लिए – सही ढंग से आवंटन, प्रारंभिकरण, प्रतिलिपि बनाने और हटाने का प्रबंधन करते हैं। इसके साथ एक छोटी सी समस्या है, हालांकि, std::vector<bool> में समयपूर्व अनुकूलन, जो अन्यथा प्राकृतिक विकल्प होगा। अनिवार्य रूप से std::vector<bool> प्रति मान केवल एक बिट का उपयोग करता है, ताकि यह bool तत्वों के संदर्भों को पूरा न कर सके, बल्कि इसके बजाय प्रॉक्सी ऑब्जेक्ट्स और नरक को हाथ से निकाल दें;

तो, bool तत्वों के लिए, उदाहरण के लिए उपयोग करें एक std::bitset (जब आकार संकलन समय पर जाना जाता है), या उदा। एक std::deque, के रूप में इस प्रकार है:।

#include <deque> 

bool foo(int size) 
{ 
    std::deque<bool> boolArray(size);  // Zero-initialized 

    for(int i = 0; i < size; ++i) 
    { 
     if(boolArray[i]) { return false; } 
    } 
    return true; 
} 

#include <iostream> 
int main() 
{ 
    using namespace std; 
    cout << (foo(42)? "OK" : "Ungood compiler") << endl; 
} 

चीयर्स & hth,

Answer 2

bool* boolArray = new bool[size]; 
for(int i = 0; i < size; i++) { 
    boolArray[i] = false; 
} 

Answer 3

उपयोग std::fill function या std::fill_n function।

std::fill_n(boolArray, length, defaultValue); 
std::fill(boolArray, boolArray + length, defaultValue); 

साइड नोट: बजाय std::vector उपयोग करके देखें।

Answer 4

के बारे में क्या:

void Foo(int size) 
{ 
    // bool boolArray = new bool[size]; 
    // Did you mean bool*? 
    // Try and avoid direct allocation of memory. 
    // Memory allocation should be done inside an object that 
    // actively manages it. 

    // Normally I would recommend a vector 
    std::vector<bool> boolArray(size, false); 

    // But. And a Big but. Is that the standards committee decided to 
    // specialize the vector for bool so that each element only takes 
    // a single bit. Unfortunately this had some side effects that were 
    // made its use not perfect (time/assign-ability). 

    // So we can try a boost array 
    boost::array<bool, size> boolArray; 
}