Hoe je 1D- en 2D-arrays doorgeeft aan functies in C

Deze tutorial legt uit hoe je gehele arrays – zowel eendimensionale als multidimensionale – doorgeeft aan functies in C, met duidelijke codevoorbeelden en best practices.

In C vervalt een arraynaam naar een pointer wanneer deze aan een functie wordt doorgegeven, waardoor de functie kan opereren op de originele data zonder deze te kopiëren. Dit gedrag te begrijpen is essentieel voor efficiënte, onderhoudbare code.

Individuele array-elementen doorgeven

Het doorgeven van een enkel element is identiek aan het doorgeven van een primitief type.

Voorbeeld 1: Individuele array-elementen doorgeven

#include <stdio.h>
void display(int age1, int age2) {
    printf("%d\n", age1);
    printf("%d\n", age2);
}
int main() {
    int ageArray[] = {2, 8, 4, 12};
    // Geef tweede en derde elementen door aan display()
    display(ageArray[1], ageArray[2]);
    return 0;
}

Output

8
4

Hier geven we ageArray[1] en ageArray[2] door net als gewone variabelen. De functie ontvangt ze by value, dus de originele array blijft ongewijzigd.

Hele eendimensionale arrays doorgeven

Om een hele array aan een functie door te geven, geef je simpelweg de arraynaam op. De functieprototype moet een arrayparameter aanduiden, maar de werkelijke grootte kan worden weggelaten. De compiler behandelt de parameter als een pointer naar het eerste element.

Voorbeeld 2: Som van een array berekenen

#include <stdio.h>
float calculateSum(float num[]);
int main() {
    float result, num[] = {23.4, 55, 22.6, 3, 40.5, 18};
    // Geef de hele array door aan calculateSum()
    result = calculateSum(num);
    printf("Resultaat = %.2f", result);
    return 0;
}
float calculateSum(float num[]) {
    float sum = 0.0;
    for (int i = 0; i < 6; ++i) {
        sum += num[i];
    }
    return sum;
}

Output

Resultaat = 162.50

De functiesignatuur float calculateSum(float num[]) vertelt de compiler dat num een pointer is naar een float-array. De lus verwerkt de array in-place zonder te kopiëren.

Multidimensionale arrays doorgeven

Multidimensionale arrays volgen hetzelfde principe: de arraynaam vervalt naar een pointer naar de eerste rij. De compiler moet echter de grootte van elke dimensie behalve de eerste kennen. Dit is nodig om de juiste geheugenoffsets te berekenen.

Voorbeeld 3: Een tweedimensionale array doorgeven

#include <stdio.h>
void displayNumbers(int num[2][2]);
int main() {
    int num[2][2];
    printf("Voer 4 getallen in:\n");
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 2; ++j) {
            scanf("%d", &num[i][j]);
        }
    }
    // Geef de tweedimensionale array door aan een functie
    displayNumbers(num);
    return 0;
}
void displayNumbers(int num[2][2]) {
    printf("Weergave:\n");
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 2; ++j) {
            printf("%d\n", num[i][j]);
        }
    }
}

Output

Voer 4 getallen in: 2 3 4 5
Weergave:
2
3
4
5

De functieprototype void displayNumbers(int num[2][2]) declareert een 2×2 integer-array. Bij het aanroepen van de functie geven we simpelweg num door; de compiler zorgt automatisch voor de pointerconversie.

Let op dat je de rij-dimensie kunt weglaten, maar de kolomgrootte moet specificeren: int num[][2] is geldig, terwijl de kolomgrootte essentieel is voor adresberekening.

Belangrijk: C staat het doorgeven van arrays aan functies toe, maar ondersteunt niet direct het retourneren van arrays uit functies. Gebruik pointers of structuren als je complexe data moet retourneren.