std::variant
Uma união segura quanto aos tipos
std::variant é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.
Uma união segura quanto aos tipos
std::variant contém exatamente um valor de uma lista fixa de tipos e lembra qual deles está armazenado. Inclua <variant> para usá-lo.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 10;
std::cout << std::get<int>(v) << "\n";
}Atribuindo tipos diferentes
Você pode atribuir novamente a uma variante qualquer um de seus tipos alternativos. Ela atualiza automaticamente qual alternativa está ativa.
#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";
}Verificando o tipo ativo
std::holds_alternative<T>(v) informa se a variante contém atualmente o 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";
}A função index()
v.index() retorna a posição, começando em zero, do tipo ativo na lista de tipos.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double, char> v = (char)65;
std::cout << v.index() << "\n"; // 2
}Acesso seguro com std::get
std::get<T> retorna o valor se T estiver ativo; caso contrário, lança std::bad_variant_access. Nenhum valor silenciosamente sem sentido.
#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 sem lançar exceção
std::get_if<T>(&v) retorna um ponteiro para o valor ou nullptr se T não estiver ativo. É ótimo para verificações sem ramificações.
#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";
}Construção padrão
Uma variante construída por padrão contém uma versão inicializada por valor de seu tipo primeiro. Organize seus tipos de modo que o primeiro forneça um padrão sensato.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v; // holds int 0
std::cout << std::get<int>(v) << "\n";
}Armazenando cadeias de caracteres
Ao contrário das uniões brutas, uma variante pode conter com segurança tipos não triviais, como std::string; o tempo de vida é gerenciado para você.
#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";
}std::variant como tipo de retorno
Uma função pode retornar um entre vários tipos retornando uma variante. Em seguida, quem a chama pode inspecioná-la para descobrir qual tipo foi retornado.
#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 para alteração no local
v.emplace<T>(args...) constrói um novo valor do tipo T diretamente dentro da variante, alterando a alternativa ativa.
#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";
}Por que preferir std::variant?
std::variant oferece a eficiência de memória de uma união com segurança total de tipos: controla o tipo ativo, gerencia os tempos de vida e recusa acessos ao tipo errado. A próxima lição mostra a maneira mais clara de processá-la.
Verificação rápida
Verifique sua compreensão sobre std::variant.
Recapitulação
Você aprendeu sobre std::variant:
- Contém um entre vários tipos e controla qual deles está ativo.
holds_alternative/index()inspecionam o tipo ativo.std::getlança uma exceção em caso de incompatibilidade;get_ifretorna um ponteiro ou nulo.- Armazena com segurança tipos não triviais, como
std::string.
Perguntas Frequentes
A aula “std::variant” é grátis?
Sim — o texto completo de “std::variant” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.
O que vou aprender em “std::variant”?
Uma união segura quanto aos tipos Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar C++ Academy?
Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “std::variant”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de C++ Academy?
Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.