C Academy · Les

Ongeldige toegang

Buiten bereik en niet-geïnitialiseerd

Les 3 van 413 stappen

Ongeldige toegang is een gratis C Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C Academy bevat in totaal 4 lessen.

Verder dan lekken

Lekken verspillen geheugen, maar fouten met ongeldige toegang beschadigen het. memcheck detecteert verschillende soorten:

Lezen of schrijven voorbij het einde van een buffer
Geheugen gebruiken nadat free is aangeroepen
Niet-geïnitialiseerde waarden lezen
Lezen of schrijven via een ongeldige verwijzing

Deze fouten veroorzaken de gevaarlijkste en moeilijkst reproduceerbare crashes.

Schrijven buiten de grenzen

Dit reserveert ruimte voor 5 ints, maar schrijft naar index 5, de zesde positie.

Index 5 ligt één element voorbij het einde. memcheck meldt op deze regel een 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;
}

De fout lezen

Het rapport vermeldt de bewerking, de grootte en de relatie tot het blok:

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' vertelt je dat de toegang direct na een toewijzing van 20 bytes (5 ints) terechtkwam.

Lezen buiten de grenzen

Leesbewerkingen worden ook gedetecteerd. Hier loopt de lus één element te ver door.

memcheck meldt bij de laatste iteratie een Invalid read of size 4, ook al lijkt het programma toevallig te 'werken'.

#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;
}

Niet-geïnitialiseerde waarden

malloc maakt geheugen niet nul. Als je het gebruikt voordat je er een waarde aan toewijst, krijg je een onvoorspelbare waarde.

memcheck meldt Conditional jump or move depends on uninitialised value(s) wanneer zo'n waarde invloed heeft op de besturingsstroom of uitvoer.

#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;
}

Waarom meldingen over niet-geïnitialiseerde waarden vertraagd verschijnen

memcheck klaagt niet meteen wanneer je niet-geïnitialiseerd geheugen leest. Het houdt bij of waarden 'gedefinieerd' zijn en meldt het probleem pas wanneer een ongedefinieerde waarde daadwerkelijk van belang is, bijvoorbeeld in een vertakking, uitvoer of systeemaanroep.

Zo voorkom je valse alarmen wanneer je niet-geïnitialiseerde bytes onschadelijk kopieert.

Gebruik na vrijgeven

Geheugen aanraken nadat je het hebt vrijgegeven, is ongedefinieerd gedrag. memcheck detecteert dit nauwkeurig.

Het meldt Invalid read of size 4 met de opmerking Address ... is 0 bytes inside a block of size 4 free'd en toont zelfs waar free werd aangeroepen.

#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;
}

Dubbel vrijgeven

Als je dezelfde pointer twee keer vrijgeeft, raakt de administratie van de allocator beschadigd.

memcheck meldt Ongeldige free() en toont zowel de huidige vrijgave als de oorspronkelijke toewijzing, waardoor de fout duidelijk wordt.

#include <stdlib.h>

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

Oorsprong bijhouden

Voeg voor fouten met niet-geïnitialiseerde waarden --track-origins=yes toe.

memcheck meldt dan waar de verkeerde waarde is gemaakt, niet alleen waar deze is gebruikt. Zo wordt een vage waarschuwing een gerichte oplossing.

valgrind --track-origins=yes ./prog

Stack en globale variabelen

memcheck is bijzonder goed in het opsporen van heap-fouten. Voor overflows op de stack of in globale arrays is de dekking minder goed.

Daarvoor is AddressSanitizer (gcc -fsanitize=address) vaak een betere keuze. De twee hulpmiddelen vullen elkaar aan.

Eén byte te veel: de nulterminator

Een veelvoorkomende heap-overflow ontstaat doordat de terminator van een tekenreeks wordt vergeten. strlen retourneert 5 voor 'hello', maar de tekenreeks heeft 6 bytes nodig om de afsluitende '\0' op te slaan.

memcheck meldt een ongeldige schrijfactie wanneer strcpy die laatste byte voorbij het einde schrijft.

#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;
}

Snelle controle

Identificeer wat memcheck voor het fragment meldt.

Beantwoord dit in de interactieve les

Samenvatting

Je kunt nu fouten met ongeldige geheugentoegang herkennen:

Lezen en schrijven buiten de grenzen verschijnen als ongeldige lees- of schrijfacties, met de offset binnen het blok
Niet-geïnitialiseerde waarden worden gemeld zodra ze een beslissing of uitvoer beïnvloeden
Gebruik na vrijgave en dubbel vrijgeven worden gedetecteerd, met beide aanroepplaatsen
--track-origins=yes lokaliseert ongedefinieerde waarden; combineer dit met ASan voor stack-fouten

Volgende stap: het volledige rapport lezen.

Gratis beginnen

Leer C met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 39
Lessen: 144

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Ongeldige toegang” gratis?

Ja — de volledige tekst van “Ongeldige toegang” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus C Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus C Academy bevat in totaal 4 lessen.

Wat leer ik in “Ongeldige toegang”?

Buiten bereik en niet-geïnitialiseerd Je oefent met C Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C Academy te beginnen?

Ervaring vooraf is niet nodig. C Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Ongeldige toegang”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C Academy?

Ja. Elke les over C Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar C Academy