Funktionszeiger in C: Praktische Beispiele und Best Practices

Funktionszeiger eröffnen in C mächtige Möglichkeiten, indem sie Funktionen erlauben, Daten direkt über Speicheradressen zu manipulieren, statt Werte zu kopieren. Durch Übergeben von Adressen an Zeigerparameter kann eine Funktion die ursprünglichen Variablen modifizieren, was Muster wie In-Place-Swapping, dynamische Callbacks und Higher-Order-Funktionen ermöglicht.

• Funktionszeiger-Beispiel
• Funktionen mit Array-Parametern
• Funktionen, die ein Array zurückgeben
• Funktionszeiger
• Array von Funktionszeigern
• Funktionen mit Void-Zeigern
• Funktionszeiger als Argumente

Funktionszeiger-Beispiel

Der klassische Swap-Algorithmus demonstriert, wie eine Funktion die Werte zweier Variablen durch Operation auf ihren Adressen austauschen kann.

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;
}

Ausgabe:

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

1. swap mit zwei Integer-Zeigern deklarieren.
2. m und n in main initialisieren und ausgeben.
3. swap(&m, &n) aufrufen, um Adressen zu übergeben.
4. In swap temporäre Variable zum Austauschen der Werte nutzen.
5. Zeiger dereferenzieren, um tatsächliche Daten zu lesen/schreiben.

Funktionen mit Array-Parametern

Arrays verfallen zu Zeigern, wenn sie an Funktionen übergeben werden. Das folgende Programm summiert Array-Elemente durch Iteration über den Zeiger.

int add_array(int *a, int num_elements);
int main() {
    int Tab[5] = {100, 220, 37, 16, 98};
    printf("Total summation is %d\n", add_array(Tab, 5));
    return 0;
}
int add_array(int *p, int size) {
    int total = 0;
    for (int k = 0; k < size; k++) {
        total += p[k]; /* äquivalent zu total += *p; p++; */
    }
    return total;
}

Ausgabe:

Total summation is 471

1. add_array definieren, das Zeiger und Größe annimmt, Summe zurückgibt.
2. Arraynamen Tab (verfällt zu Zeiger) und Länge an Funktion übergeben.

Funktionen, die ein Array zurückgeben

Eine Funktion kann einen Zeiger auf ein statisches Array zurückgeben. Nützlich, wenn der Aufrufer ein temporäres Array ohne Speicherverwaltung benötigt.

#include <stdio.h>
int *build_array();
int main() {
    int *a;
    a = build_array(); /* erste 5 geraden Zahlen */
    for (int k = 0; k < 5; k++) printf("%d\n", a[k]);
    return 0;
}
int *build_array() {
    static int Tab[5] = {1,2,3,4,5};
    return Tab;
}

Ausgabe:

1 2 3 4 5

1. Funktion deklarieren, die Zeiger auf statisches Array zurückgibt.
2. Rückgabezeiger nutzen, um Array-Inhalt zu iterieren und auszugeben.

Funktionszeiger

Ein Funktionszeiger hält die Adresse eines Funktions-Einstiegspunkts, was dynamische Dispatch und Callbacks ermöglicht. Die Deklarationssyntax erfordert Klammern um den Stern, um Fehlinterpretation zu vermeiden.

return_type (*function_name)(arguments)

Beispiel – Routine über Zeiger aufrufen:

#include <stdio.h>
void Hi_function(int times); /* Funktion */
int main() {
    void (*function_ptr)(int); /* Funktionszeiger */
    function_ptr = Hi_function; /* Zuweisung */
    function_ptr(3); /* Aufruf */
    return 0;
}
void Hi_function(int times) {
    for (int k = 0; k < times; k++) printf("Hi\n");
}

Ausgabe:

Hi
Hi
Hi

1. Reguläre Funktion definieren.
2. Funktionszeiger mit korrekter Signatur deklarieren.
3. Zeiger auf Funktionsnamen zuweisen.
4. Funktion über Zeiger aufrufen.

Array von Funktionszeigern

Mehrere Funktionszeiger in einem Array zu speichern, ermöglicht einen tabellengesteuerten Ansatz, ähnlich einer Switch-Anweisung. Das folgende Programm demonstriert einen einfachen Rechner.

#include <stdio.h>
int sum(int num1, int num2);
int sub(int num1, int num2);
int mult(int num1, int num2);
int divi(int num1, int num2);
int main() {
    int x, y, choice, result;
    int (*ope[4])(int, int);
    ope[0] = sum;
    ope[1] = sub;
    ope[2] = mult;
    ope[3] = divi;
    printf("Enter two integer numbers: ");
    scanf("%d%d", &x, &y);
    printf("Enter 0 to sum, 1 to subtract, 2 to multiply, or 3 to divide: ");
    scanf("%d", &choice);
    result = ope[choice](x, y);
    printf("%d", result);
    return 0;
}
int sum(int x, int y) { return x + y; }
int sub(int x, int y) { return x - y; }
int mult(int x, int y) { return x * y; }
int divi(int x, int y) { return y != 0 ? x / y : 0; }

Ergebnis: Eingabe 13 48 2 → 624

1. Vier arithmetische Funktionen definieren.
2. Array von vier Funktionszeigern mit passenden Signaturen erstellen.
3. Jeden Zeiger der entsprechenden Funktion zuweisen.
4. Benutzerwahl abrufen und gewählte Funktion aufrufen.

Funktionen mit Void-Zeigern

Void-Zeiger bieten typenunabhängigen Datenzugriff. In Funktionsparametern erlauben sie der Routine, jeden Datentyp zu akzeptieren, vorausgesetzt der Aufrufer liefert den korrekten Cast.

void *cube(const void *);

Beispielprogramm:

#include <stdio.h>
void* cube(const void* num);
int main() {
    int x = 4;
    int cube_int = (int)cube(&x);
    printf("%d cubed is %d\n", x, cube_int);
    return 0;
}
void* cube(const void *num) {
    int result = (*(int *)num) * (*(int *)num) * (*(int *)num);
    return (void*)result;
}

Ergebnis: 4 cubed is 64

1. Funktion definieren, die const void-Zeiger annimmt und void-Zeiger zurückgibt.
2. Zeiger zu int* casten, um Wert zuzugreifen.
3. Kubik berechnen und Ergebnis als void* zurückcasten.

Funktionszeiger als Argumente

Einen Funktionszeiger an eine andere Funktion zu übergeben, ist ein gängiges Muster für Callbacks. Die Standardbibliothek's qsort nutzt diese Technik, um Arrays beliebiger Typen zu sortieren.

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

Beispiel – Integer-Array sortieren:

#include <stdio.h>
#include <stdlib.h>
int compare(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, compare);
    for (size_t i = 0; i < num; i++) printf("%d ", arr[i]);
    return 0;
}
int compare(const void *elem1, const void *elem2) {
    int a = *(int *)elem1;
    int b = *(int *)elem2;
    return (a - b);
}

Ergebnis: 13 14 48 50 52

1. compare implementieren, um negativ, null oder positiv basierend auf zwei Integern zurückzugeben.
2. Array-Größe und Elementbreite mit sizeof bestimmen.
3. qsort mit Array, Anzahl, Breite und Vergleichsfunktion aufrufen.
4. Sortiertes Array ausgeben, um Operation zu verifizieren.