2012-06-13 23 views
11

मैं एक 2-डी मैट्रिक्स बनाया ऐसा डबल सूचक का उपयोग कर:मुक्त एक डबल सूचक

int** pt; pt = (int*) malloc(sizeof(int)*10); 

मुझे पता है कि एक सूचक है कि

free(ptr); 

तरह मुक्त हो जाता है हम कैसे डबल सूचक मुक्त कर सकते हैं ?

क्या होगा यदि हम कुछ प्रिंट करते हैं और बाद में उस स्मृति को मुक्त करते हैं और प्रोग्राम से बाहर निकलते हैं? क्या अंतिम मेमोरी उसमें शामिल है जिसे हमने उपयोग किया था या यह प्रारंभिक के समान होगा?

for (int i=0; i<10; ++i) { 
    free(mat[i]); 
} 

तो शीर्ष स्तर के सूचक मुक्त:

+3

यह इस बात पर निर्भर करता है कि आपने 'malloc' कैसे कहा जाता है। कोड कहां है? –

+1

हमें कोड दिखाने की आवश्यकता है। –

+0

@bledi तो आपको इन पॉइंटर्स के माध्यम से फिर से शुरू करने की आवश्यकता है, और पहले बिंदु डेटा मुक्त करें। फिर पॉइंटर्स खुद को मुक्त करें। अतीला के जवाब को देखो। प्रासंगिक malloc कोड डालने पर –

उत्तर

27

आप एक मैट्रिक्स आप मैट्रिक्स की प्रत्येक पंक्ति मुक्त कर सकते हैं mat

int** mat = malloc(10 * sizeof(int*)); 
for (int i=0; i<10; ++i) { 
    mat[i] = malloc(10 * sizeof(int)); 
} 

तो (यह मानते हुए कि आप प्रत्येक सही ढंग से पहले से प्रारंभ किया है) है कहो :

free(mat); 

आपके दूसरे प्रश्न के लिए: यदि आप स्मृति आवंटित करते हैं और इसका उपयोग करें, आप उस मेमोरी को बदल देंगे, जो इसे मुक्त करने के बावजूद "वापस नहीं किया जाएगा" (हालांकि आप इसे किसी भी अधिक विश्वसनीय/पोर्टेबल तक नहीं पहुंच पाएंगे)।

नोट: शीर्ष-स्तरीय malloc sizeof(int*) उपयोग कर रहा है के रूप में आप सूचक-हैं- आवंटन कर रहे हैं int रों, नहीं int रों - int* के आकार और int एक ही होने की गारंटी नहीं कर रहे हैं।

+0

उत्तर के लिए धन्यवाद। – bledi

+0

इस पुष्टि के लिए धन्यवाद जीवन बचतकर्ता, – Diljeet

2

अपने मैट्रिक्स "प्रचंड" नहीं है, तो यानी सभी पंक्तियों में एक ही लंबाई है, तो आप पर विचार करना चाहते हो सकता है:

  1. इसे मैन्युअल रूप से एक्सेस करना, यानी सिर्फ मूल्यों की एक -1 डी सरणी के रूप में यह इलाज है, और एक अलग width मान रखें। किसी तत्व को एक्सेस करने के लिए (x, y) mat[y * width + x] का उपयोग करें।
  2. तुम सच में mat[y][x] की सुविधा चाहते हैं, आप इसे malloc() कि दोनों सूचक सरणी और सभी पंक्तियों आवंटित करने के लिए एक कॉल कर रही है, तो संकेत आरंभ प्रत्येक पंक्ति में बात करने के लिए से सुधार कर सकते हैं। इसका लाभ यह है कि यह सब मुक्त हो सकता है: एक free(mat); कॉल के साथ संपादित करें।

दूसरा दृष्टिकोण कुछ इस तरह दिखेगा:

double ** matrix_new(size_t width, size_t height) 
{ 
    double **p = malloc(height * sizeof *p + width * height); 
    double *e1 = (double *) (p + height); 
    size_t i; 

    for(i = 0; i < height; ++i) 
    p[i] = e1 + i * width; 
    return p; 
} 

ध्यान दें: ऊपर अन-परीक्षण किया है, और उत्पादन कोड जाहिर p उपयोग करने से पहले विफलता के लिए जाँच करनी चाहिए।

+2

यदि आप केवल शीर्ष स्तर के सूचक को मुक्त करते हैं, तो आंतरिक स्तर की ओर इशारा करते हुए बफर संदर्भित नहीं होते हैं, क्या वे कुछ कचरा कलेक्टर द्वारा डिफ़ॉल्ट रूप से मुक्त होते हैं ???? या उन्हें स्पष्ट रूप से मुक्त किया जाना चाहिए ??? –

संबंधित मुद्दे