Antwoord.

In de C-taal zijn arrays een basisstructuur voor het opslaan van een geordende set elementen van hetzelfde type. Ze bieden snelle toegang op index en zijn nauw verbonden met het gebruik van pointers. Arrays kunnen statisch, automatisch (op de stack) of dynamisch (in de heap) worden gedeclareerd. Het type allocatie beïnvloedt de levensduur van de array, de beschikbaarheid vanuit verschillende delen van de code en de vereisten voor geheugenbeheer.

Achtergrond
Oorspronkelijke C maakte alleen statische en automatische arrays mogelijk, maar met de introductie van dynamische geheugenallocatie (functies malloc, calloc, free) ontstonden nieuwe ontwerppatronen die de flexibiliteit van de code verhoogden.

Probleem
Ontwikkelaars maken vaak fouten met afmetingen, levensduur en opruimen van arrays, wat leidt tot geheugenlekken, race-conditions en geheugenbeschadiging.

Oplossing
Een zorgvuldige keuze van het opslagtype afhankelijk van de taak, aandacht voor initiatie en tijdige vrijgave van geheugen voor dynamische arrays.

Codevoorbeeld:

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

int main() {
    // Automatisch (op de stack)
    int auto_arr[5] = {1,2,3,4,5};

    // Statisch (leeft zolang het programma draait)
    static int static_arr[5];

    // Dynamisch (in de heap)
    int *dyn_arr = malloc(5 * sizeof(int));
    for (int i = 0; i < 5; i++) dyn_arr[i] = i * 2;

    // Gebruik
    for (int i = 0; i < 5; i++) printf("%d ", dyn_arr[i]);
    printf("
");

    free(dyn_arr);
    return 0;
}

Belangrijke kenmerken:

Arrays slaan elementen aaneengeschakeld in het geheugen op, wat snelle toegang op index mogelijk maakt.
Het type opslaggebied bepaalt de levensduur van de array (stack, statisch geheugen, heap).
Dynamische arrays vereisen handmatig geheugenbeheer via malloc/calloc en free.

Misleidende vragen.

Kun je de grootte van een dynamische array verkrijgen via sizeof?

Nee, sizeof(ptr) voor een dynamische array geeft de grootte van de pointer terug, niet van de array. Het is nodig om de grootte handmatig op te slaan of een aparte variabele te gebruiken.

int* arr = malloc(10 * sizeof(int));
printf("%zu
", sizeof(arr)); // Grootte van de pointer, niet van de array

Wat gebeurt er als je buiten de grenzen van de array gaat?

In de C-taal is er geen automatische controle van arraygrenzen: toegang buiten de grenzen leidt tot undefined behavior. Fouten worden alleen tijdens runtime gedetecteerd of helemaal niet gedetecteerd.

Kun je een lokale (automatische) array uit een functie retourneren?

Nee! Een array, gedeclareerd binnen een functie, wordt verwijderd na afloop van de functie. Het retourneren van een dergelijke array leidt tot toegang tot al vrijgegeven geheugen.

int* create_wrong_array() {
    int arr[10];
    return arr; // Fout: pointer naar stack retourneren
}

Veelvoorkomende fouten en anti-patronen

Gebruik van lokale arrays na het verlaten van de functie.
Out-of-bounds toegang.
Vergeten aanroep free voor dynamische arrays: geheugenlekken.

Voorbeeld uit het leven

Negatief geval

Een ontwikkelaar maakt een array op de stack en retourneert de pointer naar deze array vanuit de functie. Het programma crasht soms of retourneert rommel.

Voordelen:

Geen kosten voor dynamische allocatie (theoretisch).

Nadelen:

Onbetrouwbaar gedrag, moeilijk om de fout te vangen.
Beschadiging van de stack, datalek.

Positief geval

Gebruik van dynamische allocatie met doorgeven van afmetingen samen met de pointer, opruimen van geheugen via free. Alle gevallen van geheugenopruiming worden gecontroleerd met unit-tests.