std::visit
Processe alternativas de variant
std::visit é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 4 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.
Por que usar std::visit?
Verificar manualmente cada alternativa com get_if fica verboso. std::visit aplica uma função chamável ao tipo que a variante contém atualmente, cuidando do despacho para você.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 4;
std::visit([](auto x){ std::cout << x << "\n"; }, v);
}Um visitante com lambda genérica
Uma lambda que recebe auto funciona para todas as alternativas se o corpo compilar para todas elas. Aqui, imprimimos qualquer tipo que esteja ativo.
#include <iostream>
#include <string>
#include <variant>
int main() {
std::variant<int, std::string> v = std::string("hi");
std::visit([](const auto& x){ std::cout << x << "\n"; }, v);
}Retornando um valor
std::visit pode retornar um valor. Cada ramo precisa retornar o mesmo tipo.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 2.5;
double d = std::visit([](auto x){ return x * 2.0; }, v);
std::cout << d << "\n";
}Comportamento por tipo com if constexpr
Para agir de maneira diferente conforme o tipo dentro de uma única lambda genérica, combine if constexpr com std::decay_t e std::is_same_v.
#include <iostream>
#include <string>
#include <variant>
#include <type_traits>
int main() {
std::variant<int, std::string> v = 5;
std::visit([](const auto& x){
using T = std::decay_t<decltype(x)>;
if constexpr (std::is_same_v<T, int>) std::cout << "int " << x << "\n";
else std::cout << "str " << x << "\n";
}, v);
}Um visitante definido por estrutura
Você também pode escrever uma estrutura com várias sobrecargas de operator(), uma por tipo. O compilador escolhe a sobrecarga correspondente.
#include <iostream>
#include <string>
#include <variant>
struct Printer {
void operator()(int i) const { std::cout << "int " << i << "\n"; }
void operator()(const std::string& s) const { std::cout << "str " << s << "\n"; }
};
int main() {
std::variant<int, std::string> v = std::string("yo");
std::visit(Printer{}, v);
}O padrão overloaded
Um auxiliar popular combina várias lambdas em um único visitante. Cada lambda trata um tipo específico.
#include <iostream>
#include <string>
#include <variant>
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
int main() {
std::variant<int, std::string> v = 8;
std::visit(overloaded{
[](int i){ std::cout << "i=" << i << "\n"; },
[](const std::string& s){ std::cout << "s=" << s << "\n"; }
}, v);
}Exaustividade
Um visitante precisa tratar todas as alternativas, ou o código não será compilado. Essa verificação em tempo de compilação impede que você se esqueça de um caso.
Visitando e modificando
Se você passar a variante por referência não constante, o visitante poderá modificar o valor armazenado no próprio local.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 10;
std::visit([](auto& x){ x += 1; }, v);
std::cout << std::get<int>(v) << "\n";
}Várias variantes
std::visit pode receber várias variantes de uma só vez; o visitante então recebe um argumento por variante.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> a = 2;
std::variant<int, double> b = 3.0;
auto sum = std::visit([](auto x, auto y){ return x + y; }, a, b);
std::cout << sum << "\n";
}Escolhendo um estilo de visitante
Use uma lambda genérica com auto para um tratamento uniforme, o padrão overloaded para uma lógica clara por tipo e um visitante definido por estrutura quando o comportamento for reutilizado em vários pontos de chamada.
Visitar versus get_if
get_if é adequado para uma única verificação rápida, mas std::visit funciona melhor em maior escala: exige exaustividade e mantém toda a lógica por tipo em um só lugar.
Verificação rápida
Verifique sua compreensão sobre std::visit.
Recapitulação
Você aprendeu sobre std::visit:
- Despacha uma função chamável para a alternativa ativa.
- Use lambdas genéricas,
if constexpr, visitantes definidos por estrutura ou o padrão overloaded. - Os visitantes precisam ser exaustivos (verificação em tempo de compilação).
- Podem retornar valores e visitar várias variantes em conjunto.
Perguntas Frequentes
A aula “std::visit” é grátis?
Sim — o texto completo de “std::visit” é 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::visit”?
Processe alternativas de variant 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 4 de 4.
Quanto tempo leva a aula “std::visit”?
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.