C++ Academy · Aula

Lógica condicional

Use std::conditional e if constexpr

Lógica condicional é 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.

Escolhendo Tipos e Caminhos

A lógica de características de tipos permite que o código escolha tipos e caminhos de código em tempo de compilação. As principais ferramentas são std::conditional e if constexpr.

std::conditional

std::conditional_t<cond, A, B> resulta em A quando cond é verdadeiro; caso contrário, resulta em B.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::conditional_t<true, int, double>;
    std::cout << std::is_same_v<T, int> << "\n";
    return 0;
}

Selecionando um Tipo de Armazenamento

Um uso comum é escolher um tipo amplo para valores grandes e um tipo estreito nos demais casos.

#include <iostream>
#include <type_traits>

template <bool Big>
struct Storage {
    using type = std::conditional_t<Big, long long, short>;
};

int main() {
    Storage<true>::type a = 10;
    std::cout << sizeof(a) << "\n";
    return 0;
}

Fundamentos de if constexpr

if constexpr (C++17) descarta o ramo não escolhido em tempo de compilação. Apenas o ramo escolhido precisa ser compilado para o tipo fornecido.

#include <iostream>
#include <type_traits>

template <typename T>
void describe(T v) {
    if constexpr (std::is_integral_v<T>)
        std::cout << "integer: " << v << "\n";
    else
        std::cout << "other: " << v << "\n";
}

int main() {
    describe(5);
    describe(2.5);
    return 0;
}

Por que if constexpr supera o if em tempo de execução

Com um if comum, ambos os ramos precisam ser compilados para cada T. Com if constexpr, o ramo rejeitado não é instanciado, portanto pode conter código específico do tipo que, de outra forma, seria inválido.

Operações específicas do tipo

Isso é impossível com um if simples, porque .length() não seria compilado para int.

#include <iostream>
#include <string>
#include <type_traits>

template <typename T>
auto size_of(const T& v) {
    if constexpr (std::is_same_v<T, std::string>)
        return v.length();
    else
        return sizeof(v);
}

int main() {
    std::cout << size_of(std::string("hi")) << "\n";
    std::cout << size_of(42) << "\n";
    return 0;
}

enable_if para sobrecargas

Antes de if constexpr, std::enable_if selecionava sobrecargas por meio de SFINAE. Ele remove uma função da resolução de sobrecargas quando uma condição é falsa.

#include <iostream>
#include <type_traits>

template <typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
void only_int(T v) { std::cout << "int " << v << "\n"; }

int main() {
    only_int(7);
    return 0;
}

Combinando condições

Você pode combinar características com &&, || e ! em condições avaliadas em tempo de compilação, assim como faria com booleanos comuns.

#include <iostream>
#include <type_traits>

template <typename T>
void check() {
    if constexpr (std::is_integral_v<T> && !std::is_same_v<T, bool>)
        std::cout << "non-bool integer\n";
    else
        std::cout << "something else\n";
}

int main() {
    check<int>();
    check<bool>();
    return 0;
}

Seleção recursiva em tempo de compilação

if constexpr permite recursão em tempo de compilação, útil para processar tuplas ou pacotes de parâmetros elemento por elemento.

conjunction e disjunction

O C++17 também fornece std::conjunction e std::disjunction para aplicar AND/OR lógico com curto-circuito a uma lista de características.

Escolhendo a ferramenta certa

Use conditional para selecionar um tipo, if constexpr para selecionar código e enable_if/conceitos para controlar a resolução de sobrecargas. O código moderno favorece if constexpr e conceitos por sua clareza.

Verificação rápida

Relembre o principal benefício de if constexpr.

Recapitulação

Você aprendeu a lógica condicional em tempo de compilação.

conditional_t<c,A,B> seleciona um tipo
if constexpr seleciona código e descarta o outro ramo
enable_if controla a resolução de sobrecargas por meio de SFINAE
Combine características com operadores lógicos

Perguntas Frequentes

A aula “Lógica condicional” é grátis?

Sim — o texto completo de “Lógica condicional” é 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 “Lógica condicional”?

Use std::conditional e if constexpr 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 “Lógica condicional”?

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.

Todas as aulas deste curso

← Voltar para C++ Academy