std::variant
Una union con sicurezza dei tipi
std::variant è 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.
Una union con sicurezza dei tipi
std::variant contiene esattamente un valore scelto da un elenco fisso di tipi e ricorda quale. Per usarlo, includa <variant>.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 10;
std::cout << std::get<int>(v) << "\n";
}Assegnare tipi diversi
È possibile riassegnare una variant a uno qualsiasi dei suoi tipi alternativi. La variant aggiorna automaticamente l'alternativa attiva.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 5;
v = 3.14; // now holds a double
std::cout << std::get<double>(v) << "\n";
}Verificare il tipo attivo
std::holds_alternative<T>(v) indica se la variant contiene attualmente il tipo T.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 2.0;
std::cout << std::holds_alternative<double>(v) << "\n";
std::cout << std::holds_alternative<int>(v) << "\n";
}La funzione index()
v.index() restituisce la posizione, a partire da zero, del tipo attivo nell'elenco dei tipi.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double, char> v = (char)65;
std::cout << v.index() << "\n"; // 2
}Accesso sicuro con std::get
std::get<T> restituisce il valore se T è attivo; in caso contrario genera un'eccezione std::bad_variant_access. Nessun valore spazzatura silenzioso.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 7;
try {
std::cout << std::get<double>(v) << "\n";
} catch (const std::bad_variant_access& e) {
std::cout << "wrong type!\n";
}
}get_if senza eccezioni
std::get_if<T>(&v) restituisce un puntatore al valore oppure nullptr se T non è attivo. È ideale per i controlli senza ramificazioni.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 9;
if (auto p = std::get_if<int>(&v))
std::cout << "int " << *p << "\n";
}Costruzione predefinita
Una variant costruita per impostazione predefinita contiene una versione inizializzata per valore del suo primo tipo. Ordini i tipi in modo che il primo costituisca un valore predefinito sensato.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v; // holds int 0
std::cout << std::get<int>(v) << "\n";
}Memorizzare stringhe
A differenza delle union tradizionali, una variant può contenere in sicurezza tipi non banali come std::string; il ciclo di vita viene gestito automaticamente.
#include <iostream>
#include <string>
#include <variant>
int main() {
std::variant<int, std::string> v = std::string("hello");
std::cout << std::get<std::string>(v) << "\n";
}Variant come tipo restituito
Una funzione può restituire uno tra diversi tipi restituendo una variant. Il chiamante può quindi esaminarla per scoprire quale tipo è stato restituito.
#include <iostream>
#include <string>
#include <variant>
std::variant<int, std::string> parse(bool ok) {
if (ok) return 42;
return std::string("error");
}
int main() {
auto r = parse(false);
if (auto s = std::get_if<std::string>(&r)) std::cout << *s << "\n";
}emplace per modificare direttamente
v.emplace<T>(args...) costruisce un nuovo valore di tipo T direttamente all'interno della variant, rendendo attiva l'alternativa corrispondente.
#include <iostream>
#include <string>
#include <variant>
int main() {
std::variant<int, std::string> v = 1;
v.emplace<std::string>("switched");
std::cout << std::get<std::string>(v) << "\n";
}Perché preferire Variant?
std::variant offre l'efficienza in memoria delle union con la piena sicurezza dei tipi: tiene traccia del tipo attivo, gestisce i cicli di vita e rifiuta gli accessi al tipo sbagliato. La lezione successiva mostra il modo più semplice per elaborarla.
Verifica rapida
Verifichi la Sua comprensione di std::variant.
Riepilogo
Ha imparato a conoscere std::variant:
- Contiene uno tra diversi tipi e tiene traccia di quale sia.
holds_alternative/index()esaminano il tipo attivo.std::getgenera un'eccezione in caso di mancata corrispondenza;get_ifrestituisce un puntatore o null.- Memorizza in sicurezza tipi non banali come
std::string.
Domande Frequenti
La lezione «std::variant» è gratuita?
Sì — il testo completo di «std::variant» è 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::variant»?
Una union con sicurezza dei tipi 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::variant»?
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.