क्या सी में एक चर लंबाई के साथ एक सरणी बनाने का कोई तरीका है?

Question

उपयोगकर्ता द्वारा इनपुट किए जाने वाले आकार के साथ सरणी बनाने के लिए कोई तरीका है (malloc के अलावा)?

Answer 1

एक तरीका वीएलए का उपयोग करना है (सी 99 परिभाषित करता है जिसे 'परिवर्तनीय लंबाई Arrays' कहा जाता है)।

#include <stdio.h> 

int use_a_vla (int n) 
{ 
    int vla[n]; /* Array length is derived from function argument. */ 

    vla[0] = 10; 
    vla[n-1] = 10; 

    return 0; 
} 

int main (void) 
{ 
    int i; 

    scanf ("%d", &i); /* User input. */ 

    use_a_vla (i); 
} 

Answer 2

यह सब संकलक पर निर्भर करता है:

यहाँ एक उदाहरण है।

चर लंबाई स्वचालित सरणियों ISO C99 में अनुमति दी जाती है, और एक विस्तार जीसीसी उन्हें C90 मोड में और सी में स्वीकार करता है के रूप में ++। ये arrays किसी अन्य स्वचालित सरणी की तरह घोषित किए जाते हैं, लेकिन लंबाई के साथ निरंतर अभिव्यक्ति नहीं है। भंडारण के बिंदु पर आवंटित किया जाता है जब ब्रेस-स्तर बाहर निकलता है और अस्वीकार कर दिया जाता है। उदाहरण के लिए:

FILE * 
concat_fopen (char *s1, char *s2, char *mode) 
{ 
    char str[strlen (s1) + strlen (s2) + 1]; 
    strcpy (str, s1); 
    strcat (str, s2); 
    return fopen (str, mode); 
} 

अधिक जानकारी के लिए this देखें।

Answer 3

अच्छा, यह पैडेंटिक है, लेकिन आप अपना खुद का ढेर प्रबंधन कोड लिख सकते हैं और अपनी स्मृति आवंटन समारोह को malloc() के अलावा कुछ और कॉल कर सकते हैं। मुझे उम्मीद है कि यह जवाब कष्टप्रद के बजाय मनोरंजक है।

Answer 4

आप Vlas या alloca() की जरूरत नहीं है, तो यहां एक बेहद kludgy, लेकिन पोर्टेबल, ढेर आधारित तकनीक है:

int foo(int size) 
{ 
    if (size <= 64*1024) 
    { 
     unsigned char arr[64*1024]; 
     return bar(arr, size); 
    } 
    else if (size <= 1*1024*1024) 
    { 
     unsigned char arr[1*1024*1024]; 
     return bar(arr, size); 
    } 
    else if (size <= 64*1024*1024) 
    { 
     unsigned char arr[64*1024*1024]; 
     return bar(arr, size); 
    } 
    else 
     return -1;  // Assume it's too big 
} 

int bar(unsigned char arr[], int size) 
{ 
    ...your code goes here... 
} 

int maincode(int size) 
{ 
    // Invoke bar() indirectly, allocating an array 
    // on the stack of at least 'size' bytes 
    return foo(size); 
} 

मैं विशेष रूप से इस तकनीक की सलाह नहीं देते, लेकिन यह आप अलग दे देंगे ढेर के बजाय ढेर पर आवंटित स्मृति के आकार के ब्लॉक।

Answer 5

मुझे लगता है कि आप malloc से बचने की कोशिश कर रहे हैं क्योंकि आपको realloc के बारे में पता नहीं है।

अनिवार्य रूप से, आपको मोटे तौर पर सी ++ वेक्टर क्या करने की कोशिश करनी चाहिए। एक बार आपकी सरणी एक निश्चित आकार में बढ़ जाती है, realloc इसे आकार के दोगुनी हो जाती है।

realloc यदि संभव हो तो आपकी मेमोरी ब्लॉक बढ़ेगी, और यदि संभव नहीं है तो यह malloc एक नया होगा और सामग्री को कॉपी करेगा।