C++ Academy · Lektion

std::bind

Bind argumenter til callables

Lektion 3 af 413 trin

std::bind er en gratis C++ Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i C++ Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. C++ Academy-kurset indeholder 4 lektioner i alt.

Hvad er std::bind

std::bind opretter en ny kaldbar enhed ved at fastlåse nogle argumenter for en eksisterende enhed. Det kaldes delvis anvendelse.

Findes i <functional>.
Returnerer et kaldbart objekt med uspecificeret type.

#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;
}

Pladsholdere

Pladsholdere som std::placeholders::_1 markerer argumenter, der skal leveres senere, når det bundne objekt kaldes.

#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;
}

Omordning af argumenter

Pladsholdere kan stå i vilkårlig rækkefølge, så du kan bytte om på placeringerne af de argumenter, som den kaldende kode leverer.

#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;
}

Binding af flere argumenter

Du kan fastlåse flere argumenter på én gang og lade andre være pladsholdere.

#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;
}

Lagring af resultatet

Objektet, som std::bind returnerer, kan gemmes i en std::function med en konkret navngiven type.

#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;
}

Binding af medlemsfunktioner

std::bind kan målrettes en medlemsfunktion ved at videregive medlemspegeren og et objekt eller en pladsholder for 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;
}

Binding efter værdi eller reference

Bundne argumenter kopieres som standard. Pak et argument ind i std::ref for at binde det efter reference, så ændringer bliver synlige.

#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;
}

Brug af bundne kaldbare enheder i algoritmer

En bunden kaldbar enhed fungerer som et prædikat eller en operation i standardalgoritmer.

#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;
}

Indlejring af bind

Bind-udtryk kan sammensættes, men de bliver hurtigt svære at læse. Hver pladsholder henviser stadig til den endelige kaldendes argumenter.

#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;
}

Ignorering af ekstra argumenter

Hvis det bundne kald kun bruger nogle af pladsholderne, ignoreres eventuelle ekstra argumenter, der videregives på kaldstidspunktet, ganske enkelt.

#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;
}

Når en lambda er tydeligere

Moderne C++ foretrækker ofte en lambda frem for std::bind, fordi den er mere læsbar, og compileren optimerer den bedre.

#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;
}

Hurtig kontrol

Afprøv din forståelse af pladsholdere.

Besvar den i den interaktive lektion

Opsummering

Du har lært, hvordan std::bind fungerer:

fastlåser nogle argumenter og bruger pladsholderne _1, _2 til resten
kan omordne argumenter, binde medlemsfunktioner og bruge std::ref
resultater kan gemmes i std::function og bruges i algoritmer
lambdafunktioner er ofte tydeligere i moderne C++

Nu sammenligner du lambdafunktioner, bind og funktionspegere for at vælge det rigtige værktøj.

Gratis at komme i gang

Lær C++ med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 51
Lektioner: 203

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “std::bind” gratis?

Ja — alle 3 lektioner i læringssporet C++ Academy, inklusive “std::bind”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. C++ Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “std::bind”?

Bind argumenter til callables Du øver dig i C++ Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på C++ Academy?

Der kræves ingen tidligere erfaring. C++ Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “std::bind”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne C++ Academy-lektion?

Ja. Alle C++ Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til C++ Academy