C Academy · पाठ

Invalid Access

सीमा से बाहर और uninitialized access

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

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

लीक से आगे

लीक मेमोरी बर्बाद करते हैं, लेकिन अमान्य पहुँच वाले बग उसे दूषित करते हैं। memcheck कई प्रकार की समस्याएँ पकड़ता है:

बफ़र के अंत के बाद पढ़ना या लिखना
free के बाद मेमोरी का उपयोग करना
प्रारंभ न किए गए मान पढ़ना
गलत पॉइंटर के माध्यम से पढ़ना या लिखना

इनसे सबसे खतरनाक और दोबारा उत्पन्न करना सबसे कठिन क्रैश होते हैं।

सीमा से बाहर लिखना

यह 5 ints के लिए जगह आवंटित करता है, लेकिन index 5, यानी छठे स्थान, पर लिखता है।

Index 5 अंतिम स्थान से एक element आगे है। memcheck इस line पर Invalid write of size 4 रिपोर्ट करता है।

#include <stdlib.h>

int main(void) {
    int *a = malloc(5 * sizeof(int));
    a[5] = 99; /* valid indices are 0..4 */
    free(a);
    return 0;
}

त्रुटि पढ़ना

रिपोर्ट ऑपरेशन, आकार और ब्लॉक से संबंध बताती है:

Invalid write of size 4
Address 0x... is 0 bytes after a block of size 20 alloc'd

'0 bytes after a block of size 20' बताता है कि पहुँच 20-बाइट (5-int) वाले आवंटन के ठीक बाद हुई।

सीमा से बाहर पढ़ना

पढ़ने की समस्याएँ भी पकड़ी जाती हैं। यहाँ लूप एक element अधिक आगे तक चलता है।

अंतिम iteration पर memcheck Invalid read of size 4 दिखाता है, भले ही प्रोग्राम संयोग से 'काम' करता हुआ दिखाई दे।

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

int main(void) {
    int *a = calloc(3, sizeof(int));
    for (int i = 0; i <= 3; i++)   /* should be i < 3 */
        printf("%d\n", a[i]);
    free(a);
    return 0;
}

प्रारंभ न किए गए मान

malloc मेमोरी को शून्य नहीं करता। मान निर्दिष्ट करने से पहले उसका उपयोग करने पर अप्रत्याशित मान मिलता है।

जब ऐसा मान नियंत्रण प्रवाह या output को प्रभावित करता है, तो memcheck Conditional jump or move depends on uninitialised value(s) रिपोर्ट करता है।

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

int main(void) {
    int *p = malloc(sizeof(int));
    if (*p == 0)              /* *p was never set */
        printf("zero\n");
    free(p);
    return 0;
}

प्रारंभ न किए गए मानों की रिपोर्ट देर से क्यों आती है

memcheck प्रारंभ न की गई मेमोरी पढ़ते ही शिकायत नहीं करता। यह 'परिभाषितता' को ट्रैक करता है और तभी रिपोर्ट करता है जब कोई अपरिभाषित मान वास्तव में महत्वपूर्ण हो, जैसे किसी शाखा, output या सिस्टम कॉल में।

इससे प्रारंभ न की गई बाइटों को बिना नुकसान इधर-उधर कॉपी करने पर झूठी चेतावनियाँ नहीं मिलतीं।

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

मेमोरी को मुक्त करने के बाद उसे छूना अनिर्धारित व्यवहार है। memcheck इसका सटीक पता लगाता है।

यह Invalid read of size 4 के साथ Address ... is 0 bytes inside a block of size 4 free'd नोट दिखाता है और यह भी बताता है कि free कहाँ हुआ था।

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

int main(void) {
    int *p = malloc(sizeof(int));
    *p = 7;
    free(p);
    printf("%d\n", *p);   /* read after free */
    return 0;
}

डबल फ्री

एक ही पॉइंटर को दो बार फ़्री करने से आवंटक का लेखा-जोखा बिगड़ जाता है।

memcheck Invalid free() की सूचना देता है और वर्तमान फ़्री तथा मूल आवंटन, दोनों दिखाता है, जिससे गलती स्पष्ट हो जाती है।

#include <stdlib.h>

int main(void) {
    int *p = malloc(sizeof(int));
    free(p);
    free(p);   /* freed twice */
    return 0;
}

स्रोतों को ट्रैक करें

अप्रारंभित मानों की त्रुटियों के लिए --track-origins=yes जोड़ें।

इसके बाद memcheck यह बताता है कि गलत मान कहाँ बनाया गया था, केवल यह नहीं कि उसका उपयोग कहाँ हुआ, जिससे अस्पष्ट चेतावनी को सटीक सुधार में बदला जा सकता है।

valgrind --track-origins=yes ./prog

स्टैक और ग्लोबल

memcheck हीप की त्रुटियों को पकड़ने में बहुत अच्छा है। स्टैक या ग्लोबल एरे में होने वाले ओवरफ़्लो के लिए इसकी पहुँच कमज़ोर है।

ऐसे मामलों में AddressSanitizer (gcc -fsanitize=address) अक्सर बेहतर विकल्प है। ये दोनों उपकरण एक-दूसरे के पूरक हैं।

एक की गलती: नल टर्मिनेटर

हीप ओवरफ़्लो का एक आम कारण स्ट्रिंग टर्मिनेटर को भूल जाना है। strlen 'hello' के लिए 5 लौटाता है, लेकिन अंत में आने वाले '\0' को रखने के लिए स्ट्रिंग को 6 बाइट चाहिए।

जब strcpy उस अंतिम बाइट को सीमा के बाहर लिखता है, तो memcheck अमान्य लेखन की सूचना देता है।

#include <stdlib.h>
#include <string.h>

int main(void) {
    char *s = malloc(strlen("hello")); /* needs +1 */
    strcpy(s, "hello");                 /* writes the '\0' past end */
    free(s);
    return 0;
}

त्वरित जाँच

दिए गए कोड अंश के लिए memcheck की सूचना पहचानें।

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

पुनरावलोकन

अब आप अमान्य पहुँच वाली बग पहचान सकते हैं:

सीमा से बाहर पढ़ने/लिखने पर ब्लॉक ऑफ़सेट के साथ अमान्य पठन/लेखन दिखाई देता है
अप्रारंभित मानों को तब चिह्नित किया जाता है जब वे किसी निर्णय या आउटपुट को प्रभावित करते हैं
फ़्री किए जाने के बाद उपयोग और डबल-फ्री, दोनों कॉल स्थानों के साथ पकड़े जाते हैं
--track-origins=yes अपरिभाषित मानों का स्रोत बताता है; स्टैक की बग के लिए इसे ASan के साथ उपयोग करें

अगला विषय: पूरी रिपोर्ट पढ़ना।

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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