गतिशील आकार के साथ सरणी कैसे बनाएं? गतिशील सरणी का सामान्य उपयोग (शायद पॉइंटर्स भी)?

Question

मैं एक प्रोग्राम है जो

1. उपयोगकर्ता इनपुट ले जाता है बनाने के लिए कोशिश कर रहा हूँ
2. एक प्रारंभिक आकार के बिना एक सरणी में स्टोर यह (मान लें कि यह के सभी int है चलो) (अर्थात नहीं ->array[5];); और फिर
3. जो भी भयावह उद्देश्यों के लिए सरणी में संग्रहीत जानकारी का उपयोग करें।

मैं मदद मांग रहा हूं ताकि मैं सीख सकूं कि यदि आवश्यक हो तो मैं इसे कैसे कर सकता हूं।

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

पढ़ना सिर्फ मेरे लिए पर्याप्त समझा नहीं गया।

मुझे पता है कि यह एक बहुत ही नोबिश सवाल है, और हाँ, मैं एक नोब हूं, लेकिन इसे बदलने के लिए मुझे कुछ मदद चाहिए।

तुम सिर्फ एक कंटेनर की जरूरत है सिर्फ std:vector का उपयोग करें:

Answer 1

सी ++ लिए

। यह आपके लिए आवश्यक सभी स्मृति आवंटन का ख्याल रखेगा। हालांकि यदि आप अपना खुद का गतिशील कंटेनर विकसित करना चाहते हैं (आपके पास जो भी कारण हैं) तो आपको स्मृति आवंटन का ख्याल रखना होगा। यही है, जब आपकी सरणी बढ़ती है तो आपको नई मेमोरी खंड आवंटित करनी होगी, मौजूदा सरणी मानों को नए मेमोरी लोकेशन में कॉपी करें और नई आवंटित मेमोरी में नए मान जोड़ें। आमतौर पर एक अलग वर्ग के अंदर इस तरह के तर्क को लपेटता है उदा। GrowingArray (मानक की तरह प्रदान की vector वर्ग)

संपादित

मेरा उत्तर के बारे में अधिक विस्तार से बता दें (यह देखते हुए कि आप उद्देश्य सीखने के लिए इस का उपयोग कर रहे): एक के बिना एक सरणी में

दुकान यह प्रारंभिक आकार (यानी नहीं -> सरणी [5];)

यहां आप इस तरह कुछ उपयोग करना चाहते हैं: int * myDynamicArray; जब कोई उपयोगकर्ता कुछ मान इनपुट करता है तो आप मेमोरी चंक आवंटित करते हैं जहां उन मानों को संग्रहीत किया जा रहा है: myDynamicArray = new int[5]; आपके प्रारंभिक इनपुट के आकार के साथ। मैं कुछ चर में सरणी के आकार को सहेजने की भी सिफारिश करता हूं: int arraySize = 5; यदि बाद में आप अपने myDynamicArray पर नए मान जोड़ना चाहते हैं तो सबसे पहले आपको उगाए गए सरणी के लिए नई मेमोरी खंड आवंटित करना होगा (वर्तमान सरणी तत्व + नई सरणी तत्व)। मान लें कि आपके पास 10 नए मूल्य आ रहे हैं। फिर आप करेंगे: int* grownArray = new int[arraySize+10]; यह उगाए गए सरणी के लिए नई मेमोरी खंड आवंटित करता है। फिर आप पुराने मेमोरी खंड से आइटम्स को नए मेमोरी खंड में कॉपी करना चाहते हैं और उपयोगकर्ता द्वारा जोड़े गए मान जोड़ सकते हैं (मैं इसे लेता हूं, आप इसे सीखने के उद्देश्यों के लिए उपयोग कर रहे हैं इस प्रकार मैंने आपको हाथी की प्रतिलिपि बनाने के लिए चक्र के लिए सरल प्रदान किया है। आप std:copy या सी memcopy जैसे उपयोग कर सकते हैं साथ ही):

int i = 0; 
for (; i < arraySize; ++i) 
    { 
    grownArray[i] = myDynamicArray [i]; 
    } 
// enlarge newly allocated array: 
arraySize+= 10; 
for (; i < arraySize; ++i) 
    { 
    grownArray[i] = newValues from somewhere 
    } 
// release old memory 
delete[] myDynamicArray; 
// reassign myDynamicArray pointer to point to expanded array 
myDynamicArray = gronwArray; 

Answer 2

यहां कुछ कोड है जो मैंने सी ++ में लिखा है जो मूल बातें करता है।

#include <iostream> 

int main(int argc, char *argv[]) 
{ 
    int* my_dynamic_array; 

    int size; 
    std::cin >> size; 

    my_dynamic_array = new int[size]; 

    for (int k=0; k<size; k++) 
     my_dynamic_array[k] = k; 

    for (int k=0; k<size; k++) 
     std::cout << my_dynamic_array[k] << std::endl; 

    delete[] my_dynamic_array; 

    return 0; 
} 

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

तो सबसे पहले हमने सरणी घोषणा के बजाए एक पॉइंटर के साथ हमारी गतिशील सरणी घोषित की, उदाहरण के लिए हमने के बजाय int *my_dynamic_array का उपयोग किया। सबसे पहले यह बहुत छोटा लगता है, लेकिन ऐसा कुछ है जिसे आपको समझने की आवश्यकता है कि सी और सी ++ में क्या हो रहा है।

जब आप स्थाई रूप से एक सरणी घोषित करते हैं, तो आप प्रोग्राम को बता रहे हैं कि आप उस स्मृति को आपके लिए उपयोग करना चाहते हैं। यह वास्तव में है; आप का उपयोग शुरू करने के लिए यह तुम्हारा है। जब आप गतिशील रूप से एक सरणी बनाते हैं, तो आप एक पॉइंटर से शुरू करते हैं। पॉइंटर्स सिर्फ कुछ स्मृति का संदर्भ हैं। वह स्मृति अभी तक आवंटित नहीं है। यदि आप इसमें कुछ पहुंचने का प्रयास करते हैं, तो कहें, my_dynamic_array[3], आपको एक ग़लत त्रुटि मिल जाएगी। ऐसा इसलिए है क्योंकि वास्तव में उस स्थान पर स्मृति में कुछ भी नहीं है (प्रोग्राम को उपयोग करने के लिए कम से कम कुछ भी नहीं दिया गया है)।

delete के बजाय delete[] का उपयोग भी ध्यान दें। जब आप सरणी के साथ काम करते हैं तो आप स्मृति को मुक्त करते हैं।

आप सी में इस कार्य कर रहे हैं, तो आप इस एक ही तरह से, लेकिन इसके बजाय new की और delete[] आप malloc और free है काफी सोच सकते हैं।

गतिशील सरणी और पॉइंटर्स के बीच सूक्ष्म मतभेदों को जानना मुश्किल है। इससे पहले कि मैं पूरी तरह से समझ रहा था कि मुझे क्या चल रहा था, मुझे थोड़ी देर लग गई। शुभकामनाएं और इसे रखें।

Answer 3

यह शायद सबसे चतुर तरीका (गुप्त अत्यधिक एसटीएल कुछ के लिए उपयोग) है ...

std::vector<int> vec; 

// read integers 1 at a time from the user, 
// will stop when non-integer input is entered 
std::copy(std::istream_iterator<int>(std::cin), 
      std::istream_iterator<int>(), 
      std::back_inserter(vec)); 

// print out the vector 
std::copy(vec.begin(), vec.end(), std::ostream_iterator<int>(std::cout, " ")); 

Answer 4

सी में आप इस विधि का उपयोग कर सकते हैं।

int i=0; 
int *p; 
char c; 
int size; 
printf("Enter size :"); 
scanf("%d",&size); 
int *p=malloc(sizeof(int)*size); 
do 
{ 
printf("Enter Number : "); 
scanf("%d",&p[i]); 
i++; 
printf("Press 'q' or 'Q' to quit or any other key to continue : "); 
scanf("%c",&c); 
} 
while(c!='q' && c!='Q' && i<=size); 
p=realloc(p,i*sizeof(int)); 

आप स्मृति आवंटित के बाकी अगर पूर्णांकों आप चाहते हैं की संख्या स्मृति आवंटित की तुलना में कम है मुक्त कर सकते हैं इस तरह।

Answer 5

मैं आपके लिए एक सुझाव देता हूं। आप लिंक किए गए सूची के बजाय सरणी का उपयोग कर सकते है अगर आप एक उदाहरण के बाद सी

यहाँ

साथ todevelop जा रहे हैं:

typedef struct linked_list { 
    int x, 
    struct linked_list *next 
} linked_list; 

struct linked_list *head = NULL; 

void add_element(int x) 
{ 
    struct linked_list *elem; 
    elem = malloc(sizeof(struct linked_list)); 
    elem->x =x; 
    elem->next = head; 
    head = elem; 
} 

int main() 
{ 
    int x; 
    struct linked_list *p; 
    do 
    { 
     printf("Enter Number : "); 
     scanf("%d",&x); 
     add_element(x) 
     printf("Press 'q' or 'Q' to quit or any other key to continue : "); 
     scanf("%c",&c); 
    }while(c!='q' && c!='Q'); 

    for (p=head;p!=NULL;p=p->next) 
    { 
     printf(%d\r\n",p->x); 
    } 

}