C++ Academy · Lektion

Funktionspekare

Skicka funktioner som argument

Lektion 1 av 413 steg

Funktionspekare är en gratis lektion i C++ Academy på CoddyKit. Detta är lektion 1 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 en funktionspekare?

En funktionspekare lagrar adressen till en funktion, så att Ni kan anropa den indirekt eller skicka runt den som data.

Typen kodar signaturen.
Den gör det möjligt för funktioner att ta emot beteende som parameter.

#include <iostream>

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

int main() {
    int (*op)(int, int) = add;
    std::cout << op(3, 4) << '\n';
    return 0;
}

Deklarera typen

Deklarationen int (*op)(int, int) utläses så här: op är en pekare till en funktion som tar emot två heltal och returnerar ett heltal. Parenteserna runt *op krävs.

#include <iostream>

int square(int x) { return x * x; }

int main() {
    int (*fn)(int) = square;
    std::cout << fn(5) << '\n';
    return 0;
}

Anropa via en pekare

Ni anropar en funktionspekare på samma sätt som själva funktionen. Ni kan också dereferera den uttryckligen, men det behövs sällan.

#include <iostream>

void greet() { std::cout << "Hello\n"; }

int main() {
    void (*g)() = greet;
    g();
    (*g)();
    return 0;
}

Skicka funktioner som argument

En funktion kan ta emot en parameter av typen funktionspekare, så att anroparen kan koppla in anpassat beteende.

#include <iostream>

int apply(int x, int (*fn)(int)) { return fn(x); }
int doubler(int n) { return n * 2; }

int main() {
    std::cout << apply(10, doubler) << '\n';
    return 0;
}

Välj under körning

Eftersom en funktionspekare är en variabel kan Ni bestämma vilken funktion som ska anropas medan programmet körs.

#include <iostream>

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

int main() {
    bool wantAdd = true;
    int (*op)(int, int) = wantAdd ? add : sub;
    std::cout << op(8, 3) << '\n';
    return 0;
}

Arrayer med funktionspekare

Lagra flera funktionspekare i en array för att skapa en enkel dispatch-tabell som indexeras med ett värde.

#include <iostream>

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

int main() {
    int (*ops[2])(int, int) = {add, mul};
    std::cout << ops[0](2, 3) << ' ' << ops[1](2, 3) << '\n';
    return 0;
}

Använda en typedef

Pekarsyntaxen är omständlig. Ett alias med typedef eller using ger typen ett lättläst namn.

#include <iostream>

using BinOp = int(*)(int, int);
int add(int a, int b) { return a + b; }

int main() {
    BinOp op = add;
    std::cout << op(6, 7) << '\n';
    return 0;
}

Funktionspekare med algoritmer

Standardalgoritmer accepterar anropsbara objekt, och en vanlig funktion fungerar som ett sådant. Här räknar ett predikat de jämna talen.

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

bool isEven(int n) { return n % 2 == 0; }

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5, 6};
    int c = std::count_if(v.begin(), v.end(), isEven);
    std::cout << "Evens: " << c << '\n';
    return 0;
}

Begränsning: inget tillstånd

En vanlig funktionspekare kan inte bära med sig infångade data. Om Ni behöver komma ihåg kontext mellan anrop måste Ni använda globala variabler eller gå över till mer avancerade anropsbara objekt.

#include <iostream>

int counter = 0;
int next() { return ++counter; }

int main() {
    int (*fn)() = next;
    std::cout << fn() << ' ' << fn() << ' ' << fn() << '\n';
    return 0;
}

Lambdas utan capture konverteras

En lambda som inte fångar något kan implicit konverteras till en matchande funktionspekare, vilket är praktiskt för små funktioner direkt i koden.

#include <iostream>

int main() {
    int (*fn)(int) = [](int x) { return x + 100; };
    std::cout << fn(1) << '\n';
    return 0;
}

Nullade funktionspekare

En funktionspekare kan vara nullptr, vilket betyder att den inte pekar på något. Kontrollera alltid pekaren innan Ni anropar den för att undvika odefinierat beteende.

#include <iostream>

int main() {
    int (*fn)(int) = nullptr;
    if (fn) {
        std::cout << fn(5) << '\n';
    } else {
        std::cout << "No function set\n";
    }
    return 0;
}

Snabbkontroll

Testa Er förståelse av funktionspekarnas begränsningar.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt Er om funktionspekare:

de innehåller adressen till en funktion och anropas som funktionen
de gör det möjligt att skicka beteende som parameter och bygga dispatch-tabeller
alias gör deras typ lättläst
de kan inte bära tillstånd, men lambdas utan capture kan konverteras till dem

Härnäst får Ni lära Er om std::function, som kan lagra alla anropsbara objekt, även sådana med tillstånd.

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 ”Funktionspekare” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen C++ Academy, inklusive ”Funktionspekare”, 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 ”Funktionspekare”?

Skicka funktioner som argument 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 1 av 4.

Hur lång tid tar lektionen ”Funktionspekare”?

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