Constant expressions

컴파일 타임에 평가될 수 있는 expression 을 정의합니다.

이러한 표현식은 상수 템플릿 인수, 배열 크기 및 기타 상수 표현식이 필요한 상황에서 사용할 수 있습니다, 예를 들어

int n = 1;
std::array<int, n> a1;  // 오류: "n"은 상수 표현식이 아닙니다
const int cn = 2;
std::array<int, cn> a2; // 정상: "cn"은 상수 표현식입니다

정의

어떤 표현식이 상수 표현식인지 판단할 때, copy elision 이 수행되지 않는 것으로 가정합니다.

C++98 상수 표현식 정의는 접기 상자 내에 완전히 포함되어 있습니다. 다음 설명은 C++11 및 이후 C++ 버전에 적용됩니다.

리터럴 타입

다음 유형들을 통칭하여 literal types 라고 합니다:

• 가능하게 cv 한정된 void
• 스칼라 타입
• 레퍼런스 타입
• 리터럴 타입의 배열
• 다음 모든 조건을 만족하는 가능하게 cv 한정된 클래스 타입:

• 이것은 trivial destructor (until C++20) constexpr destructor (since C++20) 를 가집니다.
• 모든 비정적(non-static) 비변이(non-variant) 데이터 멤버와 기본 클래스가 비휘발성(non-volatile) 리터럴 타입입니다.
• 다음 타입 중 하나입니다:

• 다음 조건 중 하나를 만족하는 집계(aggregate) 유니온(union) 타입:

• variant member 가 없는 경우
• non-volatile literal type의 variant member를 하나 이상 가진 경우

• 비유니온(non-union) 집계 타입이며, 각 익명 유니온(anonymous union) 멤버가 다음 조건 중 하나를 만족하는 경우:

• variant member가 없는 경우
• non-volatile literal type의 variant member를 하나 이상 가진 경우

• 복사 또는 이동 생성자가 아닌 constexpr 생성자(템플릿)를 하나 이상 가진 타입

리터럴 타입의 객체만 상수 표현식 내에서 생성될 수 있습니다.

코어 상수 표현식

핵심 상수 표현식 은 다음 언어 구성 요소 중 어떠한 것도 평가하지 않는 표현식을 의미합니다:

1. a function call expression that calls a function (or a constructor) that is not declared constexpr

   constexpr int n = std::numeric_limits<int>::max(); // 정상: max()는 constexpr입니다
   constexpr int m = std::time(nullptr); // 오류: std::time()은 constexpr이 아닙니다

2. a function call to a constexpr function which is declared, but not defined
3. a function call to a constexpr function/constructor template instantiation where the instantiation fails to satisfy constexpr 함수/생성자 requirements.
4. a function call to a constexpr virtual function, invoked on an object whose dynamic type is constexpr-unknown
5. an expression that would exceed the implementation-defined limits
6. an expression whose evaluation leads to any form of core language 정의되지 않음 또는 오류가 있는 (C++26부터) behavior, except for any potential undefined behavior introduced by 표준 속성 .

   constexpr double d1 = 2.0 / 1.0; // 정상
   constexpr double d2 = 2.0 / 0.0; // 오류: 정의되지 않음
   constexpr int n = std::numeric_limits<int>::max() + 1; // 오류: 오버플로우
   int x, y, z[30];
   constexpr auto e1 = &y - &x;        // 오류: 정의되지 않음
   constexpr auto e2 = &z[20] - &z[3]; // 정상
   constexpr std::bitset<2> a; 
   constexpr bool b = a[2]; // UB, 하지만 탐지 여부는 명시되지 않음

7. (C++17 이전) a 람다 표현식
8. an lvalue-to-rvalue 암시적 변환 unless applied to...
   1. (cv 한정자가 있을 수 있는) 타입의 glvalue std::nullptr_t
   2. 상수 표현식에서 사용 가능한 객체를 지정하는 비휘발성 리터럴 타입 glvalue usable in constant expressions

      int main()
      {
          const std::size_t tabsize = 50;
          int tab[tabsize]; // OK: tabsize is a constant expression
                            // because tabsize is usable in constant expressions
                            // because it has const-qualified integral type, and
                            // its initializer is a constant initializer
          std::size_t n = 50;
          const std::size_t sz = n;
          int tab2[sz]; // Error: sz is not a constant expression
                        // because sz is not usable in constant expressions
                        // because its initializer was not a constant initializer
      }

   3. 이 표현식의 평가 내에서 수명이 시작된 비휘발성 객체를 참조하는 비휘발성 리터럴 타입 glvalue
9. an lvalue-to-rvalue 암시적 변환 or modification applied to a non-active member of a union or its subobject (even if it shares a common initial sequence with the active member)
10. an lvalue-to-rvalue implicit conversion on an object 값이 불확정적인
11. an invocation of implicit copy/move constructor/assignment for a union whose active member is mutable (if any), with lifetime beginning outside the evaluation of this expression
12. (C++20 이전) an assignment expression that would change the active member of a union
13. conversion from void에 대한 void 포인터 to a pointer-to-object type T* 포인터가 널 포인터 값을 보유하거나 해당 객체의 타입이 유사한 T 를 가리키지 않는 한 (C++26부터)
14. dynamic_cast 피연산자가 constexpr-unknown 동적 타입을 가진 객체를 참조하는 glvalue인 (C++20부터)
15. reinterpret_cast
16. (C++20 이전) pseudo-destructor call
17. (C++14 이전) an increment or a decrement operator
18. (C++14 이후) modification of an object, unless the object has non-volatile literal type and its lifetime began within the evaluation of the expression

    constexpr int incr(int& n)
    {
        return ++n;
    }
    constexpr int g(int k)
    {
        constexpr int x = incr(k); // 오류: incr(k)는 코어 상수 표현식이 아님
                                   // k의 수명이 incr(k) 표현식 외부에서
                                   // 시작되었기 때문
        return x;
    }
    constexpr int h(int k)
    {
        int x = incr(k); // OK: x는 코어 상수 표현식으로 초기화될
                         // 필요가 없음
        return x;
    }
    constexpr int y = h(1); // OK: y를 값 2로 초기화
                            // h(1)은 코어 상수 표현식임
                            // k의 수명이 h(1) 표현식 내부에서 시작되기 때문

19. (C++20 이후) a destructor call or pseudo destructor call for an object whose lifetime did not begin within the evaluation of this expression
20. a typeid expression applied to a glvalue of polymorphic type 그리고 그 glvalue가 동적 타입이 constexpr-unknown인 객체를 참조하는 경우 (C++20부터)
21. a new 표현식 , 다음 조건 중 하나가 충족되지 않는 한: (C++20부터)

    선택된 allocation function 이 교체 가능한 전역 할당 함수이며 할당된 저장 공간이 이 표현식 평가 내에서 해제되는 경우.	(since C++20)
    선택된 할당 함수가 할당 타입 T 를 갖는 비할당 형식이며, placement 인자가 다음 모든 조건을 만족하는 경우: 다음을 가리킴: T 가 배열 타입이 아닌 경우, T 와 유사한 타입을 가진 객체, 또는 T 가 배열 타입인 경우, T 와 유사한 타입을 가진 객체의 첫 번째 요소. 이 표현식 평가 내에서 지속 시간이 시작된 저장 공간을 가리킴.	(since C++26)

22. a delete 표현식 , 단 이 표현식의 평가 내에서 할당된 저장 영역을 해제하는 경우는 제외 (C++20부터)
23. (C++20 이후) Coroutines: an await-표현식 or a yield-expression
24. (C++20 이후) a 삼항 비교 when the result is unspecified
25. an equality or relational operator whose result is unspecified
26. (C++14 이전) an assignment or a compound assignment operator
27. (C++26 이전) throw 표현식
28. (C++26 이후) 예외 객체의 생성. 단, 예외 객체와 std::current_exception 또는 std::rethrow_exception 호출로 생성된 모든 암시적 복사본이 이 표현식 평가 내에서 파괴되는 경우는 제외

    constexpr void check(int i)
    {
        if (i < 0)
            throw i;
    }
    constexpr bool is_ok(int i)
    {
        try {
            check(i);
        } catch (...) {
            return false;
        }
        return true;
    }
    constexpr bool always_throw()
    {
        throw 12;
        return true;
    }
    static_assert(is_ok(5)); // OK
    static_assert(!is_ok(-1)); // C++26부터 OK
    static_assert(always_throw()); // 오류: 처리되지 않은 예외

29. asm 선언
30. va_arg 매크로 호출
31. goto 문
32. 예외를 발생시킬 dynamic_cast 또는 typeid 표현식 또는 new 표현식 (C++26 이후) 예외 타입의 정의가 도달 가능하지 않은 경우 (C++26 이후)
33. 람다 표현식 내부에서, 해당 참조가 odr-use인 경우 this 또는 해당 람다 외부에서 정의된 변수에 대한 참조

    void g()
    {
        const int n = 0;
        constexpr int j = *&n; // OK: 람다 표현식 외부
        [=]
        {
            constexpr int i = n;   // OK: 'n'은 odr-used되지 않으며 여기서 캡처되지 않음
            constexpr int j = *&n; // 잘못된 형식: '&n'은 'n'의 odr-use가 됨
        };
    }

    odr-use가 클로저에 대한 함수 호출에서 발생하는 경우, 이는 this 또는 둘러싸는 변수를 참조하지 않습니다. 클로저의 데이터 멤버에 접근하기 때문입니다 // OK: 'v'와 'm'은 odr-used되지만 중첩된 람다 내의 상수 표현식에서 발생하지 않음 // 상수 표현식 평가 중 생성된 자동 객체에 대한 캡처를 가질 수 있음 auto monad = [](auto v){ return [=]{ return v; }; }; auto bind = [](auto m){ return [=](auto fvm){ return fvm(m()); }; }; static_assert(bind(monad(2))(monad)() == monad(2)());

    (C++17 이후)

추가 요구사항

표현식 E 가 위에서 언급된 어떤 것도 평가하지 않더라도, E 를 평가했을 때 런타임-정의되지 않은 동작 이 발생한다면 E 가 핵심 상수 표현인지는 구현에 따라 정의됩니다.

표현식 E 가 위에서 언급한 어떤 것도 평가하지 않더라도, E 를 평가할 경우 다음 중 어떤 것을 평가하게 된다면 E 가 핵심 상수 표현식인지 여부는 명시되지 않습니다:

• 표준 라이브러리에서 정의되지 않은 동작을 가진 연산.
• va_start 매크로의 호출.

표현식이 핵심 상수 표현식인지 판단하기 위한 목적으로, std:: allocator < T > 의 멤버 함수 본문 평가는 T 가 리터럴 타입인 경우 무시됩니다.

표현식이 코어 상수 표현식인지 여부를 결정하기 위해, union 의 trivial 복사/이동 생성자 또는 복사/이동 할당 연산자 호출의 평가는 (존재하는 경우) union의 active 멤버를 복사/이동하는 것으로 간주됩니다.

표현식이 핵심 상수 표현식으로 평가되는 동안, 모든 식별자 표현식과 수명이 표현식 평가 외부에서 시작된 객체나 참조를 참조하는 * this 사용은 전체 상수 평가를 포함하는 수명을 가진 해당 객체나 참조의 특정 인스턴스를 참조하는 것으로 처리됩니다.

• 그러한 객체의 경우 상수 표현식에서 사용할 수 없는 객체 (C++20부터) 는 해당 객체의 동적 타입이 constexpr-unknown 입니다.
• 그러한 참조의 경우 상수 표현식에서 사용할 수 없는 (C++20부터) 참조는 참조된 타입의 지정되지 않은 객체에 바인딩되는 것으로 처리되며, 해당 객체와 모든 하위 객체의 수명은 전체 상수 평가를 포함하고 동적 타입은 constexpr-unknown입니다.

정수 상수 표현식

Integral constant expression 는 정수형 또는 범위 없는 열거형 타입의 표현식이 prvalue로 암시적으로 변환된 것으로, 변환된 표현식이 핵심 상수 표현식인 경우를 말합니다.

클래스 타입의 표현식이 정수 상수 표현식이 필요한 곳에서 사용되면, 해당 표현식은 문맥상 암시적으로 변환됩니다 정수 타입이나 비범위 열거형 타입으로.

변환된 상수 표현식

변환된 상수 표현식 은 타입 T 의 표현식이 암시적으로 변환된 것으로, 변환된 표현식이 상수 표현식이고 암시적 변환 시퀀스가 다음 요소들만 포함하는 경우를 말합니다:

• constexpr 사용자 정의 변환
• lvalue-to-rvalue 변환
• 정수 승격
• 비축소 정수 변환
• 부동소수점 승격
• 비축소 부동소수점 변환

그리고 만약 reference binding 이 발생하는 경우, 그것은 오직 direct binding 만 가능합니다.

다음 컨텍스트들은 변환된 상수 표현식이 필요합니다:

• case 레이블 의 constant-expression
• 기본 타입이 고정된 경우의 열거자 초기화식
• 정수 및 열거형 (C++17 이전) 상수 템플릿 인수

bool 타입의 상황적 변환된 상수 표현식 은 표현식으로, bool로 상황적 변환된 , 변환된 표현식이 상수 표현식이고 변환 순서가 위의 변환들만 포함하는 경우입니다.

다음 상황들은 타입 bool 의 문맥상 변환된 상수 표현식을 요구합니다:

• noexcept 명세

상수 평가에 필요한 함수와 변수

다음 표현식 또는 변환은 잠재적으로 상수 평가될 수 있습니다 :

• 명백하게 상수 평가되는 표현식
• 잠재적으로 평가되는 표현식
• 중괄호로 둘러싸인 초기화자 목록 의 직접 하위 표현식 ( 변환이 축소 변환인지 판단 하기 위해 상수 평가가 필요할 수 있음)
• 템플릿 엔티티 내에서 발생하는 주소 연산자 표현식 (해당 표현식이 값 종속적 인지 판단하기 위해 상수 평가가 필요할 수 있음)
• 위 항목들 중 하나의 하위 표현식이면서 중첩된 평가되지 않는 피연산자 의 하위 표현식이 아닌 경우

함수는 constexpr 함수이고 상수 평가될 수 있는 표현식에 의해 이름이 지정된 경우 상수 평가에 필요합니다 .

변수는 상수 평가에 필요합니다 만약 그것이 constexpr 변수이거나, 비휘발성 const 한정 정수 타입이거나 참조 타입이며, 그것을 나타내는 식별자 표현식 이 잠재적으로 상수 평가되는 경우입니다.

디폴트 함수의 정의와 함수 템플릿 특수화의 인스턴스화 또는 변수 템플릿 특수화 (C++14부터) 는 상수 평가를 위해 해당 함수 또는 변수가 (C++14부터) 필요한 경우 트리거됩니다.

상수 부분식

상수 부분식(constant subexpression) 은 부분식 으로서의 평가가 식 e 를 핵심 상수 식(core constant expression) 이 되지 못하게 하지 않는 식이며, 여기서 e 는 다음 표현식들 중 어느 것도 아닙니다:

• throw 표현식

• 대입 표현식
• 쉼표 표현식

참고 사항

예제

결함 보고서

다음의 동작 변경 결함 보고서들은 이전에 발표된 C++ 표준에 소급 적용되었습니다.

참고 항목