C Academy · पाठ

Dangling Pointers

Use-after-free के खतरे

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

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

Dangling Pointer क्या होता है

Dangling pointer ऐसी मेमोरी की ओर संकेत करता है जिसे पहले ही मुक्त किया जा चुका है या जो किसी अन्य कारण से अब मान्य नहीं है।

इसका उपयोग करने पर अनिर्धारित व्यवहार हो सकता है: क्रैश, डेटा का बिगड़ना या बिना दिखाई देने वाली गड़बड़ियाँ।

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

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 5;
    printf("%d\n", *p);
    free(p);
    p = NULL;
    return 0;
}

मुक्त करने के बाद उपयोग

इसका सबसे सामान्य कारण free के बाद pointer के ज़रिए पढ़ना या लिखना है।

उस ब्लॉक का उपयोग किसी अन्य काम के लिए फिर से किया जा चुका हो सकता है।

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

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 42;
    free(p);
    /* Reading *p here would be use-after-free. */
    p = NULL;
    printf("avoided use-after-free\n");
    return 0;
}

मुक्त करने के बाद NULL करना

मुक्त करने के तुरंत बाद pointer को NULL पर सेट करने से अनजाने उपयोग की स्थिति में स्पष्ट क्रैश होता है, या सुरक्षित रूप से free(NULL) चल जाता है।

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

int main(void) {
    char *buf = malloc(10);
    buf[0] = 'A';
    free(buf);
    buf = NULL;
    if (buf == NULL) printf("buf is safely null\n");
    return 0;
}

स्थानीय पते को लौटाना

किसी स्थानीय (स्टैक) variable का address लौटाने से dangling pointer बन जाता है: function के लौटते ही वह variable समाप्त हो जाता है।

इसके बजाय heap का उपयोग करें या buffer पास करें।

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

int *make_value(int v) {
    int *p = malloc(sizeof(int));
    *p = v;
    return p;
}

int main(void) {
    int *p = make_value(99);
    printf("%d\n", *p);
    free(p);
    return 0;
}

एक ब्लॉक की ओर कई pointers

यदि दो pointers एक ही ब्लॉक का संदर्भ देते हैं, तो एक के ज़रिए उसे मुक्त करने पर दूसरा dangling हो जाता है।

ownership का हिसाब रखें, ताकि केवल owner ही उसे मुक्त करे।

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

int main(void) {
    int *a = malloc(sizeof(int));
    *a = 7;
    int *b = a;
    printf("%d\n", *b);
    free(a);
    a = NULL;
    b = NULL;
    printf("both nulled\n");
    return 0;
}

realloc के बाद dangling pointer

जब realloc किसी ब्लॉक को दूसरी जगह ले जाता है, तो पिछले स्थान की ओर संकेत करने वाला हर पुराना pointer dangling हो जाता है।

केवल realloc से लौटे हुए pointer का उपयोग करें।

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

int main(void) {
    int *a = malloc(sizeof(int));
    a[0] = 1;
    int *b = realloc(a, 50 * sizeof(int));
    /* a may now be dangling; use only b. */
    b[0] = 2;
    printf("%d\n", b[0]);
    free(b);
    return 0;
}

सहायक function में मुक्त करना

यदि कोई helper किसी ब्लॉक को मुक्त करता है, तो caller का pointer dangling रह जाता है। या तो call के बाद उसे null करें या helper को pointer-to-pointer लेने के लिए डिज़ाइन करें।

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

void destroy(int **p) {
    free(*p);
    *p = NULL;
}

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 5;
    destroy(&p);
    printf("p is %s\n", p == NULL ? "null" : "set");
    return 0;
}

यह खतरनाक क्यों है

मुक्त करने के बाद उपयोग करना खतरनाक है, क्योंकि उस मेमोरी में अब कोई अन्य डेटा हो सकता है। लिखने पर असंबंधित state बिगड़ सकती है और हमलावर इसका दुरुपयोग कर सकते हैं।

scope पर आधारित dangling pointers

किसी block-scope variable की ओर संकेत करने वाला pointer, block समाप्त होते ही अमान्य हो जाता है। Pointers को उस चीज़ के lifetime से अधिक समय तक न रखें जिसकी ओर वे संकेत करते हैं।

#include <stdio.h>

int main(void) {
    int *p;
    {
        int x = 10;
        p = &x;
        printf("in scope: %d\n", *p);
    }
    /* p now dangles; do not dereference it here. */
    printf("block ended\n");
    return 0;
}

dangling pointers का पता लगाना

AddressSanitizer और Valgrind जैसे tools runtime पर मुक्त करने के बाद किए गए उपयोग को पकड़ लेते हैं और ठीक उस line की ओर संकेत करते हैं।

विकास के दौरान sanitizers के साथ build करें।

Code में सुरक्षित lifecycle का सार

Allocate करें, उपयोग करें, मुक्त करें और null करें। इस क्रम का लगातार पालन करने से pointers dangling नहीं होते।

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

int main(void) {
    int *p = malloc(sizeof(int));
    if (!p) return 1;
    *p = 123;
    printf("%d\n", *p);
    free(p);
    p = NULL;
    return 0;
}

त्वरित जाँच

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

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

सारांश

आपने dangling pointers के बारे में सीखा:

वे मुक्त या scope से बाहर हो चुकी मेमोरी की ओर संकेत करते हैं; उनका उपयोग अनिर्धारित व्यवहार है।
Locals के addresses लौटाने से बचें; free के बाद या realloc द्वारा ब्लॉक को दूसरी जगह ले जाने के बाद कभी pointer का उपयोग न करें।
मुक्त करने के बाद pointers को NULL पर सेट करें और ownership का हिसाब रखें।
मुक्त करने के बाद किए गए उपयोग का पता लगाने के लिए sanitizers और Valgrind का उपयोग करें।

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

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

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

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

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

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

क्या “Dangling Pointers” पाठ निःशुल्क है?

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

“Dangling Pointers” में मैं क्या सीखूँगा?

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

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

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

“Dangling Pointers” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

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