मैं एक संपूर्ण सरणी को कैसे मुक्त करूं, जिसके तत्वों को व्यक्तिगत रूप से मैलोकोक / कॉलोक [डुप्लिकेट] के माध्यम से मेमोरी आवंटित की गई है

Question

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

संक्षेप में, मेरे पास निम्नलिखित कोड हैं:

int *num,* num_start;

num_start=num;

for(i=0;i<N;i++)
{
    num = (int *)calloc(0, sizeof(int));
    num++;
}

free(num_start);

free(num_start)एन पूर्णांक तत्वों के पूरे सरणी को मुक्त करेगा जो गतिशील रूप से अंतरिक्ष आवंटित किया गया है, स्वतंत्र रूप से?

Answer 1

आपके द्वारा पोस्ट किया गया "कोड" कोई मतलब नहीं है और गलत है।

int *num, num_start;
num_start=num;

num_start एक पूर्णांक है जो सूचक नहीं है।

for(i=0;i<N;i++)
{
    num = (int *)calloc(0, sizeof(int));
    num++;
}

सच कहूँ तो मुझे समझ नहीं आ रहा है कि यह कोड क्या करना चाहिए, लेकिन निश्चित रूप से गलत है

यदि आप Nपूर्णांकों के लिए मेमोरी आवंटित करना चाहते हैं

int *num = calloc(N, sizeof(*num));

और आप केवल जरूरत मुक्त करने के लिए

free(num);

या यदि आप एन पॉइंटर्स को एन पूर्णांक में स्टोर करने के लिए पॉइंटर आवंटित करना चाहते हैं

int **allocate(size_t N)
{
    int **num = malloc(N * sizeof(*num));
    for(size_t i=0; i<N; i++)
    {
        num[i] = calloc(N, sizeof(**num));
    }
    return num;
}

void arrayfree(int **num, size_t size)
{
    for(size_t i = 0; i < size; i++)
    {
        free(num[i]);
    }
    free(num);
}

जब आप स्मृति आवंटित करते हैं तो आपको जांचना पड़ता है कि क्या ऑपरेशन सफल था। उन चेकों को कोड को पढ़ने में आसान बनाने के लिए उदाहरण में शामिल नहीं किया गया है।

Answer 2

calloc()और malloc()कार्यों आवंटन जो एक संभाल कि स्मृति को रिहा करने के रूप में दोगुना हो जाता है करने के लिए एक सूचक लौट आते हैं। जब आप उस पॉइंटर की प्रतियां बनाने के लिए स्वतंत्र होते हैं और जब आप फिट होते हैं, तो उन्हें हेरफेर करते हैं, जब आप कॉल free()करते हैं तो आपको मूल मूल्य प्रदान करना होगा ।

यह कहना है कि यह काम करता है:

// Original allocation
int* x = calloc(42, sizeof(int));

// Making a new (independent) copy of the pointer to a new pointer
int* p = x;

// Arbitrary pointer manipulation and mangling
x++;

// Freeing with the copied value
free(p);

आप भी थोड़ा साहसी हो सकते हैं, जब तक आप अपने मूल गंतव्य पर लौटते हैं:

int* x = calloc(42, sizeof(int));

x += 40;
x -= 30;
x += 10;
x -= 13;
x -= 7;

free(x);

जहां xएक छोटी यात्रा के बाद यहां अपने मूल मूल्य पर लौट आए हैं। सामान्य व्यवहार में मूल पॉइंटर को संरक्षित करना बेहतर होता है, ताकि बाद में इसका पुनर्निर्माण किया जा सके। यदि आप उन्हें हेरफेर करने का इरादा कर रहे हैं तो प्रतियां बनाएं।