C++ Academy · Lektion

std::function

Beliebige aufrufbare Objekte speichern

std::function ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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 std::function?

std::function ist ein Wrapper mit ausgelöschtem Typ, der jedes aufrufbare Objekt mit einer passenden Signatur aufnehmen kann: freie Funktionen, Lambdas, Funktoren oder gebundene Ausdrücke.

Wird mit der Zielsignatur deklariert.
Befindet sich in <functional>.

#include <iostream>
#include <functional>

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

int main() {
    std::function<int(int, int)> f = add;
    std::cout << f(2, 3) << '\n';
    return 0;
}

Ein Lambda speichern

Im Gegensatz zu einem einfachen Funktionszeiger speichert std::function problemlos ein Lambda, auch eines mit Erfassungen.

#include <iostream>
#include <functional>

int main() {
    int offset = 10;
    std::function<int(int)> f = [offset](int x) { return x + offset; };
    std::cout << f(5) << '\n';
    return 0;
}

Einen Funktor speichern

Ein Funktor ist ein Objekt mit operator(). std::function kann einen solchen verpacken und beim Aufruf dessen Operator ausführen.

#include <iostream>
#include <functional>

struct Multiplier {
    int factor;
    int operator()(int x) const { return x * factor; }
};

int main() {
    std::function<int(int)> f = Multiplier{3};
    std::cout << f(4) << '\n';
    return 0;
}

Das Ziel neu zuweisen

Eine Variable vom Typ std::function kann während ihrer Lebensdauer auf verschiedene aufrufbare Objekte verweisen. Das ist nützlich, um Verhalten zur Laufzeit auszutauschen.

#include <iostream>
#include <functional>

int main() {
    std::function<int(int)> f = [](int x) { return x + 1; };
    std::cout << f(10) << '\n';
    f = [](int x) { return x * x; };
    std::cout << f(10) << '\n';
    return 0;
}

Leere std::function

Eine standardmäßig konstruierte std::function enthält nichts. Ihr Aufruf löst std::bad_function_call aus. Prüfen Sie sie daher vorher.

#include <iostream>
#include <functional>

int main() {
    std::function<void()> f;
    if (f) {
        f();
    } else {
        std::cout << "empty\n";
    }
    return 0;
}

Als Parameter

Funktionen können einen std::function-Parameter entgegennehmen, um jedes passende aufrufbare Objekt zu akzeptieren, wodurch APIs flexibel werden.

#include <iostream>
#include <functional>

void repeat(int n, const std::function<void(int)>& action) {
    for (int i = 0; i < n; ++i) action(i);
}

int main() {
    repeat(3, [](int i) { std::cout << "step " << i << '\n'; });
    return 0;
}

Callbacks speichern

Eine häufige Verwendung besteht darin, einen Callback als Klassenmember zu speichern, damit er später beim Eintreten eines Ereignisses aufgerufen werden kann.

#include <iostream>
#include <functional>

struct Button {
    std::function<void()> onClick;
    void click() { if (onClick) onClick(); }
};

int main() {
    Button b;
    b.onClick = [] { std::cout << "clicked!\n"; };
    b.click();
    return 0;
}

Ein Vektor aufrufbarer Objekte

Da sie denselben Typ haben, können verschiedene aufrufbare Objekte gemeinsam in einem Container gespeichert und nacheinander aufgerufen werden.

#include <iostream>
#include <functional>
#include <vector>

int inc(int x) { return x + 1; }

int main() {
    std::vector<std::function<int(int)>> ops;
    ops.push_back(inc);
    ops.push_back([](int x) { return x * 2; });
    for (auto& op : ops) std::cout << op(10) << ' ';
    std::cout << '\n';
    return 0;
}

Die Kosten der Typlöschung

std::function kann Speicher reservieren und fügt einen indirekten Aufruf hinzu. Daher ist sie etwas langsamer als ein direkter Aufruf oder ein aufrufbares Objekt aus einem Template. Verwenden Sie sie, wenn Sie eine einheitliche Speicherung benötigen.

#include <iostream>
#include <functional>

int main() {
    std::function<int()> f = [] { return 42; };
    int total = 0;
    for (int i = 0; i < 5; ++i) total += f();
    std::cout << total << '\n';
    return 0;
}

Eine std::function zurückgeben

Eine Factory kann ein konfiguriertes aufrufbares Objekt erstellen und zurückgeben, sodass Aufrufer angepasstes Verhalten erhalten.

#include <iostream>
#include <functional>

std::function<int(int)> adder(int n) {
    return [n](int x) { return x + n; };
}

int main() {
    auto add5 = adder(5);
    std::cout << add5(10) << '\n';
    return 0;
}

Vergleich mit Funktionszeigern

std::function ist flexibler als ein Funktionszeiger, weil es Zustand speichern kann. Diese Flexibilität kostet jedoch etwas Leistung und möglicherweise eine Speicherreservierung.

#include <iostream>
#include <functional>

int main() {
    int base = 7;
    std::function<int(int)> stateful = [base](int x) { return x + base; };
    std::cout << "Stateful result: " << stateful(3) << '\n';
    return 0;
}

Schnelltest

Testen Sie Ihr Verständnis von std::function.

Zusammenfassung

Sie haben gelernt, dass std::function:

jedes aufrufbare Objekt verpackt, das zu seiner Signatur passt, einschließlich zustandsbehafteter Lambdas und Funktoren
neu zugewiesen, in Containern gespeichert und von Factorys zurückgegeben werden kann
bei einer leeren Instanz bad_function_call auslöst
durch die Typlöschung einen geringen zusätzlichen Aufwand verursacht

Als Nächstes verwenden Sie std::bind, um Argumente aufrufbarer Objekte vorab zu belegen.

Häufig gestellte Fragen

Ist die Lektion „std::function“ kostenlos?

Ja — der vollständige Text von „std::function“ 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 „std::function“?

Beliebige aufrufbare Objekte speichern 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 2 von 4.

Wie lange dauert die Lektion „std::function“?

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