Просмотр кода страницы cpp/language/constant expression

У вас нет прав на выполнение действия «редактирование этой страницы» по следующей причине:
Запрошенное действие могут выполнять участники одной из следующих групп: Участники, Администраторы.
Вы можете просмотреть и скопировать исходный код этой страницы.
{{title|Константные выражения}}
{{cpp/language/expressions/navbar}}

Определяет {{rlp|expressions|выражение}}, которое можно вычислить во время компиляции.

Такие выражения могут использоваться как аргументы шаблона, не относящиеся к типу, размеры массива и в других контекстах, требующих константных выражений, например
{{source|1=
int n = 1;
std::array<int, n> a1; // ошибка: n не является константным выражением
const int cn = 2;
std::array<int, cn> a2; // OK: cn является константным выражение
}}

===Основные константные выражения===
''Основные константные выражения'' это любое выражение, оценка которого ''не будет'' оценивать одно из следующего:
<ol>
<li> указатель {{rlpt|this}}, за исключением в {{rlp|constexpr#constexpr функции|constexpr функции}}, которая оценивается как часть выражения
<li> {{mark unreviewed dr|CWG|2552}} поток управления, который проходит через объявление переменной с не {{rlp|constexpr}} статической или потоковой {{rlp|storage duration|длительностью хранения}}, и [[#Используемые в константных выражениях|неприменимый в константных выражениях]]
<li> выражение вызова функции, которое вызывает функцию (или конструктор), которая не объявлена как {{rlp|constexpr}} 
{{source|1=
constexpr int n = std::numeric_limits<int>::max(); // OK: max() является constexpr
constexpr int m = std::time(nullptr); // Ошибка: std::time() не constexpr
}}
<li> вызов функции для объявленной, но не определённой функции constexpr
<li> {{mark unreviewed dr|CWG|1872}} вызов функции для создания экземпляра шаблона функции/конструктора constexpr, где создание не соответствует требованиям {{rlp|constexpr|constexpr функции/конструктора}}.
<li class="t-rev-inl t-rev-inl-noborder t-until-cxx20"> <span>{{mark since c++20}} вызов виртуальной constexpr функции, вызванной для объекта, не [[#Используемые в константных выражениях|''используемого в константных выражениях'']] и чьё время жизни началось вне этого выражения.</span>
<li> выражение, выходящее за лимиты, определённые реализацией
<li> выражение, вычисление которого приводит к любой форме неопределённого поведения базового языка{{mark unreviewed dr|CWG|1952}} (включая переполнение целого числа со знаком, деление на ноль, арифметику указателя вне границ массива и т.д.).{{mark unreviewed dr|CWG|1313}} Неопределено, обнаруживается ли неопределённое поведение стандартной библиотеки.
{{source|1=
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]; // Неопределённое поведение, но не указывается, если обнаружено
}}
<li>{{mark until c++17}} {{rlp|lambda|лямбда-выражение}}
<li> {{rlp|implicit conversion|неявное преобразование}} lvalue-в-rvalue, если оно не применяется к не-volatile glvalue литерального типа, которое ...
<ol type="a">
<li> обозначает объект, который [[#Используемые в константных выражениях|''можно использовать в константных выражениях'']],  
{{source|1=
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 не может использоваться в константных выражениях,
                  // потому что его инициализатор не является константным инициализатором
}
}}
<li> ссылается на не volatile объект, время жизни которого началось в пределах оценки этого выражения
</ol>
<li>  {{rlp|implicit conversion|неявное преобразование}} lvalue-в-rvalue или модификация, применяемая к неактивному элементу {{rlp|union}} или его подобъекту (даже если он имеет общую начальную последовательность с активным элементом)
<li> неявное преобразование lvalue-to-rvalue для объекта, {{rlp|default initialization|значение которого неопределенно}}
<li> {{mark unreviewed dr|cwg|2268}} вызов неявного конструктора/присваивания копированием/перемещением для объединения, активный элемент которого является mutable (если есть), с началом времени жизни вне оценки этого выражения
<li> {{mark until c++20}} выражение присваивания, которое изменяет активный элемент объединения
<li> {{spar|выражение-идентификатор}}, ссылающееся на переменную или элемент данных ссылочного типа, за исключением случаев, когда ссылка [[#Используемые в константных выражениях|''может использоваться в константных выражениях'']] или её время жизни началось в пределах оценки этого выражения
<li> преобразование из [[cpp/language/pointer#Указатели на void|указателя на {{c/core|void}}]] {{rev inl|until=c++26| в любой тип указателя на объект}} {{rev inl|since=c++26| в тип указателя на объект {{c|T*}}, если указатель не указывает на объект, тип которого подобен {{c|T}} (смотрите также [[#Примечание|Примечание]] ниже)}}
<li>{{mark until c++20}}{{rlpt|dynamic_cast}}
<li> {{rlpt|reinterpret_cast}}
<li>{{mark until c++20}} вызов псевдодеструктора
<li>{{mark until c++14}} операторы инкремента или декремента
<li>
{{mark since c++14}} изменение объекта, за исключением случаев, когда объект имеет не volatile литеральный тип и его время жизни началось в пределах оценки выражения
{{source|1=
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: не требуется инициализировать с помощью
                   // основного константного выражения
  return x;
}
constexpr int y = h(1); // OK: инициализирует y значением 2
                        // h(1) является основным константным выражением, потому что
                        // время жизни k начинается внутри выражения h(1)
}}
<li> {{mark since c++20}} вызов деструктора или вызов псевдодеструктора для объекта, время жизни которого не началось при оценке этого выражения
<li>{{mark until c++20}} выражение {{rlpt|typeid}}, применённое к glvalue полиморфного типа
<li> {{rlp|new|выражение new}}{{rev inl|since=c++20| или вызов {{lc|std::allocator::allocate|std::allocator<T>::allocate}}, если только выбранная [[cpp/memory/new/operator new|функция распределения]] не является заменяемой глобальной функцией распределения, и выделенное хранилище освобождается при вычислении этого выражения}}
<li> {{rlp|delete|выражение delete}}{{rev inl|since=c++20| или вызов {{lc|std::allocator::deallocate|std::allocator<T>::deallocate}}, если он не освобождает область памяти, выделенную при вычислении этого выражения}}
<li> {{mark since c++20}} Сопрограммы: {{rlp|coroutines#co_await|выражение await}} или {{rlp|coroutines#co_yield|выражение yield}}
<li> {{mark since c++20}} {{rlp|operator comparison#Трёхстороннее сравнение|трёхстороннее сравнение}}, если результат не указан
<li> оператор равенства или отношения, результат которого не указан
<li> {{mark until c++14}} оператор присваивания или составной оператор присваивания
<li> выражение throw
<li> {{rlp|asm|объявление asm}}
<li> вызов макроса {{lc|va_arg}}, может ли быть оценён вызов макроса {{lc|va_start}}, не указано
<li> оператор {{rlpt|goto}}
<li> выражение {{rlpt|dynamic_cast}} или {{rlpt|typeid}}, которое вызовет исключение
<li> внутри лямбда-выражения ссылка на {{c|this}} или на переменную, определённую вне этой лямбды, если эта ссылка была бы использована ODR{{mark unreviewed dr|CWG|1613}}
{{source|1=
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'.
     };
}
}}
{{rrev|since=c++17|
обратите внимание, что если использование ODR происходит при вызове функции для замыкания, оно не ссылается на {{c|this}} или включающую переменную, поскольку вместо этого обращается к элементу данных замыкания
{{source|1=
// OK: 'v' & 'm' используются ODR, но не встречаются в константном выражении
// внутри вложенной лямбда
auto monad = [](auto v){return [=]{return v;};};
auto bind = [](auto m){return [=](auto fvm){return fvm(m());};};
// OK, имеется возможность захватывать автоматические объекты,
// созданные во время вычисления константного выражения.
static_assert(bind(monad(2))(monad)() == monad(2)());
}}
}}
</ol>

{{todo|нужно больше мини-примеров и меньше стандартных}}

Примечание: Просто быть ''основным константным выражением'' не имеет прямого семантического значения: выражение должно быть одним из подмножеств константных выражений (смотрите ниже) для использования в определённых контекстах.

===Константное выражение===
''Константное выражение'' это либо
* {{rev inl|until=c++14|lvalue}}{{rev inl|since=c++14|glvalue}} ''основное константное выражение'', которое ссылается на
:* объект со статической длительностью хранения, который не является временным, или
{{rrev|since=c++14|
:* объект со статической длительностью хранения, который является временным, но значение которого соответствует ограничениям для значений prvalue, упомянутые ниже, или
}}
:* {{rev inl|since=c++20|не {{rlp|consteval|немедленная}}}} функция
* ''основное константное выражение'' prvalue, значение которого соответствует следующим ограничениям:
:* если значение является объектом классового типа, каждый нестатический элемент данных ссылочного типа ссылается на сущность, которая соответствует ограничениям для {{rev inl|until=c++14|lvalues}}{{rev inl|since=c++14|glvalues}}, упомянутые выше
:* если значение имеет тип указателя, оно содержит
::* адрес объекта со статической длительностью хранения
::* адрес за концом объекта со статической длительностью хранения
::* адрес {{rev inl|since=c++20|не {{rlp|consteval|немедленной}}}} функции
::* значение нулевого указателя
{{rrev|since=c++20|
:* если значение имеет тип указателя на функцию-элемент, оно не обозначает {{rlp|consteval|немедленную функцию}}
}}
:* если значение является объектом типа класса или массива, каждый подобъект соответствует этим ограничениям для значений

{{todo|список контекстов, требующих константных выражений, которые не являются целыми/преобразованными?}}

{{source|1=
void test() {
    static const int a = std::random_device{}();
    constexpr const int& ra = a; // OK: a это константное выражение glvalue
    constexpr int ia = a; // Ошибка: a не является константным выражением prvalue

    const int b = 42;
    constexpr const int& rb = b; // Ошибка: b не является константным выражением glvalue
    constexpr int ib = b; // OK: b это константное выражение prvalue
}
}}

====Целочисленное константное выражение====
''Целочисленное константное выражение'' это выражение целочисленного типа или типа перечисления без области видимости, неявно преобразованное в prvalue, где преобразованное выражение является ''базовым константным выражением''. Если выражение типа класса используется там, где ожидается целочисленное константное выражение, выражение {{rlp|implicit_cast|контекстуально неявно преобразуется}} в целочисленный тип или тип перечисления без области видимости.

Следующие контексты требуют ''целочисленное константное выражение'':

{{rrev|until=c++14|
* {{rlp|array|границы массива}}
* размерности в {{rlp|new|выражениях new}} кроме первой
}}
* {{rlp|bit_field|длины битовых полей}}
* инициализаторы перечисления, когда базовый тип не фиксирован
* {{rlp|alignas|выравнивания}}.

====Преобразованное константное выражение====
''Преобразованное константное выражение'' типа {{tt|T}} это выражение {{rlp|implicit cast|неявно преобразованное}} к типу T, где преобразованное выражение является константным выражением, а последовательность неявного преобразования содержит только:
:* определяемые пользователем constexpr преобразования (так что класс может использоваться там, где ожидается целочисленный тип)
:* преобразования lvalue-в-rvalue
:* целочисленные продвижения
:* не сужающие целочисленные преобразования
{{rev begin}}
{{rev|since=c++17|
:* преобразования массив-в-указатель
:* преобразования функции-в-указатель
:* преобразование указателя на функцию (указатель на функцию noexcept в указатель на функцию)
:* квалификационные преобразования
:* преобразования нулевого указателя из {{lc|std::nullptr_t}}
:* преобразования нулевого указателя на элемент из {{lc|std::nullptr_t}}
}}
{{rev end}}
:* И если какая-либо {{rlp|reference initialization|привязка ссылки}} имеет место, это прямая привязка (а не та, которая создаёт временный объект)

В следующих контекстах требуется ''преобразованное константное выражение'':
* {{rlp|switch|выражения case}}
* {{rlp|enum|инициализаторы перечислителя}}, когда базовый тип фиксирован

{{rrev|since=c++14|
* {{rlp|array|границы массива}}
* измерения в {{rlp|new|выражениях new}} кроме первого
}}
* {{rev inl|until=c++17|целочисленные и перечисляемые }} {{rlp|template parameters|аргументы шаблона}}, не относящиеся к типу.

''Контекстно преобразованное константное выражение типа {{c/core|bool}}'' это выражение,  {{rlp|implicit cast#Контекстные преобразования|контекстно преобразованное в {{c/core|bool}}}}, где преобразованное выражение является константным выражением, а последовательность преобразования содержит только указанные выше преобразования.

Следующие контексты требуют ''контекстно преобразованное константное выражение типа {{c/core|bool}}'':

* {{rlp|noexcept spec|спецификации {{c/core|noexcept}}}}
{{rrev|until=c++23|
* {{rlp|static_assert|объявления {{c/core|static_assert}}}}
}}
{{rrev|since=c++17|until=c++23|
* {{rlp|if#Constexpr if|операторы constexpr {{tt|if}}}}
}}
{{rrev|since=c++20|
* {{rlp|explicit|условные {{c/core|explicit}} спецификаторы}}
}}

====Исторические категории====
Категории константных выражений, перечисленные ниже, больше не используются в стандарте начиная с C++14:

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

* ''Ссылочное константное выражение'' это базовое константное выражение lvalue, которое обозначает объект со статической длительностью хранения или функцию.

* ''Адресное константное выражение'' это основное константное выражение prvalue (после преобразований, требуемых контекстом) типа {{lc|std::nullptr_t}} или типа указателя, который указывает на объект со статической длительностью хранения, указывает за конец массива со статической длительностью хранения, на функцию или является нулевым указателем.

{{rrev|since=c++17|
===Константное подвыражение===
''Константное подвыражение'' это выражение, оценка которого как {{rlp|expressions#Полные выражения|подвыражения}} выражения {{c|e}} не помешала бы {{c|e}} быть [[#Основные константные выражения|основным константным выражением]], где {{c|e}} не равно ни одному из следующих выражений:
* {{rlp|throw|выражение {{tt|throw}}}}
{{rrev|since=c++20|
* {{rlp|coroutines|выражение yield}}
}}
* {{rlp|operator assignment|выражение присваивания}}
* {{rlp|operator other#Встроенный оператор запятая|оператор запятая}}
}}

===Используемые в константных выражениях===
В приведённом выше списке переменная ''может использоваться в константных выражениях'' в точке {{ttb|P}}, если

* переменная это
:* переменная constexpr, или
:* это переменная {{rlp|constant initialization|с константной инициализацией}}
::* ссылочного типа или
::* const-квалифицированного целого или перечислимого типа
* и определение переменной достижимой из {{ttb|P}}

{{rrev|since=c++20|
* и, если {{ttb|P}} не находится в той же единице трансляции, что и определение переменной (то есть определение {{rlp|modules|импортировано}}), переменная не инициализируется, чтобы указывать или ссылаться на или иметь (возможно, рекурсивный) подобъект, который указывает или ссылается на {{rlp|tu_local|локальную сущность единицы трансляции}}, которую можно использовать в константных выражениях
}}

Объект или ссылка ''могут использоваться в константных выражениях'', если они
* переменная, которая ''может использоваться в константных выражениях'', или
{{rrev|since=c++20|
* {{rlp|template_parameters#Не тип параметр шаблона|объект параметра шаблона}}, или
}}
* объект строкового литерала, или
* не mutable подобъект или ссылочный элемент из всех вышеперечисленных, или
* временный объект не volatile const-квалифицированного литерального типа, время жизни которого {{rlp|reference initialization#Время жизни временного объекта|продлено}} до времени жизни переменной, которую можно использовать в константных выражениях.

{{source|1=
const std::size_t sz = 10; // sz можно использовать в константных выражениях
}}

===Явно константно вычисляемые выражения===
Следующие выражения (включая преобразования в целевой тип) ''вычисляются явно и константно'':

:* {{rlp|array|границы массива}}
:* измерения в {{rlp|new|выражениях new}}, кроме первого
:* {{rlp|bit field|длины битовых полей}}
:* {{rlp|enum|инициализаторы перечислений}}
:* {{rlp|alignas|выравнивания}}
:* {{rlp|switch|выражения {{c/core|case}}}}
:* {{rlp|template parameters|аргументы шаблона}} не типы
:* выражения в {{rlp|noexcept spec|спецификациях {{c/core|noexcept}}}}
:* выражения в {{rlp|static assert|объявлениях {{c/core|static_assert}}}}
:* инициализаторы {{rlp|constexpr|переменных constexpr}}
{{rrev|since=c++17|
:* условия {{rlp|if#Constexpr if|операторов constexpr if}}
}}
{{rrev|since=c++20|
:* выражения в {{rlp|explicit|условных {{c/core|explicit}} спецификаторах}}
:* {{rlp|consteval|немедленные вызовы}}
:* выражения ограничений в определениях {{rlp|constraints#Концепты|концептов}}, {{rlp|constraints#Вложенные требования|вложенных требованиях}} и {{rlp|constraints#Предложения requires|предложениях requires}}, при определении того, удовлетворены ли ограничения<!-- они не оцениваются во время определения -->
}}
* Где также допускается неконстантное выражение, в том числе:
:* инициализаторы переменных ссылочного типа, целочисленного или перечислимого типа с квалификацией const, но только если инициализаторы являются константными выражениями
:* инициализаторы статических и локальных переменных потока, но только если все подвыражения инициализаторов (включая вызовы конструкторов и неявные преобразования) являются константными выражениями (то есть, если инициализаторы являются {{rlp|constant initialization|константными инициализаторами}})

{{rrev|since=c++20|
То, происходит ли оценка в явно константно оцениваемом контексте, можно определить с помощью {{lc|std::is_constant_evaluated}}{{rev inl|since=c++23| и {{rlpt|if#Consteval if|if consteval}}}}.

Чтобы проверить последние два условия, компиляторы могут сначала выполнить пробную константную оценку инициализаторов. Не рекомендуется в этом случае зависеть от результата.
{{source|1=
int y = 0;
const int a = std::is_constant_evaluated() ? y : 1;
// Пробная константная оценка не удалась. Константная оценка отбрасывается.
// Переменная a динамически инициализируется 1

const int b = std::is_constant_evaluated() ? 2 : y;
// Константная оценка с помощью std::is_constant_evaluation() == true выполняется успешно.
// Переменная b статически инициализируется значением 2
}}
}}

===Функции и переменные, нуждающиеся в константной оценке===
Следующие выражения или преобразования ''потенциально вычисляются константно'':
* явно константно оценённые выражения
* потенциально оценённые выражения
* немедленные подвыражения списка-инициализации в фигурных скобках (может потребоваться константная оценка, чтобы определить, {{rlp|list initialization#Сужающие преобразования|является ли преобразование сужающим}})
* выражения взятия адреса (унарный {{tt|&}}), встречающиеся в {{rlp|templates#Шаблонная сущность|шаблонной сущности}} (может потребоваться константная оценка, чтобы определить, является ли такое выражение {{rlp|dependent name#Выражения, зависящие от значения|зависимым от значения}})
* подвыражения одного из вышеперечисленных выражений, не являющиеся подвыражениями вложенного {{rlp|expressions#Невычисляемые выражения|неоценённого операнда}}

Функция ''нуждается в константной оценке'', если эта функция constexpr и {{rlp|definition#Именование функции|именована}} выражением, которое потенциально может быть оценено константно.

Переменная ''нуждается в константной оценке'', если она является либо переменной constexpr, либо имеет не volatile целочисленный тип с квалификацией const или ссылочный тип и {{rlp|expressions#Перв��чные выражения|выражение идентификатора}}, которые означают, что это потенциально константная оценка.

Определение функции по умолчанию и создание специализации {{rlp|function template|шаблона функции}} {{rev inl|since=c++14|или специализации {{rlp|variable template|шаблона переменной}}}} запускается, если функция {{rev inl|since=c++14|или переменная}} нуждается в константной оценке.

===Примечание===
Реализациям не разрешается объявлять библиотечные функции как {{c/core|constexpr}}, если в стандарте не указано, что функция является {{c/core|constexpr}} {{mark unreviewed dr|LWG}}<!-- это было LWG #2013 -->

{{rlp|copy elision|Оптимизация именованного возвращаемого значения}} (NRVO - Named return value optimization) не допускается в константных выражениях<!-- это было CWG 2278 -->, а оптимизация возвращаемого значения (RVO - return value optimization) является обязательной.{{mark unreviewed dr|CWG}}<!-- это было CWG 2022 -->
{{ftm begin|core=1|std=1|comment=1}}
{{ftm|value=201711L|std=C++11|dr=1|__cpp_constexpr_in_decltype|Генерация определений функций и переменных, когда это [[#Функции и переменные, нуждающиеся в константной оценке|необходимо для константной оценки]]}}
{{ftm|value=201907L|std=C++20|__cpp_constexpr_dynamic_alloc|Операции для динамической длительности хранения в функциях {{c/core|constexpr}}}}
{{ftm|std=C++26|value=202306L|__cpp_constexpr|Приведение constexpr из {{c/core|void*}}: в сторону стирания типа constexpr}}
{{ftm end}}

===Отчёты о дефектах===
{{dr list begin}}
{{dr list item|wg=cwg|dr=1293|std=C++11|before=не было указано, можно ли использовать строковые<br>литералы в константных выражениях|after=они пригодны для использования}}
{{dr list item|wg=cwg|dr=1311|std=C++11|before=volatile glvalue можно использовать<br>в константных выражениях|after=запрещено}}
{{dr list item|wg=cwg|dr=1312|std=C++11|before={{c/core|reinterpret_cast}} запрещён в константных выражениях, но<br>приведение к {{c/core|void*}} и обратно может дать тот же эффект|after=запрещены преобразования из типа <span class="t-c">''cv'' {{c/core|void*}}</span><br>в тип указателя на объект}}
{{dr list item|wg=cwg|dr=1313|std=C++11|before=разрешено неопределённое поведение;<br>все вычитания указателей были запрещены|after=неопределённое поведение запрещено;<br>вычитание указателей одного и того же массива ОК}}
{{dr list item|wg=cwg|dr=1405|std=C++11|before=для объектов, которые можно использовать в константных<br>выражениях, их mutable подобъекты также можно было<br>использовать|after=они не пригодны для использования}}
{{dr list item|wg=cwg|dr=1454|std=C++11|before=передача констант через функции constexpr посредствам<br>ссылок была запрещена|after=разрешено}}
{{dr list item|wg=cwg|dr=1455|std=C++11|before=преобразованные константные выражения могут быть<br>только prvalue|after=могут быть lvalue}}
{{dr list item|wg=cwg|dr=1456|std=C++11|before=константное выражение адреса не может обозначать адрес,<br>следующий за концом массива|after=разрешено}}
{{dr list item|wg=cwg|dr=1535|std=C++11|before=выражение {{c/core|typeid}}, операнд которого относится к типу полиморфного<br>класса, не было основным константым выражением, даже если<br>проверка во время выполнения не выполнялась|after=ограничение операнда ограничено значениями glvalue<br>полиморфных классовых типов}}
{{dr list item|wg=cwg|dr=1581|std=C++11|before=функции, необходимые для константной оценки, не<br>требовалось определять или создавать экземпляры|after=требуется}}<!-- P0859R0 -->
{{dr list item|wg=cwg|dr=1694|std=C++11|before=привязка значения временного объекта к ссылке со<br>статической длительностью хранения была константным выражением|after=это не константное выражение}}
{{dr list item|wg=cwg|dr=1952|std=C++11|before=требовалось диагностировать неопределённое поведение<br>стандартной библиотеки|after=не указано, диагностировала ли библиотека<br>неопределённое поведение}}
{{dr list item|wg=cwg|dr=2126|std=C++11|before=константные инициализированные временные объекты с расширенным<br>временем жизни const-квалифицированных литеральных типов нельзя<br>было использовать в константных выражениях|after=можно использовать}}
{{dr list item|wg=cwg|dr=2167|std=C++11|before=ссылки, не являющиеся элементами, локальные для оценки,<br>сделали оценку не constexpr|after=разрешены ссылки, не являющиеся элементами}}
{{dr list item|wg=cwg|dr=2299|std=C++14|before=было неясно, можно ли использовать макросы<br>из {{header|cstdarg}} в константной оценке|after={{tt|va_arg}} запрещено, {{tt|va_start}} не указано}}
{{dr list item|wg=cwg|dr=2418|std=C++11|before=не было указано, какой объект или ссылка, не являющиеся<br>переменными, можно использовать в константных выражениях|after=указано}}
{{dr list item|wg=cwg|dr=2490|std=C++20|before=(псевдо) вызовам деструктора не хватало ограничений<br>при константной оценке|after=ограничение добавлено}}
{{dr list end}}

===Смотрите также===
{{dsc begin}}
{{dsc inc | cpp/language/dsc constexpr}}
{{dsc inc | cpp/types/dsc is_literal_type}}
{{dsc see c | c/language/constant_expression | Константные выражения | nomono=true}}
{{dsc end}}

{{langlinks|en|es|ja|zh}}
Шаблоны, используемые на этой странице:
Возврат к странице cpp/language/constant expression.
cppreference.com

Поиск

Пространства имён

Варианты

Просмотры

Действия

Просмотр кода страницы cpp/language/constant expression

Навигация

Инструменты
