C++ Academy · Lektion

Funktionszeiger

Funktionen als Argumente übergeben

Funktionszeiger ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist ein Funktionszeiger?

Ein Funktionszeiger speichert die Adresse einer Funktion, sodass Sie sie indirekt aufrufen oder wie Daten weitergeben können.

Der Typ beschreibt die Signatur.
Dadurch können Funktionen Verhalten als Parameter entgegennehmen.

#include <iostream>

int add(int a, int b) { return a + b; }

int main() {
    int (*op)(int, int) = add;
    std::cout << op(3, 4) << '\n';
    return 0;
}

Den Typ deklarieren

Die Deklaration int (*op)(int, int) bedeutet: op ist ein Zeiger auf eine Funktion, die zwei int-Werte entgegennimmt und einen int-Wert zurückgibt. Die Klammern um *op sind erforderlich.

#include <iostream>

int square(int x) { return x * x; }

int main() {
    int (*fn)(int) = square;
    std::cout << fn(5) << '\n';
    return 0;
}

Aufruf über einen Zeiger

Sie rufen einen Funktionszeiger genauso auf wie die Funktion selbst. Sie können ihn auch explizit dereferenzieren, aber das ist nur selten erforderlich.

#include <iostream>

void greet() { std::cout << "Hello\n"; }

int main() {
    void (*g)() = greet;
    g();
    (*g)();
    return 0;
}

Funktionen als Argumente übergeben

Eine Funktion kann einen Funktionszeiger als Parameter akzeptieren, sodass der Aufrufer eigenes Verhalten einsetzen kann.

#include <iostream>

int apply(int x, int (*fn)(int)) { return fn(x); }
int doubler(int n) { return n * 2; }

int main() {
    std::cout << apply(10, doubler) << '\n';
    return 0;
}

Zur Laufzeit auswählen

Da ein Funktionszeiger eine Variable ist, können Sie während der Programmausführung entscheiden, welche Funktion aufgerufen werden soll.

#include <iostream>

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }

int main() {
    bool wantAdd = true;
    int (*op)(int, int) = wantAdd ? add : sub;
    std::cout << op(8, 3) << '\n';
    return 0;
}

Arrays von Funktionszeigern

Speichern Sie mehrere Funktionszeiger in einem Array, um eine einfache Dispatch-Tabelle zu erstellen, auf die über einen Wert zugegriffen wird.

#include <iostream>

int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }

int main() {
    int (*ops[2])(int, int) = {add, mul};
    std::cout << ops[0](2, 3) << ' ' << ops[1](2, 3) << '\n';
    return 0;
}

Ein typedef verwenden

Die Syntax von Zeigern ist schwer lesbar. Ein typedef- oder using-Alias gibt dem Typ einen verständlichen Namen.

#include <iostream>

using BinOp = int(*)(int, int);
int add(int a, int b) { return a + b; }

int main() {
    BinOp op = add;
    std::cout << op(6, 7) << '\n';
    return 0;
}

Funktionszeiger mit Algorithmen

Standardalgorithmen akzeptieren aufrufbare Objekte, und eine gewöhnliche Funktion kann als solches verwendet werden. Hier zählt ein Prädikat gerade Zahlen.

#include <iostream>
#include <vector>
#include <algorithm>

bool isEven(int n) { return n % 2 == 0; }

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5, 6};
    int c = std::count_if(v.begin(), v.end(), isEven);
    std::cout << "Evens: " << c << '\n';
    return 0;
}

Einschränkung: kein Zustand

Ein gewöhnlicher Funktionszeiger kann keine erfassten Daten mitführen. Wenn Sie zwischen Aufrufen einen Kontext bewahren müssen, benötigen Sie globale Variablen oder müssen auf leistungsfähigere aufrufbare Objekte ausweichen.

#include <iostream>

int counter = 0;
int next() { return ++counter; }

int main() {
    int (*fn)() = next;
    std::cout << fn() << ' ' << fn() << ' ' << fn() << '\n';
    return 0;
}

Lambdas ohne Erfassung werden konvertiert

Ein Lambda, das nichts erfasst, kann implizit in einen passenden Funktionszeiger konvertiert werden. Das ist praktisch für kleine Inline-Funktionen.

#include <iostream>

int main() {
    int (*fn)(int) = [](int x) { return x + 100; };
    std::cout << fn(1) << '\n';
    return 0;
}

Null-Funktionszeiger

Ein Funktionszeiger kann nullptr sein, das heißt, er zeigt auf nichts. Prüfen Sie ihn vor dem Aufruf immer, um undefiniertes Verhalten zu vermeiden.

#include <iostream>

int main() {
    int (*fn)(int) = nullptr;
    if (fn) {
        std::cout << fn(5) << '\n';
    } else {
        std::cout << "No function set\n";
    }
    return 0;
}

Schnelltest

Testen Sie Ihr Verständnis der Einschränkungen von Funktionszeigern.

Zusammenfassung

Sie haben Funktionszeiger kennengelernt:

Sie enthalten die Adresse einer Funktion und werden wie die Funktion aufgerufen.
Sie ermöglichen es, Verhalten als Parameter zu übergeben und Dispatch-Tabellen zu erstellen.
Aliase machen ihren Typ verständlich.
Sie können keinen Zustand mitführen, aber Lambdas ohne Erfassung werden in sie konvertiert.

Als Nächstes lernen Sie std::function kennen, das jedes aufrufbare Objekt einschließlich solcher mit Zustand speichern kann.

Häufig gestellte Fragen

Ist die Lektion „Funktionszeiger“ kostenlos?

Ja — der vollständige Text von „Funktionszeiger“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Funktionszeiger“?

Funktionen als Argumente übergeben Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C++ Academy zu starten?

Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Funktionszeiger“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?

Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C++ Academy