if statement

• Wenn es syntaktisch als eine structured binding Deklaration aufgelöst werden kann, wird es als eine structured binding Deklaration interpretiert.

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

Strukturierte Bindungsdeklaration

Die Deklaration unterliegt folgenden Einschränkungen:

• Der Ausdruck in ihrem Initialisierer darf nicht vom Typ Array sein.
• Die Deklarationsspezifizierer-Sequenz darf nur Typspezifizierer und constexpr enthalten.

Die Entscheidungsvariable der Deklaration ist die eingeführte Variable e , die durch die Deklaration eingeführt wird .

if Anweisungen mit Initialisierer

Wenn ein Init-Anweisung verwendet wird, entspricht die if -Anweisung

oder

Mit der Ausnahme, dass Namen, die durch die Init-Anweisung deklariert werden (falls Init-Anweisung eine Deklaration ist) und Namen, die durch Bedingung deklariert werden (falls Bedingung eine Deklaration ist), sich im selben Gültigkeitsbereich befinden, der auch der Gültigkeitsbereich beider Anweisungen ist.

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

Die Anweisung, die mit if constexpr beginnt, wird als constexpr if-Anweisung bezeichnet. Alle Unteranweisungen einer constexpr if-Anweisung sind kontrollflussbeschränkte Anweisungen .

In einer constexpr-if-Anweisung muss condition ein kontextuell umgewandelter konstanter Ausdruck vom Typ bool sein (bis C++23) ein Ausdruck sein, der kontextuell zu bool umgewandelt wird , wobei die Umwandlung ein konstanter Ausdruck ist (seit C++23) .

Wenn condition zu true ausgewertet wird, dann wird statement-false verworfen (falls vorhanden), andernfalls wird statement-true verworfen.

Die return -Anweisungen in einer verworfenen Anweisung nehmen nicht an der Ableitung des Funktionrückgabetyps teil:

template<typename T>
auto get_value(T t)
{
    if constexpr (std::is_pointer_v<T>)
        return *t; // leitet Rückgabetyp zu int für T = int* ab
    else
        return t;  // leitet Rückgabetyp zu int für T = int ab
}

Der verworfenen Anweisung kann ODR-use eine Variable verwenden, die nicht definiert ist:

extern int x; // keine Definition von x erforderlich
int f()
{
    if constexpr (true)
        return 0;
    else if (x)
        return x;
    else
        return -x;
}

Außerhalb einer Vorlage wird eine verworfenen Anweisung vollständig geprüft. if constexpr ist kein Ersatz für die #if Präprozessor-Direktive:

void f()
{
    if constexpr(false)
    {
        int i = 0;
        int *p = i; // Fehler selbst in verworfenem Statement
    }
}

Wenn eine constexpr-if-Anweisung innerhalb einer templated entity erscheint und die condition nach der Instanziierung nicht value-dependent ist, wird die verworfenen Anweisung nicht instanziiert, wenn das umschließende Template instanziiert wird.

template<typename T, typename ... Rest>
void g(T&& p, Rest&& ...rs)
{
    // ... p verarbeiten
    if constexpr (sizeof...(rs) > 0)
        g(rs...); // niemals mit einer leeren Argumentliste instanziiert
}

Die Bedingung bleibt wertabhängig nach der Instanziierung ist eine geschachtelte Vorlage:

template<class T>
void g()
{
    auto lm = [=](auto p)
    {
        if constexpr (sizeof(T) == 1 && sizeof p == 1)
        {
            // diese Bedingung bleibt wertabhängig nach der Instanziierung von g<T>,
            // was implizite Lambda-Captures beeinflusst
            // dieser Verbundblock kann erst nach der
            // Instanziierung des Lambda-Rumpfes verworfen werden
        }
    };
}

Der verworfenen Anweisung kann nicht für jede mögliche Spezialisierung fehlerhaft sein:

template<typename T>
void f()
{
    if constexpr (std::is_arithmetic_v<T>)
        // ...
    else {
        using invalid_array = int[-1]; // ungültig: für jedes T ungültig
        static_assert(false, "Must be arithmetic"); // ungültig vor CWG2518
    }
}

Die gängige Problemumgehung vor der Implementierung von CWG issue 2518 für eine solche Catch-all-Anweisung ist ein typabhängiger Ausdruck, der immer false ist:

template<typename>
constexpr bool dependent_false_v = false;
template<typename T>
void f()
{
    if constexpr (std::is_arithmetic_v<T>)
        // ...
    else {
        // Workaround vor CWG2518
        static_assert(dependent_false_v<T>, "Muss arithmetisch sein");
    }
}

Eine typedef-Deklaration oder Alias-Deklaration (seit C++23) kann als Init-Statement einer constexpr-if-Anweisung verwendet werden, um den Gültigkeitsbereich des Typ-Alias zu reduzieren.

Consteval if

Die Anweisung, die mit if consteval beginnt, wird als consteval-if-Anweisung bezeichnet. Alle Unteranweisungen einer consteval-if-Anweisung sind kontrollflussbeschränkte Anweisungen .

statement muss ein zusammengesetzter Ausdruck sein, und es wird weiterhin als Teil der consteval-if-Anweisung behandelt, selbst wenn es kein zusammengesetzter Ausdruck ist (und somit zu einem Kompilierungsfehler führt):

constexpr void f(bool b)
{
    if (true)
        if consteval {}
        else ; // Fehler: keine Verbundanweisung
               // else nicht mit äußerem if assoziiert
}

Wenn eine consteval-if-Anweisung in einem manifestly constant-evaluated context ausgewertet wird, wird compound-statement ausgeführt. Andernfalls wird statement ausgeführt, falls vorhanden.

Wenn die Anweisung mit if ! consteval beginnt, müssen sowohl die compound-statement als auch die statement (falls vorhanden) zusammengesetzte Anweisungen sein. Solche Anweisungen gelten nicht als consteval if-Anweisungen, sind jedoch äquivalent zu consteval if-Anweisungen:

• if ! consteval { /* stmt */ } entspricht
  

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

• if ! consteval { /* stmt-1 */ } else { /* stmt-2 */ } entspricht
  

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

compound-statement in einer consteval if-Anweisung (oder statement in der negativen Form) befindet sich in einem immediate function context , in welchem ein Aufruf einer immediate function keine konstante Expression sein muss.

#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 // verwende einen kompilierzeitfreundlichen Algorithmus
    {
        return ipow_ct(base, exp);
    }
    else // verwende Laufzeitauswertung
    {
        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';
}