Functiepointers in C: Praktische Voorbeelden en Best Practices

Functiepointers ontgrendelen krachtige mogelijkheden in C, waardoor functies data direct via geheugenadressen kunnen manipuleren in plaats van waarden te kopiëren. Door adressen aan pointer-parameters door te geven, kan een functie de oorspronkelijke variabelen wijzigen, wat patronen mogelijk maakt zoals in-place swapping, dynamische callbacks en higher-order functies.

• Functiepointers Voorbeeld
• Functies met Array-parameters
• Functies die een Array retourneren
• Functiepointers
• Array van Functiepointers
• Functies die void-pointers gebruiken
• Functiepointers als Argumenten

Functiepointers Voorbeeld

De klassieke swap-routine demonstreert hoe een functie de waarden van twee variabelen kan uitwisselen door op hun adressen te opereren.

void swap (int *a, int *b);
int main() {
    int m = 25;
    int n = 100;
    printf("m is %d, n is %d\n", m, n);
    swap(&m, &n);
    printf("m is %d, n is %d\n", m, n);
    return 0;
}
void swap (int *a, int *b) {
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

Output:

m is 25, n is 100
m is 100, n is 25

1. Declareer swap met twee integer-pointers.
2. Initialiseer m en n in main en print ze.
3. Roep swap(&m, &n) aan om de adressen door te geven.
4. Binnen swap, gebruik een tijdelijke variabele om de waarden te wisselen.
5. Dereferenceer pointers om de daadwerkelijke data te lezen/schrijven.

Functies met Array-parameters

Arrays vervallen naar pointers wanneer ze aan functies doorgegeven worden. Het volgende programma telt de elementen van een array op door over de pointer te itereren.

int tel_array (int *a, int aantal_elementen);
int main() {
    int Tabel[5] = {100, 220, 37, 16, 98};
    printf("Totale som is %d\n", tel_array(Tabel, 5));
    return 0;
}
int tel_array (int *p, int grootte) {
    int totaal = 0;
    for (int k = 0; k < grootte; k++) {
        totaal += p[k]; /* equivalent aan totaal += *p; p++; */
    }
    return totaal;
}

Output:

Totale som is 471

1. Definieer tel_array om een pointer en grootte te accepteren, retourneert de som.
2. Geef de arraynaam Tabel (die vervalt naar een pointer) en de lengte door aan de functie.

Functies die een Array Retourneren

Een functie kan een pointer naar een statische array retourneren. Deze benadering is nuttig wanneer de aanroeper een tijdelijke array nodig heeft zonder geheugentoewijzing te managen.

#include <stdio.h>
int * bouw_array();
int main() {
    int *a;
    a = bouw_array(); /* krijg eerste 5 even getallen */
    for (int k = 0; k < 5; k++) printf("%d\n", a[k]);
    return 0;
}
int * bouw_array() {
    static int Tabel[5] = {1,2,3,4,5};
    return Tabel;
}

Output:

1 2 3 4 5

1. Declareer een functie die een pointer naar een statische array retourneert.
2. Gebruik de geretourneerde pointer om te itereren en de array-inhoud te printen.

Functiepointers

Een functiepointer bevat het adres van een functie's entry-point, wat dynamische dispatch en callbacks mogelijk maakt. De declaratiesyntaxis vereist haakjes om de asterisk om misinterpretatie te voorkomen.

retour_type (*functie_naam)(argumenten)

Voorbeeld: Een routine aanroepen via een pointer.

#include <stdio.h>
void Hoi_functie (int keer); /* functie */
int main() {
    void (*functie_ptr)(int); /* functiepointer */
    functie_ptr = Hoi_functie; /* toewijzing */
    functie_ptr(3); /* aanroep */
    return 0;
}
void Hoi_functie (int keer) {
    for (int k = 0; k < keer; k++) printf("Hoi\n");
}

Output:

Hoi Hoi Hoi

1. Definieer een gewone functie.
2. Declareer een functiepointer met de correcte handtekening.
3. Wijs de pointer toe aan de functienaam.
4. Roep de functie aan via de pointer.

Array van Functiepointers

Meerdere functiepointers in een array opslaan maakt een tabel-gedreven benadering mogelijk, vergelijkbaar met een switch-statement. Het volgende programma demonstreert een eenvoudige rekenmachine.

#include <stdio.h>
int som(int num1, int num2);
int verschil(int num1, int num2);
int product(int num1, int num2);
int deel(int num1, int num2);
int main() {
    int x, y, keuze, resultaat;
    int (*ope[4])(int, int);
    ope[0] = som;
    ope[1] = verschil;
    ope[2] = product;
    ope[3] = deel;
    printf("Voer twee gehele getallen in: ");
    scanf("%d%d", &x, &y);
    printf("Voer 0 voor som, 1 voor verschil, 2 voor product, of 3 voor deel: ");
    scanf("%d", &keuze);
    resultaat = ope[keuze](x, y);
    printf("%d", resultaat);
    return 0;
}
int som(int x, int y) {return x + y;}
int verschil(int x, int y) {return x - y;}
int product(int x, int y) {return x * y;}
int deel(int x, int y) {return y != 0 ? x / y : 0;}

Resultaat: Invoer 13 48 2 → 624

1. Definieer vier rekenkundige functies.
2. Maak een array van vier functiepointers met matching handtekeningen.
3. Wijs elke pointer toe aan de bijbehorende functie.
4. Haal de keuze van de gebruiker op en roep de geselecteerde functie aan.

Functies die void-pointers Gebruiken

Void-pointers bieden type-agnostische toegang tot data. Wanneer gebruikt in functieparameters, staan ze toe dat de routine elk datatype accepteert, mits de aanroeper de juiste cast geeft.

void * kubus (const void *);

Voorbeeldprogramma:

#include <stdio.h>
void* kubus (const void* num);
int main() {
    int x = 4;
    int kubus_int = (int)kubus(&x);
    printf("%d tot de derde macht is %d\n", x, kubus_int);
    return 0;
}
void* kubus (const void *num) {
    int resultaat = (*(int *)num) * (*(int *)num) * (*(int *)num);
    return (void*)resultaat;
}

Resultaat: 4 tot de derde macht is 64

1. Definieer een functie die een const void-pointer accepteert en een void-pointer retourneert.
2. Cast de pointer naar int * om de waarde te benaderen.
3. Bereken de derde macht en cast het resultaat terug naar void * voor retour.

Functiepointers als Argumenten

Een functiepointer doorgeven aan een andere functie is een veelvoorkomend patroon voor callbacks. De standaardbibliotheek's qsort gebruikt deze techniek om arrays van willekeurige typen te sorteren.

void qsort(void *base, size_t num, size_t width, int (*vergelijk)(const void *, const void *));

Voorbeeld dat een integer-array sorteert:

#include <stdio.h>
#include <stdlib.h>
int vergelijk (const void *, const void *);
int main() {
    int arr[5] = {52, 14, 50, 48, 13};
    size_t num = sizeof(arr)/sizeof(arr[0]);
    size_t width = sizeof(arr[0]);
    qsort((void *)arr, num, width, vergelijk);
    for (size_t i = 0; i < num; i++) printf("%d ", arr[i]);
    return 0;
}
int vergelijk (const void *elem1, const void *elem2) {
    int a = *(int *)elem1;
    int b = *(int *)elem2;
    return (a - b);
}

Resultaat: 13 14 48 50 52

1. Implementeer vergelijk om negatief, nul of positief te retourneren op basis van de twee integers.
2. Bepaal array-grootte en element-breedte met sizeof.
3. Roep qsort aan met de array, aantal, breedte en vergelijkingsfunctie.
4. Print de gesorteerde array om de operatie te verifiëren.