if statement

• S'il peut être résolu syntaxiquement comme une déclaration de liaison structurée , il est interprété comme une déclaration de liaison structurée.

• attribute-specifier-seq (optionnel) decl-specifier-seq declarator brace-or-equal-initializer

Déclaration de liaison structurée

La déclaration présente les restrictions suivantes :

• L' expression dans son initialiseur ne peut pas être de type tableau.
• La séquence de spécificateurs de déclaration ne peut contenir que des spécificateurs de type et constexpr .

La variable de décision de la déclaration est la variable inventée e introduite par la déclaration .

if instructions avec initialiseur

Si une init-statement est utilisée, l'instruction if est équivalente à

ou

Sauf que les noms déclarés par l' init-statement (si l' init-statement est une déclaration) et les noms déclarés par la condition (si la condition est une déclaration) sont dans la même portée, qui est également la portée des deux statement s.

std::map<int, std::string> m;
std::mutex mx;
extern bool shared_flag; // protégé par mx
int demo()
{
    if (auto it = m.find(10); it != m.end())
        return it->second.size();
    if (char buf[10]; std::fgets(buf, 10, stdin))
        m[0] += buf;
    if (std::lock_guard lock(mx); shared_flag)
    {
        unsafe_ping();
        shared_flag = false;
    }
    if (int s; int count = ReadBytesWithSignal(&s))
    {
        publish(count);
        raise(s);
    }
    if (const auto keywords = {"if", "for", "while"};
        std::ranges::any_of(keywords, [&tok](const char* kw) { return tok == kw; }))
    {
        std::cerr << "Le jeton ne doit pas être un mot-clé\n";
    }
}

Constexpr if

L'instruction qui commence par if constexpr est connue sous le nom d' instruction constexpr if . Toutes les sous-instructions d'une instruction constexpr if sont des instructions à contrôle de flux limité .

Dans une instruction constexpr if, condition doit être une expression constante contextuellement convertie de type bool (jusqu'à C++23) une expression contextuellement convertie en bool , où la conversion est une expression constante (depuis C++23) .

Si condition donne true , alors statement-false est ignoré (s'il est présent), sinon, statement-true est ignoré.

Les return dans une instruction rejetée ne participent pas à la déduction du type de retour de fonction :

template<typename T>
auto get_value(T t)
{
    if constexpr (std::is_pointer_v<T>)
        return *t; // déduit le type de retour comme int pour T = int*
    else
        return t;  // déduit le type de retour comme int pour T = int
}

L'instruction écartée peut ODR-utiliser une variable qui n'est pas définie :

extern int x; // aucune définition de x requise
int f()
{
    if constexpr (true)
        return 0;
    else if (x)
        return x;
    else
        return -x;
}

En dehors d'un modèle, une instruction écartée est entièrement vérifiée. if constexpr n'est pas un substitut pour la directive de préprocesseur #if :

void f()
{
    if constexpr(false)
    {
        int i = 0;
        int *p = i; // Erreur même dans une instruction rejetée
    }
}

Si une instruction constexpr if apparaît à l'intérieur d'une entité template , et si la condition n'est pas value-dependent après l'instanciation, l'instruction rejetée n'est pas instanciée lorsque le template englobant est instancié.

template<typename T, typename ... Rest>
void g(T&& p, Rest&& ...rs)
{
    // ... traiter p
    if constexpr (sizeof...(rs) > 0)
        g(rs...); // jamais instancié avec une liste d'arguments vide
}

La condition reste dépendante de la valeur après l'instanciation est un modèle imbriqué :

template<class T>
void g()
{
    auto lm = [=](auto p)
    {
        if constexpr (sizeof(T) == 1 && sizeof p == 1)
        {
            // cette condition reste dépendante de la valeur après l'instanciation de g<T>,
            // ce qui affecte les captures implicites du lambda
            // ce bloc d'instructions peut être écarté seulement après
            // l'instanciation du corps du lambda
        }
    };
}

L'instruction rejetée ne peut pas être mal formée pour toute spécialisation possible :

template<typename T>
void f()
{
    if constexpr (std::is_arithmetic_v<T>)
        // ...
    else {
        using invalid_array = int[-1]; // mal formé : invalide pour tout T
        static_assert(false, "Must be arithmetic"); // mal formé avant CWG2518
    }
}

La solution de contournement courante avant l'implémentation de CWG issue 2518 pour une telle instruction catch-all est une expression dépendante du type qui est toujours false :

template<typename>
constexpr bool dependent_false_v = false;
template<typename T>
void f()
{
    if constexpr (std::is_arithmetic_v<T>)
        // ...
    else {
        // contournement avant CWG2518
        static_assert(dependent_false_v<T>, "Doit être arithmétique");
    }
}

Une déclaration typedef ou déclaration d'alias (depuis C++23) peut être utilisée comme init-statement d'une instruction constexpr if pour réduire la portée de l'alias de type.

Consteval si

L'instruction qui commence par if consteval est connue sous le nom d' instruction consteval if . Toutes les sous-instructions d'une instruction consteval if sont des instructions à contrôle de flux limité .

statement doit être une instruction composée, et elle sera toujours traitée comme faisant partie de l'instruction consteval if même si ce n'est pas une instruction composée (et entraîne donc une erreur de compilation) :

constexpr void f(bool b)
{
    if (true)
        if consteval {}
        else ; // erreur : pas une instruction composée
               // else non associé au if externe
}

Si une instruction if consteval est évaluée dans un contexte manifestement constant-évalué , compound-statement est exécuté. Sinon, statement est exécuté s'il est présent.

Si l'instruction commence par if ! consteval , la compound-statement et l' statement (le cas échéant) doivent toutes deux être des instructions composées. Ces instructions ne sont pas considérées comme des instructions consteval if, mais sont équivalentes aux instructions consteval if :

• if ! consteval { /* stmt */ } est équivalent à
  

if consteval { } else { /* stmt */ } .

• if ! consteval { /* stmt-1 */ } else { /* stmt-2 */ } est équivalent à
  

if consteval { /* stmt-2 */ } else { /* stmt-1 */ } .

compound-statement dans une instruction consteval if (ou statement dans la forme négative) se trouve dans un contexte de fonction immédiate , dans lequel un appel à une fonction immédiate n'a pas besoin d'être une expression constante.

#include <cmath>
#include <cstdint>
#include <cstring>
#include <iostream>
constexpr bool is_constant_evaluated() noexcept
{
    if consteval { return true; } else { return false; }
}
constexpr bool is_runtime_evaluated() noexcept
{
    if not consteval { return true; } else { return false; }
}
consteval std::uint64_t ipow_ct(std::uint64_t base, std::uint8_t exp)
{
    if (!base) return base;
    std::uint64_t res{1};
    while (exp)
    {
        if (exp & 1) res *= base;
        exp /= 2;
        base *= base;
    }
    return res;
}
constexpr std::uint64_t ipow(std::uint64_t base, std::uint8_t exp)
{
    if consteval // utiliser un algorithme adapté à la compilation
    {
        return ipow_ct(base, exp);
    }
    else // utiliser l'évaluation à l'exécution
    {
        return std::pow(base, exp);
    }
}
int main(int, const char* argv[])
{
    static_assert(ipow(0, 10) == 0 && ipow(2, 10) == 1024);
    std::cout << ipow(std::strlen(argv[0]), 3) << '\n';
}