Constant expressions

Определяет выражение , которое может быть вычислено во время компиляции.

Такие выражения могут использоваться в качестве константных аргументов шаблонов, размеров массивов и в других контекстах, требующих константных выражений, например.

int n = 1;
std::array<int, n> a1;  // Ошибка: "n" не является константным выражением
const int cn = 2;
std::array<int, cn> a2; // OK: "cn" является константным выражением

Определение

При определении того, является ли выражение константным выражением, copy elision предполагается не выполняемым.

Определение константных выражений в C++98 полностью находится в сворачиваемом блоке. Следующее описание применяется к C++11 и более поздним версиям C++.

Литеральный тип

Следующие типы в совокупности называются literal types :

• возможно cv-квалифицированный void
• скалярный тип
• ссылочный тип
• массив литерального типа
• возможно cv-квалифицированный классовый тип, удовлетворяющий всем следующим условиям:

• Он имеет тривиальный деструктор (до C++20) constexpr деструктор (начиная с C++20) .
• Все его нестатические невариантные члены данных и базовые классы являются не-volatile литеральными типами.
• Он является одним из следующих типов:

• агрегатный тип объединения , удовлетворяющий одному из следующих условий:

• Не имеет вариантного члена .
• Имеет хотя бы один вариантный член не-volatile литерального типа.

• не-объединенный агрегатный тип, и каждый из его анонимных членов объединения удовлетворяет одному из следующих условий:

• Не имеет вариантного члена.
• Имеет хотя бы один вариантный член не-volatile литерального типа.

• тип с хотя бы одним 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(); // OK: 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 undefined или ошибочно (since C++26) behavior, except for any potential undefined behavior introduced by стандартные атрибуты .

   constexpr double d1 = 2.0 / 1.0; // OK
   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]; // OK
   constexpr std::bitset<2> a; 
   constexpr bool b = a[2]; // UB, но не определено, будет ли обнаружено

7. (до C++17) a лямбда-выражение
8. an lvalue-to-rvalue неявное преобразование unless applied to...
   1. glvalue типа (возможно cv-квалифицированного) std::nullptr_t
   2. не-volatile glvalue литерального типа, который обозначает объект, пригодный для использования в константных выражениях

      int main()
      {
          const std::size_t tabsize = 50;
          int tab[tabsize]; // OK: tabsize является константным выражением
                            // потому что tabsize пригоден для использования в константных выражениях
                            // поскольку имеет const-квалифицированный целочисленный тип, и
                            // его инициализатор является константным инициализатором
          std::size_t n = 50;
          const std::size_t sz = n;
          int tab2[sz]; // Ошибка: sz не является константным выражением
                        // потому что sz не пригоден для использования в константных выражениях
                        // поскольку его инициализатор не был константным инициализатором
      }

   3. не-volatile glvalue литерального типа, который ссылается на не-volatile объект, время жизни которого началось в процессе вычисления данного выражения
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 to a pointer-to-object type T* если только указатель не содержит нулевое значение указателя или не указывает на объект, тип которого подобен типу T (начиная с C++26)
14. dynamic_cast операнд которого является glvalue, ссылающейся на объект, чей динамический тип является constexpr-неизвестным (since 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-неизвестным (since C++20)
21. a new выражение , если не выполняется одно из следующих условий: (since C++20)

    Выбранная функция выделения памяти является заменяемой глобальной функцией выделения памяти, и выделенная память освобождается в процессе вычисления данного выражения.

    (since C++20)

    Выбранная функция выделения памяти является невыделяющей формой с выделяемым типом T , и аргумент размещения удовлетворяет всем следующим условиям: Он указывает на: объект, тип которого подобен T , если T не является типом массива, или первый элемент объекта типа, подобного T , если T является типом массива. Он указывает на память, время жизни которой началось в процессе вычисления данного выражения.

    (since C++26)

22. a delete выражение , если только он не освобождает область памяти, выделенную в ходе вычисления данного выражения (since C++20)
23. (начиная с C++20) Coroutines: an выражение await or a yield-выражение
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)); // OK начиная с C++26
    static_assert(always_throw()); // Ошибка: неперехваченное исключение

29. asm-объявление asm-declaration
30. вызов макроса va_arg
31. оператор goto
32. выражение dynamic_cast или typeid или выражение new expression (начиная с C++26) которое может сгенерировать исключение когда определение типа исключения недоступно (начиная с C++26)
33. внутри лямбда-выражения - ссылка на this или на переменную, определенную вне этой лямбды, если эта ссылка является odr-использованием

    void g()
    {
        const int n = 0;
        constexpr int j = *&n; // OK: вне лямбда-выражения
        [=]
        {
            constexpr int i = n;   // OK: 'n' не odr-используется и не захватывается здесь
            constexpr int j = *&n; // Некорректно: '&n' было бы odr-использованием 'n'
        };
    }

    обратите внимание, что если odr-использование происходит в вызове функции замыкания, оно не ссылается на this или на охватывающую переменную, поскольку обращается к члену данных замыкания // OK: 'v' и 'm' odr-используются, но не встречаются в константном выражении // внутри вложенной лямбды 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 core constant expression, если вычисление E привело бы к неопределённому поведению во время выполнения .

Даже если выражение E не вычисляет ничего из перечисленного выше, не определено, является ли E core constant expression, если вычисление E потребовало бы вычисления любого из следующего:

• Операция с неопределённым поведением в стандартной библиотеке .
• Вызов макроса va_start .

Для целей определения, является ли выражение ядерным константным выражением, вычисление тела функции-члена std:: allocator < T > игнорируется, если T является литеральным типом.

Для целей определения, является ли выражение ядерным константным выражением, вычисление вызова тривиального копирующего/перемещающего конструктора или копирующего/перемещающего оператора присваивания union считается копирующим/перемещающим активный член union, если таковой имеется.

При оценке выражения как основного константного выражения все выражения идентификаторов и использования * this , которые ссылаются на объект или ссылку, время жизни которых началось вне оценки выражения, рассматриваются как ссылающиеся на конкретный экземпляр этого объекта или ссылки, время жизни которого и всех подобъектов (включая все члены объединений) охватывает всю константную оценку.

• Для такого объекта который не может использоваться в константных выражениях (начиная с C++20) , динамический тип объекта является constexpr-unknown .
• Для такой ссылки которая не может использоваться в константных выражениях (начиная с C++20) , ссылка рассматривается как привязанная к неопределенному объекту ссылочного типа, время жизни которого и всех подобъектов включает всю константную оценку и чей динамический тип является constexpr-unknown.

Целочисленное константное выражение

Целочисленное константное выражение - это выражение целочисленного типа или типа неограниченного перечисления, неявно преобразованное в prvalue, где преобразованное выражение является ядерным константным выражением.

Если выражение классового типа используется там, где ожидается целочисленное константное выражение, выражение контекстно неявно преобразуется в целочисленный тип или тип неограниченного перечисления.

Преобразованное константное выражение

Преобразованное константное выражение типа T - это выражение, неявно преобразованное к типу T , где преобразованное выражение является константным выражением, и последовательность неявного преобразования содержит только:

• constexpr пользовательские преобразования
• преобразования lvalue-to-rvalue
• целочисленные повышения
• non-narrowing целочисленные преобразования
• повышения плавающей точки
• non-narrowing преобразования плавающей точки

И если происходит любое reference binding , оно может быть только direct binding .

Следующие контексты требуют конвертируемого константного выражения:

• константное выражение constant-expression в case labels
• инициализаторы перечислений когда базовый тип фиксирован
• целочисленные и перечислимые (until C++17) константные template arguments

Контекстуально преобразованное константное выражение типа bool — это выражение, контекстуально преобразуемое в bool , где преобразуемое выражение является константным выражением, а последовательность преобразования содержит только указанные выше преобразования.

Следующие контексты требуют контекстно преобразованного константного выражения типа bool :

• noexcept спецификации

Функции и переменные, необходимые для константной оценки

Следующие выражения или преобразования являются потенциально константно вычисляемыми :

• явно константно-вычисляемые выражения
• потенциально вычисляемые выражения
• непосредственные подвыражения списка инициализации в фигурных скобках (константное вычисление может потребоваться для определения, является ли преобразование сужающим )
• выражения взятия адреса, встречающиеся внутри шаблонной сущности (константное вычисление может потребоваться для определения, является ли такое выражение зависимым по значению )
• подвыражения одного из вышеперечисленных, не являющиеся подвыражением вложенного невычисляемого операнда

Функция требуется для константного вычисления если она является constexpr функцией и вызывается выражением, которое потенциально вычисляется константно.

Переменная требуется для константной оценки если она является либо constexpr переменной, либо имеет не-volatile const-квалифицированный целочисленный тип или тип ссылки, и выражение-идентификатор которое её обозначает потенциально константно оценивается.

Определение функции по умолчанию и инстанцирование специализации шаблона функции или специализации шаблона переменной (since C++14) запускаются, если функция или переменная (since C++14) требуется для константного вычисления.

Постоянное подвыражение

Постоянное подвыражение — это выражение, вычисление которого в качестве подвыражения выражения e не препятствовало бы тому, чтобы e являлось ядерным константным выражением , при условии что e не является ни одним из следующих выражений:

• throw выражение

• выражение присваивания
• оператор запятая

Примечания

Пример

Отчеты о дефектах

Следующие отчеты об изменениях в поведении, являющиеся дефектными, были применены ретроактивно к ранее опубликованным стандартам C++.

Смотрите также