C++ Academy · leksjon

std::function

Lagre alle kallbare objekter

Leksjon 2 av 413 trinn

std::function er en gratis leksjon i C++ Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i C++ Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i C++ Academy inneholder totalt 4 leksjoner.

Hva er std::function?

std::function er en wrapper med type-erasure som kan inneholde ethvert kallbart objekt med en gitt signatur: frie funksjoner, lambdas, funktorer eller bundne uttrykk.

Deklareres med målsignaturen.
Finnes i <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;
}

Lagre en lambda

I motsetning til en rå funksjonspeker lagrer std::function gjerne en lambda, også en som fanger variabler.

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

Lagre en funktor

En funktor er et objekt med operator(). std::function kan pakke inn en slik funktor og kalle operatoren når objektet anropes.

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

Tilordne målet på nytt

Én std::function-variabel kan inneholde forskjellige kallbare objekter i løpet av levetiden. Dette er nyttig når du vil bytte atferd under kjøring.

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

Tom std::function

En std::function som er opprettet med standardkonstruktøren, inneholder ingenting. Hvis du kaller den, kastes std::bad_function_call, så kontroller den først.

#include <iostream>
#include <functional>

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

Som parameter

Funksjoner kan ta imot en std::function-parameter for å godta alle kallbare objekter med riktig signatur, noe som gjør API-er fleksible.

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

Lagre callback-funksjoner

Et vanlig bruksområde er å lagre en callback i et klassemedlem, slik at den kan kalles senere når en hendelse oppstår.

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

En vektor med kallbare objekter

Fordi de har samme type, kan forskjellige kallbare objekter lagres sammen i en container og kalles etter tur.

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

Kostnaden ved type-erasure

std::function kan allokere minne og medfører et indirekte kall, så den er litt tregere enn et direkte kall eller et kallbart objekt via en mal. Bruk den når du trenger ensartet lagring.

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

Returnere en std::function

En fabrikkfunksjon kan opprette og returnere et konfigurert kallbart objekt, slik at den som kaller funksjonen, får tilpasset atferd.

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

Sammenlignet med funksjonspekere

std::function er mer fleksibel enn en funksjonspeker fordi den kan lagre tilstand, men denne fleksibiliteten koster litt ytelse og kan medføre en allokering.

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

Hurtigsjekk

Test forståelsen din av std::function.

Besvar den i den interaktive leksjonen

Oppsummering

Du har lært at std::function:

pakker inn alle kallbare objekter som samsvarer med signaturen, inkludert lambdas og funktorer med tilstand
kan tilordnes på nytt, lagres i containere og returneres fra fabrikkfunksjoner
kaster bad_function_call når den er tom
medfører litt overhead på grunn av type-erasure

Deretter skal du bruke std::bind til å forhåndsutfylle argumenter for kallbare objekter.

Gratis å komme i gang

Lær deg C++ med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 51
Leksjoner: 203

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «std::function» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien C++ Academy, inkludert «std::function», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i C++ Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «std::function»?

Lagre alle kallbare objekter Du øver på C++ Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med C++ Academy?

Ingen tidligere erfaring er nødvendig. C++ Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «std::function»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne C++ Academy-leksjonen?

Ja. Alle C++ Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til C++ Academy