C++ Academy · Les

Functieaanwijzers

Geef functies door als argumenten

Les 1 van 413 stappen

Functieaanwijzers is een gratis C++ Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C++ Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C++ Academy bevat in totaal 4 lessen.

Wat is een functiepointer?

Een functiepointer slaat het adres van een functie op, zodat je die indirect kunt aanroepen of als gegevens kunt doorgeven.

Het type legt de signatuur vast.
Functies kunnen hiermee gedrag als parameter aannemen.

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

Het type declareren

De declaratie int (*op)(int, int) lees je als volgt: op is een pointer naar een functie die twee ints accepteert en een int retourneert. De haakjes rond *op zijn vereist.

#include <iostream>

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

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

Aanroepen via een pointer

Je roept een functiepointer net zo aan als de functie zelf. Je kunt de pointer ook expliciet derefereren, maar dat is zelden nodig.

#include <iostream>

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

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

Functies als argumenten doorgeven

Een functie kan een functiepointer als parameter accepteren, zodat de aanroeper aangepast gedrag kan invoegen.

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

Tijdens uitvoering kiezen

Omdat een functiepointer een variabele is, kun je tijdens het uitvoeren van het programma bepalen welke functie wordt aangeroepen.

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

Arrays met functiepointers

Sla meerdere functiepointers op in een array om een eenvoudige dispatchtabel te maken die met een waarde wordt geïndexeerd.

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

Een typedef gebruiken

De syntaxis van pointers is omslachtig. Met een alias via typedef of using geef je het type een leesbare naam.

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

Functiepointers met algoritmen

Standaardalgoritmen accepteren aanroepbare objecten, en een gewone functie werkt als zo'n object. Hier telt een predicaat de even getallen.

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

Beperking: geen status

Een gewone functiepointer kan geen vastgelegde gegevens bevatten. Als je context tussen aanroepen wilt onthouden, moet je globale variabelen gebruiken of overstappen op uitgebreidere aanroepbare objecten.

#include <iostream>

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

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

Lambdas zonder vastlegging kunnen worden omgezet

Een lambda die niets vastlegt, kan impliciet worden omgezet naar een overeenkomende functiepointer. Dat is handig voor kleine inlinefuncties.

#include <iostream>

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

Null-functiepointers

Een functiepointer kan nullptr zijn, wat betekent dat hij nergens naartoe wijst. Controleer dit altijd voordat je hem aanroept om ongedefinieerd gedrag te voorkomen.

#include <iostream>

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

Korte toets

Toets je begrip van de beperkingen van functiepointers.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt geleerd over functiepointers:

ze bevatten het adres van een functie en worden net als de functie aangeroepen
ze laten je gedrag als parameter doorgeven en dispatchtabellen bouwen
aliassen maken hun type leesbaar
ze kunnen geen status bevatten, maar lambdas zonder vastlegging kunnen naar functiepointers worden omgezet

Vervolgens maak je kennis met std::function, waarin elk aanroepbaar object kan worden opgeslagen, ook objecten met status.

Gratis beginnen

Leer C++ met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 51
Lessen: 203

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Functieaanwijzers” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad C++ Academy, waaronder “Functieaanwijzers”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus C++ Academy bevat in totaal 4 lessen.

Wat leer ik in “Functieaanwijzers”?

Geef functies door als argumenten Je oefent met C++ Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C++ Academy te beginnen?

Ervaring vooraf is niet nodig. C++ Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Functieaanwijzers”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C++ Academy?

Ja. Elke les over C++ Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar C++ Academy