C++ Academy · Lektion

std::function

Lagra valfri anropsbar funktion

Lektion 2 av 413 steg

std::function är en gratis lektion i C++ Academy på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för C++ Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C++ Academy innehåller totalt 4 lektioner.

Vad är std::function?

std::function är en typeliminerad wrapper som kan innehålla vilket anropsbart objekt som helst som matchar en given signatur: fria funktioner, lambdas, funktorer eller bundna uttryck.

Deklareras med målsignaturen.
Finns 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;
}

Lagra en lambda

Till skillnad från en vanlig funktionspekare lagrar std::function utan problem en lambda, även en lambda med capture.

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

Lagra en funktor

En funktor är ett objekt med operator(). std::function kan omsluta en sådan och anropa dess operator när objektet anropas.

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

Tilldela ett nytt mål

En och samma variabel av typen std::function kan under sin livstid hänvisa till olika anropsbara objekt, vilket är användbart när beteendet ska bytas under körning.

#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 standardkonstruerad std::function innehåller ingenting. Om Ni anropar den kastas std::bad_function_call, så kontrollera 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

Funktioner kan ta emot en parameter av typen std::function för att acceptera alla matchande anropsbara objekt, vilket gör API:er flexibla.

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

Lagra callback-funktioner

En vanlig användning är att lagra en callback-funktion i en klassmedlem, så att den kan anropas senare när en händelse inträffar.

#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 av anropsbara objekt

Eftersom de delar samma typ kan olika anropsbara objekt lagras tillsammans i en behållare och anropas efter varandra.

#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 för typeliminering

std::function kan allokera minne och lägger till ett indirekt anrop, så den är något långsammare än ett direkt anrop eller ett mallbaserat anropsbart objekt. Använd den när Ni behöver enhetlig 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;
}

Returnera en std::function

En fabrik kan skapa och returnera ett konfigurerat anropsbart objekt, så att anroparna kan få anpassat beteende.

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

Jämförelse med funktionspekare

std::function är mer flexibel än en funktionspekare eftersom den kan lagra tillstånd, men flexibiliteten kostar lite prestanda och kan medföra 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;
}

Snabbkontroll

Testa Er förståelse av std::function.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt Er att std::function:

omsluter alla anropsbara objekt som matchar dess signatur, inklusive lambdas och funktorer med tillstånd
kan tilldelas på nytt, lagras i behållare och returneras från fabriker
kastar bad_function_call när den är tom
medför en liten kostnad på grund av typeliminering

Härnäst ska Ni använda std::bind för att fylla i argument till anropsbara objekt i förväg.

Gratis att börja

Lär dig C++ med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 51
Lektioner: 203

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”std::function” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen C++ Academy, inklusive ”std::function”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i C++ Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”std::function”?

Lagra valfri anropsbar funktion Ni övar på C++ Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig C++ Academy?

Du behöver inga förkunskaper. Utbildningen i C++ Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”std::function”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här C++ Academy-lektionen?

Ja. Varje C++ Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till C++ Academy