std::bind
Powiąż argumenty z obiektami wywoływalnymi
std::bind to bezpłatna lekcja C++ Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C++ Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C++ Academy zawiera 4 lekcji w sumie.
Czym jest std::bind?
std::bind tworzy nowy obiekt wywoływalny przez ustalenie niektórych argumentów istniejącego obiektu. Nazywa się to częściową aplikacją.
- Jest dostępny w nagłówku
<functional>. - Zwraca obiekt wywoływalny o nieokreślonym typie.
#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;
}Symbole zastępcze
Symbole zastępcze, takie jak std::placeholders::_1, oznaczają argumenty, które zostaną dostarczone później, podczas wywoływania związanego obiektu.
#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;
}Zmiana kolejności argumentów
Symbole zastępcze mogą występować w dowolnej kolejności, co pozwala zamieniać miejscami argumenty dostarczane przez kod wywołujący.
#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;
}Wiązanie wielu argumentów
Można jednocześnie ustalić wiele argumentów, pozostawiając pozostałe jako symbole zastępcze.
#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;
}Przechowywanie wyniku
Obiekt zwrócony przez std::bind można przechować w obiekcie typu std::function, uzyskując konkretny, nazwany typ.
#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;
}Wiązanie funkcji składowych
std::bind może wskazywać funkcję składową przez przekazanie wskaźnika do funkcji składowej oraz obiektu (lub symbolu zastępczego) dla this.
#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;
}Wiązanie przez wartość a przez referencję
Argumenty wiązane są domyślnie kopiowane. Należy opakować jeden z nich w std::ref, aby związać go przez referencję i umożliwić obserwowanie zmian.
#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;
}Używanie związanych obiektów wywoływalnych w algorytmach
Związany obiekt wywoływalny może pełnić rolę predykatu lub operacji w standardowych algorytmach.
#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;
}Zagnieżdżanie bind
Wyrażenia wiązania można komponować, choć szybko stają się trudne do odczytania. Każdy symbol zastępczy nadal odnosi się do argumentów przekazanych przez końcowy kod wywołujący.
#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;
}Ignorowanie dodatkowych argumentów
Jeśli związane wywołanie używa tylko niektórych symboli zastępczych, wszelkie dodatkowe argumenty przekazane podczas wywołania są po prostu ignorowane.
#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;
}Kiedy lambda jest czytelniejsza
We współczesnym C++ często preferuje się lambdę zamiast std::bind, ponieważ jest bardziej czytelna, a kompilator lepiej ją optymalizuje.
#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;
}Szybkie sprawdzenie
Sprawdź swoją wiedzę na temat symboli zastępczych.
Podsumowanie
Dowiedziałeś się, jak działa std::bind:
- ustala niektóre argumenty i używa symboli zastępczych
_1,_2dla pozostałych - może zmieniać kolejność argumentów, wiązać funkcje składowe i używać
std::ref - wyniki można przechowywać w
std::functioni używać w algorytmach - we współczesnym C++ lambdy są często czytelniejsze
Następnie porównasz lambdy, bind i wskaźniki do funkcji, aby wybrać odpowiednie narzędzie.
Często zadawane pytania
Czy lekcja „std::bind” jest bezpłatna?
Tak — pełny tekst „std::bind” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C++ Academy, przejdź na CoddyKit PRO. Kurs C++ Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „std::bind”?
Powiąż argumenty z obiektami wywoływalnymi Ćwiczysz C++ Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć C++ Academy?
Nie wymagamy żadnego doświadczenia. C++ Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.
Ile czasu zajmuje lekcja „std::bind”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji C++ Academy?
Tak. Każda lekcja C++ Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.