C++ Academy · Leçon

Logique conditionnelle

Utiliser std::conditional et if constexpr

Logique conditionnelle est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Choisir les types et les branches

La logique fondée sur les caractéristiques de type permet au code de choisir des types et des chemins d’exécution à la compilation. Les principaux outils sont std::conditional et if constexpr.

std::conditional

std::conditional_t<cond, A, B> donne A lorsque cond est vrai, et B dans le cas contraire.

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

Sélectionner un type de stockage

Une utilisation courante consiste à choisir un type large pour les grandes valeurs et un type étroit dans les autres cas.

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

Les bases de if constexpr

if constexpr (C++17) élimine à la compilation la branche qui n’est pas sélectionnée. Seule la branche choisie doit être compilable pour le type donné.

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

Pourquoi if constexpr est préférable à if à l’exécution

Avec un if ordinaire, les deux branches doivent être compilables pour chaque T. Avec if constexpr, la branche rejetée n’est pas instanciée ; elle peut donc contenir du code spécifique au type qui serait autrement invalide.

Opérations spécifiques au type

C’est impossible avec un simple if, car .length() ne serait pas compilable pour 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 pour les surcharges

Avant if constexpr, std::enable_if sélectionnait les surcharges au moyen de SFINAE. Il retire une fonction de la résolution des surcharges lorsqu’une condition est fausse.

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

Combinaison de conditions

Vous pouvez combiner des traits avec &&, || et ! dans des conditions évaluées à la compilation, comme avec des booléens ordinaires.

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

Sélection récursive à la compilation

if constexpr permet la récursivité à la compilation, ce qui est utile pour traiter des tuples ou des packs de paramètres élément par élément.

conjunction et disjunction

C++17 fournit également std::conjunction et std::disjunction pour appliquer un ET/OU logique avec court-circuit à une liste de traits.

Choisir le bon outil

Utilisez conditional pour sélectionner un type, if constexpr pour sélectionner du code, et enable_if/les concepts pour contrôler la résolution des surcharges. Le code moderne privilégie if constexpr et les concepts pour plus de clarté.

Vérification rapide

Rappelez-vous l’avantage essentiel de if constexpr.

Récapitulatif

Vous avez appris la logique conditionnelle évaluée à la compilation.

conditional_t<c,A,B> sélectionne un type
if constexpr sélectionne du code et élimine l’autre branche
enable_if contrôle la résolution des surcharges via SFINAE
Combinez les traits avec des opérateurs logiques

Questions Fréquemment Posées

La leçon « Logique conditionnelle » est-elle gratuite ?

Oui — le texte complet de « Logique conditionnelle » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Logique conditionnelle » ?

Utiliser std::conditional et if constexpr Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Logique conditionnelle » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C++ Academy