std::bind
Associare argomenti ai callable
std::bind è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.
Che cos'è std::bind?
std::bind crea un nuovo oggetto chiamabile fissando alcuni argomenti di un oggetto esistente. Questa operazione si chiama applicazione parziale.
- È definito in
<functional>. - Restituisce un oggetto chiamabile di tipo non specificato.
#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;
}Placeholder
I placeholder come std::placeholders::_1 indicano gli argomenti da fornire in seguito, quando viene chiamato l'oggetto associato.
#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;
}Riordinare gli argomenti
I placeholder possono comparire in qualsiasi ordine, consentendo di scambiare la posizione degli argomenti forniti dal chiamante.
#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;
}Associare più argomenti
È possibile fissare più argomenti contemporaneamente, lasciando gli altri come placeholder.
#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;
}Memorizzare il risultato
L'oggetto restituito da std::bind può essere memorizzato in uno std::function per ottenere un tipo concreto e denominato.
#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;
}Associare funzioni membro
std::bind può operare su una funzione membro passando il puntatore al membro e un oggetto (o un placeholder) per 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;
}Associare per valore o per riferimento
Gli argomenti associati vengono copiati per impostazione predefinita. Racchiuda un argomento in std::ref per associarlo per riferimento, così le modifiche saranno visibili.
#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;
}Usare oggetti chiamabili associati negli algoritmi
Un oggetto chiamabile associato può essere usato come predicato o operazione negli algoritmi 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;
}Annidare bind
Le espressioni bind possono essere composte, anche se questa soluzione diventa rapidamente difficile da leggere. Ogni placeholder continua a riferirsi agli argomenti del chiamante finale.
#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;
}Ignorare gli argomenti aggiuntivi
Se la chiamata associata usa solo alcuni placeholder, gli eventuali argomenti aggiuntivi passati al momento della chiamata vengono semplicemente ignorati.
#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;
}Quando una lambda è più chiara
Il C++ moderno preferisce spesso una lambda a std::bind perché è più leggibile e il compilatore la ottimizza meglio.
#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;
}Verifica rapida
Verifichi la Sua comprensione dei placeholder.
Riepilogo
Ha imparato come funziona std::bind:
- fissa alcuni argomenti e usa i placeholder
_1,_2per gli altri - può riordinare gli argomenti, associare funzioni membro e usare
std::ref - i risultati possono essere memorizzati in
std::functione usati negli algoritmi - le lambda sono spesso più chiare nel C++ moderno
Ora confronterà lambda, bind e puntatori a funzione per scegliere lo strumento più adatto.
Domande Frequenti
La lezione «std::bind» è gratuita?
Sì — il testo completo di «std::bind» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.
Cosa imparerò in «std::bind»?
Associare argomenti ai callable Eserciti C++ Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare C++ Academy?
Non è richiesta alcuna esperienza precedente. C++ Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «std::bind»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione C++ Academy?
Sì. Ogni lezione C++ Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.