C++ Academy · Leçon

std::function

Stocker n’importe quel appelable

std::function est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que std::function ?

std::function est une enveloppe avec effacement de type qui peut contenir n'importe quel objet appelable correspondant à une signature donnée : des fonctions libres, des lambdas, des foncteurs ou des expressions liées.

Elle est déclarée avec la signature cible.
Elle se trouve dans <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;
}

Stocker une lambda

Contrairement à un pointeur de fonction brut, std::function stocke volontiers une lambda, même si celle-ci comporte des captures.

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

Stocker un foncteur

Un foncteur est un objet qui possède operator(). std::function peut l'envelopper et appeler son opérateur lorsqu'il est invoqué.

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

Réaffecter la cible

Une variable std::function peut référencer différents objets appelables pendant sa durée de vie, ce qui est utile pour remplacer le comportement lors de l'exécution.

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

std::function vide

Un objet std::function construit par défaut ne contient rien. L'appeler lève std::bad_function_call ; vérifiez donc son état au préalable.

#include <iostream>
#include <functional>

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

En tant que paramètre

Les fonctions peuvent recevoir un paramètre std::function afin d'accepter tout objet appelable correspondant, ce qui rend les interfaces de programmation flexibles.

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

Stocker des fonctions de rappel

Une utilisation courante consiste à conserver une fonction de rappel dans un membre de classe afin de pouvoir l'invoquer plus tard lorsqu'un événement se produit.

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

Un vecteur d'objets appelables

Comme ils partagent un même type, différents objets appelables peuvent coexister dans un conteneur et être invoqués tour à tour.

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

Le coût de l'effacement de type

std::function peut allouer de la mémoire et ajoute un appel indirect ; il est donc légèrement plus lent qu'un appel direct ou qu'un objet appelable basé sur un modèle. Utilisez-le lorsque vous avez besoin d'un stockage uniforme.

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

Renvoyer un std::function

Une fabrique peut créer et renvoyer un objet appelable configuré, ce qui permet aux appelants d'obtenir un comportement personnalisé.

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

Comparer aux pointeurs de fonction

std::function est plus flexible qu'un pointeur de fonction, car il stocke un état, mais cette flexibilité coûte un peu de performances et peut nécessiter une allocation.

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

Vérification rapide

Vérifiez votre compréhension de std::function.

Récapitulatif

Vous avez appris que std::function :

enveloppe tout objet appelable correspondant à sa signature, y compris les lambdas et les foncteurs possédant un état
peut être réaffecté, stocké dans des conteneurs et renvoyé par des fabriques
lève bad_function_call lorsqu'il est vide
ajoute une légère surcharge due à l'effacement de type

Vous allez maintenant utiliser std::bind pour préremplir les arguments d'objets appelables.

Questions Fréquemment Posées

La leçon « std::function » est-elle gratuite ?

Oui — le texte complet de « std::function » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « std::function » ?

Stocker n’importe quel appelable Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « std::function » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C++ Academy