Opslagklassen in C Begrijpen: auto, extern, static, register Uitgelegd

Wat is een Opslagklasse in C?

Een opslagklasse definieert de scope, locatie, initialisatie, levensduur en toegankelijkheid van een variabele. In C is elke variabele niet alleen getypeerd, maar ook een opslagklasse toegewezen die bepaalt waar en hoe deze toegankelijk is.

Er zijn vier standaard opslagklassen:

• auto – standaard voor lokale variabelen.
• extern – declareert een globale variabele of functie die in een ander bestand bestaat.
• static – behoudt de waarde van een variabele tussen aanroepen en beperkt zichtbaarheid tot een bestand of functie.
• register – hint de compiler om een variabele in een CPU-register op te slaan voor snellere toegang.

Auto Opslagklasse

Variabelen gedeclareerd met auto (de standaard voor lokale variabelen) bestaan alleen binnen het blok waarin ze gedefinieerd zijn. Ze worden vernietigd wanneer het blok verlaten wordt, en ze worden geïnitialiseerd met een onbepaalde tenzij expliciet ingesteld.

int optellen(void) {
    int a = 13;
    auto int b = 48; // auto is optioneel
    return a + b;
}

Scope demonstratie:

#include <stdio.h>
int main(void) {
    auto int j = 1;
    {
        auto int j = 2;
        {
            auto int j = 3;
            printf("%d ", j); // print 3
        }
        printf("\t%d ", j); // print 2
    }
    printf("%d\n", j); // print 1
}

Output: 3 2 1

Extern Opslagklasse

Het extern-sleutelwoord declareert een variabele of functie die in een andere vertaaleenheid gedefinieerd is. Het stelt datadeling tussen bronbestanden in.

/* main.c */
#include <stdio.h>
extern int i; // declaratie
int main(void) {
    printf("waarde van de externe integer is = %d\n", i);
    return 0;
}
/* original.c */
#include <stdio.h>
int i = 48; // definitie

Compileer beide bestanden samen: gcc main.c original.c -o programma. Uitvoeren van ./programma geeft:

waarde van de externe integer is = 48

Static Opslagklasse

Statische variabelen behouden hun waarde voor de duur van het programma. Ze kunnen gebruikt worden als lokale statics of bestands-scope statics.

• Lokale static – alleen zichtbaar binnen de functie maar blijft bestaan tussen aanroepen.
• Bestands-scope static – alleen zichtbaar binnen het bestand waar gedeclareerd.

/* globale static */
static int teller = 7;
void volgende(void) {
    /* lokale static */
    static int iteratie = 13;
    iteratie++;
    printf("iteratie=%d en teller=%d\n", iteratie, teller);
}
int main(void) {
    while (teller < 10) {
        volgende();
        teller++;
    }
    return 0;
}

Output:

iteratie=14 en teller=7
iteratie=15 en teller=8
iteratie=16 en teller=9

Register Opslagklasse

Gebruik register wanneer een variabele frequente toegang nodig heeft en in een CPU-register past. De compiler kan de hint negeren als registers schaars zijn.

#include <stdio.h>
int main(void) {
    register int gewicht;
    /* poging om adres te nemen mislukt */
    // int *ptr = &gewicht; // compilatiefout
    return 0;
}

Compileren van de code levert:

error: address of register variable 'gewicht' requested

Samenvattingstabel

Belangrijkste Inzichten

• Opslagklassen controleren zichtbaarheid en levensduur van variabelen.
• Gebruik auto voor standaard lokale variabelen.
• Gebruik register voor prestatie-kritieke tellers (onder voorbehoud van compiler-ondersteuning).
• Gebruik static om state te behouden tussen functie-aanroepen of om bestands-scope te beperken.
• Gebruik extern om variabelen of functies te delen tussen bronbestanden.