if statement

• 構文的に structured binding 宣言として解決できる場合、それはstructured binding宣言として解釈されます。

• attribute-specifier-seq (オプション) decl-specifier-seq declarator brace-or-equal-initializer

Structured binding 宣言

この宣言には以下の制限があります：

• 初期化子の expression は配列型であってはなりません。
• initializer の declaration specifier sequence には型指定子と constexpr のみを含めることができます。

この宣言の決定変数は、宣言によって導入される発明された変数 e です 。

if 初期化子付き文

init-statement が使用される場合、 if 文は以下と等価です：

または

ただし、 init-statement によって宣言された名前（ init-statement が宣言である場合）および condition によって宣言された名前（ condition が宣言である場合）は同じスコープにあり、これは両方の statement のスコープでもあります。

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

if constexpr で始まる文は、 constexpr if 文 として知られています。constexpr if 文のすべての部分文は、 制御フロー限定文 です。

constexpr if 文では、 condition は 文脈的に変換された型 bool の定数式 (C++23まで) 文脈的に bool に変換される式 でなければならず、その変換は 定数式 (C++23以降) でなければなりません。

condition が true を返す場合、 statement-false は（存在すれば）破棄され、そうでない場合、 statement-true は破棄されます。

破棄された文内の return 文は、関数の戻り値型推論に参加しません：

template<typename T>
auto get_value(T t)
{
    if constexpr (std::is_pointer_v<T>)
        return *t; // T = int* の場合、戻り値の型は int と推論される
    else
        return t;  // T = int の場合、戻り値の型は int と推論される
}

破棄された文は、定義されていない変数を ODR-use する可能性があります：

extern int x; // xの定義は不要
int f()
{
    if constexpr (true)
        return 0;
    else if (x)
        return x;
    else
        return -x;
}

テンプレートの外側では、破棄された文は完全にチェックされます。 if constexpr は #if プリプロセッサディレクティブの代替にはなりません：

void f()
{
    if constexpr(false)
    {
        int i = 0;
        int *p = i; // 破棄された文内であってもエラー
    }
}

constexpr if 文が テンプレート化されたエンティティ 内に現れ、かつ condition がインスタンス化後に 値依存 でない場合、外側のテンプレートがインスタンス化されるときに破棄された文はインスタンス化されません。

template<typename T, typename ... Rest>
void g(T&& p, Rest&& ...rs)
{
    // ... pを処理
    if constexpr (sizeof...(rs) > 0)
        g(rs...); // 空の引数リストではインスタンス化されない
}

インスタンス化後も条件が値に依存したままであるのは、ネストされたテンプレートの場合です：

template<class T>
void g()
{
    auto lm = [=](auto p)
    {
        if constexpr (sizeof(T) == 1 && sizeof p == 1)
        {
            // この条件は g<T> のインスタンス化後も値に依存したまま残り、
            // これは暗黙的なラムダキャプチャに影響を与える
            // この複合文はラムダ本体のインスタンス化後にのみ
            // 破棄される可能性がある
        }
    };
}

破棄された文は、あらゆる可能な特殊化に対して不適格であってはなりません：

template<typename T>
void f()
{
    if constexpr (std::is_arithmetic_v<T>)
        // ...
    else {
        using invalid_array = int[-1]; // 不適格: すべてのTに対して無効
        static_assert(false, "Must be arithmetic"); // CWG2518以前では不適格
    }
}

CWG issue 2518 の実装以前に、このような包括的なキャッチ文に対する一般的な回避策は、常に false となる型依存の式です：

template<typename>
constexpr bool dependent_false_v = false;
template<typename T>
void f()
{
    if constexpr (std::is_arithmetic_v<T>)
        // ...
    else {
        // CWG2518以前の回避策
        static_assert(dependent_false_v<T>, "Must be arithmetic");
    }
}

typedef宣言 または エイリアス宣言 (C++23以降) は、型エイリアスのスコープを縮小するために、constexpr if文の init-statement として使用できます。

Consteval if

if consteval で始まる文は、 consteval if 文 として知られています。consteval if 文のすべての部分文は 制御フロー限定文 です。

statement は複合文でなければならず、複合文でない場合でも（そのためコンパイルエラーが発生します）、依然としてconsteval if文の一部として扱われます：

constexpr void f(bool b)
{
    if (true)
        if consteval {}
        else ; // エラー: 複合文ではない
               // else は外側の if に関連付けられていない
}

consteval if 文が 明示的に定数評価されるコンテキスト で評価される場合、 compound-statement が実行されます。そうでない場合、 statement が存在すればそれが実行されます。

文が if ! consteval で始まる場合、 compound-statement と statement （存在する場合）は両方とも複合文でなければなりません。このような文はconsteval if文とは見なされませんが、consteval if文と同等です：

• if ! consteval { /* stmt */ } は以下と等価です
  

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

• if ! consteval { /* stmt-1 */ } else { /* stmt-2 */ } は以下と等価です
  

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

compound-statement はconsteval if文内（または否定形の statement ）において 即時関数コンテキスト 内にあり、この場合、即時関数への呼び出しは定数式である必要はありません。

#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 // コンパイル時フレンドリーなアルゴリズムを使用
    {
        return ipow_ct(base, exp);
    }
    else // ランタイム評価を使用
    {
        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';
}