C++ Academy · Lektion

std::bind

Argumente an aufrufbare Objekte binden

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

std::bind erstellt ein neues aufrufbares Objekt, indem es einige Argumente eines vorhandenen Objekts festlegt. Dies wird partielle Anwendung genannt.

Befindet sich in <functional>.
Gibt ein nicht näher spezifiziertes aufrufbares Objekt zurück.

#include <iostream>
#include <functional>

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

int main() {
    auto add10 = std::bind(add, 10, 5);
    std::cout << add10() << '\n';
    return 0;
}

Platzhalter

Platzhalter wie std::placeholders::_1 markieren Argumente, die später beim Aufruf des gebundenen Objekts bereitgestellt werden.

#include <iostream>
#include <functional>

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

int main() {
    using namespace std::placeholders;
    auto add10 = std::bind(add, 10, _1);
    std::cout << add10(7) << '\n';
    return 0;
}

Argumente neu anordnen

Platzhalter können in beliebiger Reihenfolge auftreten. Dadurch können Sie die Positionen der vom Aufrufer übergebenen Argumente vertauschen.

#include <iostream>
#include <functional>

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

int main() {
    using namespace std::placeholders;
    auto flipped = std::bind(sub, _2, _1);
    std::cout << flipped(3, 10) << '\n';
    return 0;
}

Mehrere Argumente binden

Sie können mehrere Argumente gleichzeitig festlegen und die übrigen als Platzhalter offenlassen.

#include <iostream>
#include <functional>

int volume(int l, int w, int h) { return l * w * h; }

int main() {
    using namespace std::placeholders;
    auto box = std::bind(volume, 2, _1, 5);
    std::cout << box(3) << '\n';
    return 0;
}

Das Ergebnis speichern

Das von std::bind zurückgegebene Objekt kann in einer std::function gespeichert werden, um einen konkreten, benannten Typ zu erhalten.

#include <iostream>
#include <functional>

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

int main() {
    using namespace std::placeholders;
    std::function<int(int)> add100 = std::bind(add, 100, _1);
    std::cout << add100(1) << '\n';
    return 0;
}

Memberfunktionen binden

std::bind kann eine Memberfunktion als Ziel verwenden, indem der Memberzeiger und ein Objekt (oder ein Platzhalter) für this übergeben werden.

#include <iostream>
#include <functional>

struct Counter {
    int add(int x) { return value += x; }
    int value = 0;
};

int main() {
    using namespace std::placeholders;
    Counter c;
    auto bump = std::bind(&Counter::add, &c, _1);
    std::cout << bump(5) << ' ' << bump(3) << '\n';
    return 0;
}

Binden per Wert oder Referenz

Gebundene Argumente werden standardmäßig kopiert. Verpacken Sie eines davon in std::ref, um es per Referenz zu binden, sodass Änderungen sichtbar sind.

#include <iostream>
#include <functional>

void addTo(int& target, int amount) { target += amount; }

int main() {
    using namespace std::placeholders;
    int total = 0;
    auto acc = std::bind(addTo, std::ref(total), _1);
    acc(5);
    acc(10);
    std::cout << total << '\n';
    return 0;
}

Gebundene aufrufbare Objekte in Algorithmen verwenden

Ein gebundenes aufrufbares Objekt kann in Standardalgorithmen als Prädikat oder Operation verwendet werden.

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

bool greaterThan(int x, int limit) { return x > limit; }

int main() {
    using namespace std::placeholders;
    std::vector<int> v = {1, 5, 8, 2, 9};
    auto over4 = std::bind(greaterThan, _1, 4);
    std::cout << std::count_if(v.begin(), v.end(), over4) << '\n';
    return 0;
}

Bind verschachteln

Bind-Ausdrücke können miteinander kombiniert werden, werden dadurch aber schnell schwer lesbar. Jeder Platzhalter bezieht sich weiterhin auf die Argumente des endgültigen Aufrufers.

#include <iostream>
#include <functional>

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

int main() {
    using namespace std::placeholders;
    auto f = std::bind(add, std::bind(times, 2, _1), 3);
    std::cout << f(5) << '\n';
    return 0;
}

Zusätzliche Argumente ignorieren

Wenn der gebundene Aufruf nur einige Platzhalter verwendet, werden zusätzliche Argumente, die beim Aufruf übergeben werden, einfach ignoriert.

#include <iostream>
#include <functional>

int show(int a) { return a; }

int main() {
    using namespace std::placeholders;
    auto f = std::bind(show, _1);
    std::cout << f(42, 99, 100) << '\n';
    return 0;
}

Wann ein Lambda verständlicher ist

Modernes C++ bevorzugt häufig ein Lambda gegenüber std::bind, weil es besser lesbar ist und der Compiler es besser optimieren kann.

#include <iostream>
#include <functional>

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

int main() {
    auto add10 = [](int x) { return add(10, x); };
    std::cout << add10(5) << '\n';
    return 0;
}

Schnelltest

Testen Sie Ihr Verständnis von Platzhaltern.

Zusammenfassung

Sie haben gelernt, wie std::bind funktioniert:

Es legt einige Argumente fest und verwendet Platzhalter wie _1 und _2 für die übrigen.
Es kann Argumente neu anordnen, Memberfunktionen binden und std::ref verwenden.
Ergebnisse können in std::function gespeichert und in Algorithmen verwendet werden.
Lambdas sind in modernem C++ oft verständlicher.

Als Nächstes vergleichen Sie Lambdas, Bind und Funktionszeiger, um das passende Werkzeug auszuwählen.

Häufig gestellte Fragen

Ist die Lektion „std::bind“ kostenlos?

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

Argumente an aufrufbare Objekte binden 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 3 von 4.

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

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