Antwoord.

In de C-taal bepaalt de opslagklasse van variabelen waar gegevens worden opgeslagen, hoe lang ze beschikbaar zijn en welke codegebieden er toegang toe hebben. Historisch gezien zijn de sleutelwoorden auto (standaard voor lokale variabelen), static (behoudt waarde tussen aanroepen, vaak gebruikt voor het opslaan van state) en extern (verklaart een variabele die ergens anders is gedefinieerd) geïntroduceerd om zichtbaarheid en levensduur van variabelen te beheersen.

Probleem — een verkeerd begrip van waar en hoe lang een variabele leeft, kan leiden tot toegangsfouten, geheugenlekken en moeilijk leesbare code. Bijvoorbeeld, verkeerd verwachten dat een lokale statische variabele opnieuw wordt gemaakt bij elke functie-aanroep, of omgekeerd — dat een auto-variabele zijn waarde behoudt tussen aanroepen.

Oplossing — kies altijd bewust de opslagspecifier en begrijp de gevolgen ervan:

auto is meestal niet nodig (is de standaard),
static voor het behouden van waarden tussen aanroepen of voor het beperken van de zichtbaarheid binnen een module,
extern voor toegang tot globale variabelen, gedefinieerd in andere bestanden.

Voorbeeld van gebruik:

// main.c
int global_var = 42; // heeft standaard static opslagklasse, externe linkage

void func() {
    static int counter = 0; // leeft tussen aanroepen
    auto int temp = 5; // lokaal, auto hoeft niet expliciet te worden aangegeven
    counter++;
    printf("aanroep #%d\n", counter);
}

extern int global_var;

Belangrijkste kenmerken:

auto: de variabele blijft bestaan tot het einde van het blok (scope) waarin deze is gedeclareerd.
static: de variabele blijft bestaan gedurende het hele programma, maar is alleen zichtbaar binnen het bestand/de functie/de blok.
extern: de variabele is gedeclareerd, maar niet hier gedefinieerd, de definitie bevindt zich in een ander bestand.

Misleidende vragen.

Waarom zou je auto schrijven, als variabelen standaard al auto zijn?

Antwoord: In moderne versies van C wordt het sleutelwoord auto bijna niet expliciet gebruikt — voor een lokale variabele is dit de standaardspecifier. In het algemeen biedt het expliciet schrijven geen voordelen.

Kan static binnen een functie worden gebruikt om een globale variabele te verklaren?

Antwoord: Nee, static binnen een functie maakt de variabele lokaal, maar behoudt de staat tussen aanroepen. Het is niet zichtbaar buiten de functie.

Voorbeeld code:

void foo() {
    static int call_count = 0; // Niet globaal, maar leeft tussen aanroepen
    call_count++;
}

Wat gebeurt er als je een variabele als extern binnen een functie verklaart, maar deze nergens definieert?

Antwoord: Dit leidt tot een linkerfout, omdat er een verwijzing is naar een globale variabele die niet bestaat.

Typische fouten en anti-patronen

Verwarren van zichtbaarheid en levensduur (bijvoorbeeld verwachten dat statische variabelen lokaal zijn buiten functies).
Externe variabelen declareren zonder definitie.
Auto gebruiken zonder noodzaak.

Voorbeeld uit de praktijk

Negatief geval

In een groot project werden module-variabelen als extern in alle bronnen gedeclareerd, maar men vergat de definitie te maken. Dit leidde tot mysterieuze koppelingsfouten, onduidelijk voor beginnende ontwikkelaars.

Voordelen:

Maakte verwijzen naar variabelen in veel bestanden mogelijk.

Nadelen:

Moeilijk te onderhouden.
Fouten die pas optreden na het compileren van alle bestanden, en niet tijdens het schrijven van de code.

Positief geval

Er werd strikt omgegaan met zichtbaarheid: elke statische variabele alleen in de benodigde module, globale extern werden in headerbestanden verklaard en op één plek gedefinieerd.