C++ Academy · Lezione

Logica condizionale

std::conditional e if constexpr

Logica condizionale è 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.

Scegliere tipi e rami

La logica basata sui type trait consente al codice di scegliere tipi e percorsi di esecuzione in fase di compilazione. Gli strumenti principali sono std::conditional e if constexpr.

std::conditional

std::conditional_t<cond, A, B> restituisce A quando cond è true, altrimenti 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;
}

Selezionare un tipo di memoria

Un uso comune consiste nello scegliere un tipo più ampio per i valori grandi e uno più ristretto negli altri casi.

#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;
}

Nozioni di base di if constexpr

if constexpr (C++17) scarta in fase di compilazione il ramo non selezionato. Solo il ramo scelto deve compilare per il tipo specificato.

#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;
}

Perché if constexpr è migliore di un if a runtime

Con un normale if, entrambi i rami devono compilare per ogni T. Con if constexpr, il ramo rifiutato non viene istanziato, quindi può contenere codice specifico per il tipo che altrimenti non sarebbe valido.

Operazioni specifiche per il tipo

Questo non è possibile con un semplice if, perché .length() non compilerebbe per 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 per gli overload

Prima di if constexpr, std::enable_if selezionava gli overload tramite SFINAE. Rimuove una funzione dalla risoluzione degli overload quando una condizione è 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;
}

Combinare le condizioni

È possibile combinare i trait con &&, || e ! nelle condizioni valutate in fase di compilazione, proprio come normali valori booleani.

#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;
}

Selezione ricorsiva in fase di compilazione

if constexpr abilita la ricorsione in fase di compilazione, utile per elaborare tuple o parameter pack un elemento alla volta.

conjunction e disjunction

C++17 fornisce anche std::conjunction e std::disjunction per eseguire AND/OR logici con short-circuit su un elenco di trait.

Scegliere lo strumento giusto

Utilizzi conditional per selezionare un tipo, if constexpr per selezionare il codice e enable_if/concepts per controllare la risoluzione degli overload. Il codice moderno privilegia if constexpr e i concepts per maggiore chiarezza.

Verifica rapida

Richiami il principale vantaggio di if constexpr.

Riepilogo

Ha imparato la logica condizionale in fase di compilazione.

conditional_t<c,A,B> seleziona un tipo
if constexpr seleziona il codice e scarta l'altro ramo
enable_if controlla la risoluzione degli overload tramite SFINAE
Combini i trait con gli operatori logici

Domande Frequenti

La lezione «Logica condizionale» è gratuita?

Sì — il testo completo di «Logica condizionale» è 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 «Logica condizionale»?

std::conditional e if constexpr 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 «Logica condizionale»?

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.

Tutte le lezioni di questo corso

← Torna a C++ Academy