Anhang H

Funktionszeiger

In einem Funktionszeiger können, wie unschwer zu erraten ist, Adressen von Funktionen abgelegt werden.

Definition eines Funktionszeigers

Die Definition eines Funktionszeigers gleicht prinzipiell der Deklaration einer Funktion. Anstelle des Funktionsnamens wird nun aber innerhalb einer Klammer der Name des Funktionszeigers angegeben. Damit kann ein Funktionszeiger auch nur Adressen von Funktionen aufnehmen, die im Returntyp und in den Parametern mit der Zeigerdefinition übereinstimmen.

// Zeiger auf Funktionen vom Typ: void Func();
void (*pfnFunc1)()
// Zeiger auf Funktionen vom Typ: short Func(short, char*)
short (*pfnFunc2)(short, char*);

Bilden einer Funktionsadresse

Nachdem der Funktionszeiger definiert ist, kann ihm die Adresse einer entsprechenden Funktion zugewiesen werden. Um die Adresse einer Funktion zu erhalten, wird nur der Name der Funktion angegeben, d.h., es steht hier kein Adressoperator &.

// Funktionsdeklarationen
void DoSomething();
short DoAnything(short, char*);
// Zeigerdefinition und Initialisierung
void (*pfnFunc1)() = DoSomething;
short (*pfnFunc2)(short, char*) = DoAnything;

Steht die Funktionsdeklaration vor der Definition des Funktionszeigers, kann der Funktionszeiger auch mithilfe von decltype() definiert werden, was die Lesbarkeit und Wartbarkeit des Codes deutlich erhöht.

// Funktionsdeklarationen
void DoSomething();
short DoAnything(short, char*);
// Zeigerdefinition und Initialisierung
decltype(DoSomething) *pfnFunc1 = DoSomething;
decltype(DoAnything) *pfnFunc2 = DoAnything;

Funktionsaufruf über Funktionszeiger

Bleibt zum Schluss die Frage, wie die Funktion aufgerufen wird, deren Adresse im Zeiger abgelegt ist. Wie bekannt sein sollte, erfolgt der Zugriff auf Speicherstellen über Zeiger mit dem Dereferenzierungsoperator *. Und genauso funktioniert der Aufruf von Funktionen über Funktionszeiger, nur muss der dereferenzierte Funktionszeiger jetzt innerhalb einer Klammer stehen. Erhält die aufzurufende Funktion Parameter, sind diese, wie bei einem normalen Funktionsaufruf, in einer weiteren Klammer anzugeben.

// Zeigerdefinition
void (*pfnFunc1)();
short (*pfnFunc2)(short, char*);
...
// Funktionsaufrufe
(*pfnFunc1)();
short nErg = (*pfnFunc2)(var, text);

Beispiel:

Das Beispiel demonstriert den Einsatz eines Funktionszeigers anhand einer sehr einfachen Zustandsmaschine. Bei einer Zustandsmaschine wird in Abhängigkeit vom aktuellen Zustand der nachfolgende Zustand bestimmt. D.h., nur der aktuelle Zustand kennt seine möglichen Nachfolge-Zustände.

Im Beispiel besteht die Zustandsmaschine aus den drei 'Zuständen' State1(), State2() und State3(). Diese Zustände werden nacheinander über den Zeiger pfnState aufgerufen. Dazu wird zunächst in main() der Zeiger auf die erste aufzurufende Funktion State1() gesetzt. In der nachfolgenden while-Schleife wird dann so lange die im Zeiger abgelegte Funktion aufgerufen, bis der Zeiger einen nullptr enthält. Welche Funktion in der while-Schleife aufgerufen wird, wird durch die aktuell ausgeführte Funktion festgelegt. So lädt z.B. State1() als nächste auszuführende Funktion die Adresse der Funktion State2() in den Funktionszeiger. Die Funktion State3() veranlasst schließlich den Abbruch der while-Schleife, in dem abhängig von einer Bedingung dem Zeiger ein nullptr zugewiesen wird.

#include <print>

// Deklaration der Zustandsfunktionen
void State1();
void State2();
void State3();

// Funktionszeiger definieren
decltype(State1)* pfnState;

int main()
{
    // Funktionszeiger auf 1. Zustand
    pfnState = State1;

    // Nun alle Zustände durchlaufen
    do
    {
        // Zustandsfunktion aufrufen
        (*pfnState)();
    } while (pfnState != nullptr);
}

// Funktion für Zustand 1
void State1()
{
    std::println("Zustand 1");
    // Nächsten Zustand im Funktionszeiger ablegen
    pfnState = State2;
}
// Funktion für Zustand 2
void State2()
{
    std::println("Zustand 2");
    // Nächsten Zustand im Funktionszeiger ablegen
    pfnState = State3;
}
// Funktion für Zustand 3
void State3()
{
    // Statische Datum fuer Abbruch der Zustandsmaschine
    static int count = 0;

    std::println("Zustand 3");
    // Wenn Funktion zum ersten Mal aufgerufen dann
    // einen weiteren Durchlauf
    // Ansonsten Zustandsmaschine beenden
    if (count == 0)
        pfnState = State1;
    else
        pfnState = nullptr;
    count++;
}

Zustand 1
Zustand 2
Zustand 3
Zustand 1
Zustand 2
Zustand 3