C Academy · पाठ

realloc से बढ़ाना

डायनेमिक Array का आकार बदलें।

पाठ 2, कुल 4 में से13 चरण

realloc से बढ़ाना, CoddyKit पर C Academy का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह C Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। C Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

जब एक malloc पर्याप्त न हो

कभी-कभी आप एक ऐरे आवंटित करके उसमें मान भरते हैं और फिर पता चलता है कि आपको अधिक जगह चाहिए। आप अंत के आगे सीधे नहीं लिख सकते।

realloc आपको मौजूदा हीप ब्लॉक का आकार बदलने देता है और उसमें पहले से मौजूद डेटा को सुरक्षित रखता है।

realloc का सिग्नेचर

realloc(ptr, new_bytes) पुराना पॉइंटर और बाइट में नया कुल आकार लेता है।

यह नए आकार वाले ब्लॉक का पॉइंटर लौटाता है। डेटा का शुरुआती भाग पुराने और नए आकार में से जो छोटा हो, उतने तक सुरक्षित रहता है।

int *bigger = realloc(a, new_n * sizeof(*a));

यह ब्लॉक को स्थानांतरित कर सकता है

realloc ब्लॉक का आकार उसी स्थान पर बढ़ा सकता है, या नया ब्लॉक आवंटित करके आपके डेटा की प्रतिलिपि बना सकता है और पुराने ब्लॉक को मुक्त कर सकता है।

दोनों ही स्थितियों में पुराना पॉइंटर अमान्य हो सकता है। अब से आपको लौटाए गए पॉइंटर का ही उपयोग करना होगा।

a = realloc(a, new_n * sizeof(*a));
/* the old value of a may no longer be valid */

स्वयं को असाइन करने का जाल

a = realloc(a, ...) लिखना साफ़-सुथरा लगता है, लेकिन यह खतरनाक है: यदि realloc NULL लौटाता है, तो आप a को अधिलेखित करके मूल पॉइंटर खो देते हैं और पुराना ब्लॉक लीक हो जाता है।

इसके बजाय एक अस्थायी चर का उपयोग करें।

int *tmp = realloc(a, new_n * sizeof(*a));
if (tmp == NULL) { /* a is still valid */ return 1; }
a = tmp;

ऐरे का आकार सुरक्षित रूप से बढ़ाना

यह प्रोग्राम 3 int आवंटित करता है, फिर realloc से आकार बढ़ाकर 6 करता है और पहले तीन मानों को सुरक्षित रखता है।

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *a = malloc(3 * sizeof(*a));
    if (!a) return 1;
    for (int i = 0; i < 3; i++) a[i] = i + 1;

    int *tmp = realloc(a, 6 * sizeof(*a));
    if (!tmp) { free(a); return 1; }
    a = tmp;

    for (int i = 3; i < 6; i++) a[i] = i + 1;
    for (int i = 0; i < 6; i++) printf("%d\n", a[i]);
    free(a);
    return 0;
}

नए बाइट आरंभीकृत नहीं होते

जब आप किसी ब्लॉक का आकार बढ़ाते हैं, तो अंत में जुड़ी अतिरिक्त जगह में ताज़ा malloc मेमोरी की तरह अनिश्चित डेटा होता है।

realloc आपके पुराने डेटा को सुरक्षित रखता है, लेकिन नए हिस्से को शून्य नहीं करता। उसे पढ़ने से पहले आरंभीकृत करें।

a = realloc(a, 6 * sizeof(*a));
for (int i = 3; i < 6; i++) a[i] = 0;  /* clear new slots */

दोगुना करने की रणनीति

हर एक तत्व के लिए realloc कॉल करना धीमा होता है। एक प्रसिद्ध तरीका यह है कि जगह समाप्त होने पर क्षमता को दोगुना कर दिया जाए।

ऐरे के बढ़ने पर इससे आकार बदलने की संख्या कम रहती है और औसत प्रदर्शन अच्छा मिलता है।

if (count == cap) {
    cap = cap ? cap * 2 : 4;
    int *tmp = realloc(a, cap * sizeof(*a));
    if (!tmp) { free(a); return 1; }
    a = tmp;
}

जोड़ते हुए ऐरे बनाना

यह प्रोग्राम खाली ऐरे से शुरू होता है और संख्याएँ जोड़ता है; आवश्यकता पड़ने पर क्षमता दोगुनी कर देता है।

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int *a = NULL;
    size_t count = 0, cap = 0;
    for (int v = 1; v <= 5; v++) {
        if (count == cap) {
            cap = cap ? cap * 2 : 2;
            int *tmp = realloc(a, cap * sizeof(*a));
            if (!tmp) { free(a); return 1; }
            a = tmp;
        }
        a[count++] = v;
    }
    for (size_t i = 0; i < count; i++) printf("%d\n", a[i]);
    free(a);
    return 0;
}

realloc(NULL, n), malloc की तरह काम करता है

यदि आप पॉइंटर के रूप में NULL देते हैं, तो realloc बिल्कुल malloc की तरह व्यवहार करता है।

इसीलिए दोगुना करने वाले लूप में a = NULL से शुरुआत करना काम करता है: पहला realloc ही शुरुआती ब्लॉक आवंटित कर देता है।

int *a = NULL;
a = realloc(a, 4 * sizeof(*a));  /* same as malloc(4 * sizeof(*a)) */

ब्लॉक का आकार घटाना

realloc किसी ब्लॉक को छोटा भी कर सकता है। नए आकार तक का डेटा सुरक्षित रहता है; बाकी हटा दिया जाता है।

आकार घटाने से मेमोरी वापस मुक्त हो सकती है, हालांकि कार्यान्वयन चाहें तो बड़े ब्लॉक को बनाए रख सकते हैं।

int *tmp = realloc(a, 2 * sizeof(*a));  /* down from more */
if (tmp) a = tmp;

गणित में अतिप्रवाह से बचें

जब क्षमता बहुत बड़ी हो जाती है, तो cap * sizeof(*a) का परिणाम size_t की सीमा से बाहर जाकर बहुत छोटी संख्या में बदल सकता है।

बहुत बड़े ऐरे के लिए गुणा करने से पहले जाँच करें, या जिन प्रणालियों में यह सुविधा उपलब्ध हो वहाँ reallocarray का उपयोग करें।

if (cap > SIZE_MAX / sizeof(*a)) { /* overflow */ return 1; }
int *tmp = realloc(a, cap * sizeof(*a));

त्वरित जाँच

realloc की अपनी समझ जाँचें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन

realloc हीप ब्लॉक का आकार बदलता है और उसे दूसरी जगह ले जा सकता है, इसलिए हमेशा लौटाए गए पॉइंटर का उपयोग करें।

परिणाम को एक अस्थायी पॉइंटर में रखें, ताकि विफलता की स्थिति में मूल ब्लॉक लीक न हो। गति के लिए आकार को दोगुना करके बढ़ाएँ, नए स्लॉट को प्रारंभिक मान दें, और याद रखें कि realloc(NULL, n) का अर्थ malloc के समान है। आगे आप इस तर्क को एक पुनःप्रयोग योग्य वेक्टर प्रकार में रखेंगे।

शुरुआत निःशुल्क

एआई शिक्षक के साथ C सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 39
पाठ: 144

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “realloc से बढ़ाना” पाठ निःशुल्क है?

हाँ—“realloc से बढ़ाना” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और C Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। C Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“realloc से बढ़ाना” में मैं क्या सीखूँगा?

डायनेमिक Array का आकार बदलें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ C Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या C Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर C Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“realloc से बढ़ाना” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस C Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर C Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← C Academy पर वापस जाएँ