C++ Academy · Leçon

std::bind

Lier des arguments à des appelables

std::bind est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 3 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::bind ?

std::bind crée un nouvel objet appelable en fixant certains arguments d'un objet existant. C'est ce qu'on appelle l'application partielle.

Il se trouve dans <functional>.
Il renvoie un objet appelable dont le type n'est pas spécifié.

#include <iostream>
#include <functional>

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

int main() {
    auto add10 = std::bind(add, 10, 5);
    std::cout << add10() << '\n';
    return 0;
}

Espaces réservés

Des espaces réservés comme std::placeholders::_1 indiquent les arguments qui seront fournis ultérieurement, lorsque l'objet lié sera appelé.

#include <iostream>
#include <functional>

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

int main() {
    using namespace std::placeholders;
    auto add10 = std::bind(add, 10, _1);
    std::cout << add10(7) << '\n';
    return 0;
}

Réordonner les arguments

Les espaces réservés peuvent apparaître dans n'importe quel ordre, ce qui vous permet d'échanger les positions des arguments fournis par l'appelant.

#include <iostream>
#include <functional>

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

int main() {
    using namespace std::placeholders;
    auto flipped = std::bind(sub, _2, _1);
    std::cout << flipped(3, 10) << '\n';
    return 0;
}

Fixer plusieurs arguments

Vous pouvez fixer plusieurs arguments à la fois tout en laissant les autres sous forme d'espaces réservés.

#include <iostream>
#include <functional>

int volume(int l, int w, int h) { return l * w * h; }

int main() {
    using namespace std::placeholders;
    auto box = std::bind(volume, 2, _1, 5);
    std::cout << box(3) << '\n';
    return 0;
}

Stocker le résultat

L'objet renvoyé par std::bind peut être stocké dans un std::function pour obtenir un type concret et nommé.

#include <iostream>
#include <functional>

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

int main() {
    using namespace std::placeholders;
    std::function<int(int)> add100 = std::bind(add, 100, _1);
    std::cout << add100(1) << '\n';
    return 0;
}

Lier des fonctions membres

std::bind peut cibler une fonction membre en recevant le pointeur de membre et un objet (ou un espace réservé) pour this.

#include <iostream>
#include <functional>

struct Counter {
    int add(int x) { return value += x; }
    int value = 0;
};

int main() {
    using namespace std::placeholders;
    Counter c;
    auto bump = std::bind(&Counter::add, &c, _1);
    std::cout << bump(5) << ' ' << bump(3) << '\n';
    return 0;
}

Lier par valeur ou par référence

Par défaut, les arguments liés sont copiés. Encadrez-en un dans std::ref pour le lier par référence et rendre les modifications visibles.

#include <iostream>
#include <functional>

void addTo(int& target, int amount) { target += amount; }

int main() {
    using namespace std::placeholders;
    int total = 0;
    auto acc = std::bind(addTo, std::ref(total), _1);
    acc(5);
    acc(10);
    std::cout << total << '\n';
    return 0;
}

Utiliser des objets liés dans les algorithmes

Un objet appelable lié peut servir de prédicat ou d'opération dans les algorithmes standard.

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

bool greaterThan(int x, int limit) { return x > limit; }

int main() {
    using namespace std::placeholders;
    std::vector<int> v = {1, 5, 8, 2, 9};
    auto over4 = std::bind(greaterThan, _1, 4);
    std::cout << std::count_if(v.begin(), v.end(), over4) << '\n';
    return 0;
}

Imbriquer bind

Les expressions de bind peuvent être composées, mais elles deviennent rapidement difficiles à lire. Chaque espace réservé fait toujours référence aux arguments du dernier appelant.

#include <iostream>
#include <functional>

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

int main() {
    using namespace std::placeholders;
    auto f = std::bind(add, std::bind(times, 2, _1), 3);
    std::cout << f(5) << '\n';
    return 0;
}

Ignorer les arguments supplémentaires

Si l'appel lié n'utilise que certains espaces réservés, tous les arguments supplémentaires transmis lors de l'appel sont simplement ignorés.

#include <iostream>
#include <functional>

int show(int a) { return a; }

int main() {
    using namespace std::placeholders;
    auto f = std::bind(show, _1);
    std::cout << f(42, 99, 100) << '\n';
    return 0;
}

Quand une lambda est plus claire

Le C++ moderne préfère souvent une lambda à std::bind, car elle est plus lisible et le compilateur l'optimise mieux.

#include <iostream>
#include <functional>

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

int main() {
    auto add10 = [](int x) { return add(10, x); };
    std::cout << add10(5) << '\n';
    return 0;
}

Vérification rapide

Vérifiez votre compréhension des espaces réservés.

Récapitulatif

Vous avez appris le fonctionnement de std::bind :

il fixe certains arguments et utilise les espaces réservés _1, _2 pour les autres
il peut réordonner les arguments, lier des fonctions membres et utiliser std::ref
les résultats peuvent être stockés dans std::function et utilisés dans des algorithmes
les lambdas sont souvent plus claires en C++ moderne

Vous allez ensuite comparer les lambdas, bind et les pointeurs de fonction pour choisir l'outil approprié.

Questions Fréquemment Posées

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

Oui — le texte complet de « std::bind » 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::bind » ?

Lier des arguments à des appelables 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 3 sur 4.

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

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