if statement

• Si puede resolverse sintácticamente como una declaración de structured binding , se interpreta como una declaración de structured binding.

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

Declaración de enlace estructurado

La declaración tiene las siguientes restricciones:

• La expresión en su inicializador no puede ser de tipo array.
• La secuencia de especificadores de declaración solo puede contener especificadores de tipo y constexpr .

La variable de decisión de la declaración es la variable inventada e introducida por la declaración .

if sentencias con inicializador

Si se utiliza init-statement , la if sentencia es equivalente a

o

Excepto que los nombres declarados por el init-statement (si init-statement es una declaración) y los nombres declarados por condition (si condition es una declaración) están en el mismo ámbito, que también es el ámbito de ambas statement s.

std::map<int, std::string> m;
std::mutex mx;
extern bool shared_flag; // guarded by 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 << "Token must not be a keyword\n";
    }
}

Constexpr if

La declaración que comienza con if constexpr se conoce como constexpr if statement . Todas las subdeclaraciones de una constexpr if statement son control-flow-limited statements .

En una sentencia constexpr if, condition debe ser una expresión constante convertida contextualmente de tipo bool (hasta C++23) una expresión convertida contextualmente a bool , donde la conversión es una expresión constante (desde C++23) .

Si condición produce true , entonces sentencia-falsa se descarta (si está presente), de lo contrario, sentencia-verdadera se descarta.

Las return statements en una declaración descartada no participan en la deducción del tipo de retorno de la función:

template<typename T>
auto get_value(T t)
{
    if constexpr (std::is_pointer_v<T>)
        return *t; // deduce el tipo de retorno como int para T = int*
    else
        return t;  // deduce el tipo de retorno como int para T = int
}

La declaración descartada puede ODR-use una variable que no está definida:

extern int x; // no definition of x required
int f()
{
    if constexpr (true)
        return 0;
    else if (x)
        return x;
    else
        return -x;
}

Fuera de una plantilla, una declaración descartada se verifica completamente. if constexpr no es un sustituto de la directiva de preprocesamiento #if :

void f()
{
    if constexpr(false)
    {
        int i = 0;
        int *p = i; // Error incluso en una sentencia descartada
    }
}

Si una sentencia constexpr if aparece dentro de una entidad con plantilla , y si la condición no es value-dependent después de la instanciación, la sentencia descartada no se instancia cuando se instancia la plantilla contenedora.

template<typename T, typename ... Rest>
void g(T&& p, Rest&& ...rs)
{
    // ... manejar p
    if constexpr (sizeof...(rs) > 0)
        g(rs...); // nunca se instancia con una lista de argumentos vacía
}

La condición permanece dependiente del valor después de la instanciación es una plantilla anidada:

template<class T>
void g()
{
    auto lm = [=](auto p)
    {
        if constexpr (sizeof(T) == 1 && sizeof p == 1)
        {
            // esta condición permanece dependiente de valores después de la instanciación de g<T>,
            // lo cual afecta las capturas implícitas de lambda
            // esta sentencia compuesta puede descartarse solo después de
            // la instanciación del cuerpo de lambda
        }
    };
}

La declaración descartada no puede estar mal formada para cada especialización posible:

template<typename T>
void f()
{
    if constexpr (std::is_arithmetic_v<T>)
        // ...
    else {
        using invalid_array = int[-1]; // mal formado: inválido para todo T
        static_assert(false, "Must be arithmetic"); // mal formado antes de CWG2518
    }
}

La solución común antes de la implementación de CWG issue 2518 para tal declaración catch-all es una expresión dependiente del tipo que siempre es false :

template<typename>
constexpr bool dependent_false_v = false;
template<typename T>
void f()
{
    if constexpr (std::is_arithmetic_v<T>)
        // ...
    else {
        // solución alternativa antes de CWG2518
        static_assert(dependent_false_v<T>, "Must be arithmetic");
    }
}

Una declaración typedef o declaración de alias (desde C++23) puede usarse como la init-statement de una sentencia constexpr if para reducir el alcance del alias de tipo.

Consteval if

La declaración que comienza con if consteval se conoce como declaración consteval if . Todas las subdeclaraciones de una declaración consteval if son declaraciones de control de flujo limitado .

statement debe ser una sentencia compuesta, y seguirá siendo tratada como parte de la sentencia if consteval incluso si no es una sentencia compuesta (y por lo tanto resulta en un error de compilación):

constexpr void f(bool b)
{
    if (true)
        if consteval {}
        else ; // error: not a compound-statement
               // else not associated with outer if
}

Si una sentencia if consteval se evalúa en un contexto manifiestamente constante-evaluado , compound-statement se ejecuta. De lo contrario, statement se ejecuta si está presente.

Si la declaración comienza con if ! consteval , el compound-statement y la statement (si existe) deben ser ambas declaraciones compuestas. Estas declaraciones no se consideran consteval if statements, pero son equivalentes a consteval if statements:

• if ! consteval { /* stmt */ } es equivalente a
  

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

• if ! consteval { /* stmt-1 */ } else { /* stmt-2 */ } es equivalente a
  

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

compound-statement en una sentencia consteval if (o statement en la forma negativa) está en un contexto de función inmediata , en el cual una llamada a una función inmediata no necesita ser una expresión 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 // usar un algoritmo amigable para tiempo de compilación
    {
        return ipow_ct(base, exp);
    }
    else // usar evaluación en tiempo de ejecución
    {
        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';
}