स्टैक में गतिशील सरणी?

Question

क्या यह सही है? यह g ++ (3.4) के साथ संकलित है।

 
int main() 
{ 
    int x = 12; 
    char pz[x]; 
} 

Answer 1

तकनीकी रूप से, यह सी ++ का हिस्सा नहीं है। आप सी 99 (आईएसओ/आईईसी 98 99: 1 999) में परिवर्तनीय लंबाई सरणी कर सकते हैं लेकिन वे सी ++ का हिस्सा नहीं हैं। जैसा कि आपने पाया है, वे कुछ कंपाइलर्स द्वारा विस्तार के रूप में समर्थित हैं।

Answer 2

जी ++ एक सी 99 सुविधा का समर्थन करता है जो गतिशील रूप से आकार के सरणी की अनुमति देता है। यह मानक सी ++ नहीं है। जी ++ में -ansi विकल्प है जो कुछ विशेषताओं को बंद करता है जो सी ++ में नहीं हैं, लेकिन यह उनमें से एक नहीं है। ++ कि कोड अस्वीकार जी बनाने के लिए, -pedantic विकल्प का उपयोग:

 
$ g++ -pedantic junk.cpp 
junk.cpp: In function ‘int main()’: 
junk.cpp:4: error: ISO C++ forbids variable-size array ‘pz’ 

Answer 3

आप ढेर पर एक गतिशील सरणी चाहते हैं:

void dynArray(int x) 
{ 
    int *array = (int *)alloca(sizeof(*array)*x); 

    // blah blah blah.. 
} 

Answer 4

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

 
#include <iostream> 
#include <cstdlib> 
#include <vector> 

int main(int argc, char* argv[]) 
{ 
    int size; 
    std::cin>>size; 
    std::vector<int> array(size); 
    // do stuff with array ... 
    return 0; 
} 

आप सिंटैक्स के बारे में बहुत जिज्ञासु होते हैं, तो क्या आप के लिए देख रहे हैं:

 
//... 
int* array = new int[size]; 
// Do stuff with array ... 
delete [] array; 
//... 

इनमें से कोई भी स्थानीय संग्रहण के साथ आवंटित नहीं है। स्थानीय स्टोरेज का उपयोग करके स्वचालित रूप से आवंटित एक गतिशील आकार का सरणी वर्तमान में मानक C++ में समर्थित नहीं है, लेकिन वर्तमान सी मानक में समर्थित है।

आपका कोड अभी मानक सी नहीं है ++:

Answer 5

यहाँ इन सभी अन्य लोगों के अपने संयोजन जवाब है। यह मानक सी 99 है। ऐसा इसलिए है क्योंकि सी 99 आपको उस तरह से गतिशील रूप से सरणी घोषित करने की अनुमति देता है। स्पष्ट करने के लिए, यह भी मानक C99 है:

#include <stdio.h> 

int main() 
{ 
    int x = 0; 

    scanf("%d", &x); 

    char pz[x]; 
} 

यह वह जगह है नहीं मानक कुछ भी:

#include <iostream> 

int main() 
{ 
    int x = 0; 
    std::cin >> x; 
    char pz[x]; 
} 

यह मानक सी ++ नहीं किया जा सकता क्योंकि यह है कि आवश्यक निरंतर सरणी आकार, और इसकी वजह मानक सी नहीं किया जा सकता सी std::cin (या नामस्थान, या वर्गों, आदि ...) नहीं है

यह मानक सी ++ बनाने के

, ऐसा करते हैं:

int main() 
{ 
    const int x = 12; // x is 12 now and forever... 
    char pz[x]; // ...therefore it can be used here 
} 

आप एक गतिशील सरणी चाहते हैं, आप ऐसा कर सकते हैं:

#include <iostream> 

int main() 
{ 
    int x = 0; 
    std::cin >> x; 

    char *pz = new char[x]; 

    delete [] pz; 
} 

लेकिन आप ऐसा करते हैं चाहिए:

#include <iostream> 
#include <vector> 

int main() 
{ 
    int x = 0; 
    std::cin >> x; 

    std::vector<char> pz(x); 
} 

Answer 6

स्टैक पर चर लंबाई के साथ सरणियों का आवंटन एक अच्छा है विचार, क्योंकि यह तेज़ है और स्मृति को खंडित नहीं करता है। लेकिन दुर्भाग्य से सी ++ मानक इसका समर्थन नहीं करता है। आप टेम्पलेट रैपर का उपयोग करके alloca फ़ंक्शन पर ऐसा कर सकते हैं। लेकिन alloca का उपयोग वास्तव में एक मानक अनुरूप नहीं है।

स्टैंडर्ड तरह से अगर आप स्मृति विखंडन से बचने और स्मृति आवंटन speedup करने के लिए चाहते हैं कस्टम संभाजक साथ std :: वेक्टर उपयोग करने के लिए है। फास्ट आवंटक के अच्छे नमूने के लिए boost::pool_alloc पर एक नज़र डालें।