if statement

• 구문적으로 structured binding 선언으로 해결될 수 있는 경우, 이는 structured binding 선언으로 해석됩니다.

• attribute-specifier-seq (선택 사항) decl-specifier-seq declarator brace-or-equal-initializer

구조화된 바인딩 선언

선언에는 다음과 같은 제한 사항이 있습니다:

• 초기화자 의 표현식 은 배열 타입일 수 없습니다.
• 선언 지정자 시퀀스 는 타입 지정자와 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 문에서, 조건 은 bool 타입으로 문맥적으로 변환된 상수 표현식 bool 이어야 합니다 (C++23 이전) bool로 문맥적으로 변환되는 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 문이 템플릿 엔티티 내부에 나타나고, 인스턴스화 후 조건 이 값-의존적 이 아닌 경우, 버려진 문은 둘러싼 템플릿이 인스턴스화될 때 인스턴스화되지 않습니다.

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 이 구현되기 전에 이러한 catch-all 문에 대한 일반적인 해결 방법은 항상 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 선언 또는 alias 선언 (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 에서) immediate function context 에 위치하며, 이 컨텍스트에서는 immediate function에 대한 호출이 상수 표현식일 필요가 없습니다.

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