Constant expressions

Define una expresión que puede ser evaluada en tiempo de compilación.

Tales expresiones pueden utilizarse como argumentos de plantilla constantes, tamaños de array, y en otros contextos que requieran expresiones constantes, p. ej.

int n = 1;
std::array<int, n> a1;  // Error: “n” no es una expresión constante
const int cn = 2;
std::array<int, cn> a2; // OK: “cn” es una expresión constante

Definición

Al determinar si una expresión es una expresión constante, copy elision se asume que no se realiza.

La definición de C++98 de expresiones constantes está completamente dentro del cuadro colapsable. La siguiente descripción se aplica a C++11 y versiones posteriores de C++.

Tipo literal

Los siguientes tipos se denominan colectivamente literal types :

• posiblemente calificado cv void
• tipo escalar
• tipo referencia
• un array de tipo literal
• tipo de clase posiblemente calificado cv que satisface todas las siguientes condiciones:

• Tiene un trivial destructor (until C++20) constexpr destructor (since C++20) .
• Todos sus miembros de datos no estáticos no variantes y clases base son de tipos literales no volátiles.
• Es uno de los siguientes tipos:

• un tipo de unión agregado que satisface una de las siguientes condiciones:

• No tiene ningún miembro variante .
• Tiene al menos un miembro variante de tipo literal no volátil.

• un tipo agregado no unión, y cada uno de sus miembros de unión anónima satisface una de las siguientes condiciones:

• No tiene ningún miembro variante.
• Tiene al menos un miembro variante de tipo literal no volátil.

• un tipo con al menos un constructor (plantilla) constexpr que no sea un constructor de copia o movimiento

Solo los objetos de tipos literales pueden crearse dentro de una expresión constante.

Expresión constante principal

Una expresión constante principal es cualquier expresión cuya evaluación no evaluaría ninguna de las siguientes construcciones del lenguaje:

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() es constexpr
   constexpr int m = std::time(nullptr); // Error: std::time() no es 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 función/constructor 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 o erróneo (since C++26) behavior, except for any potential undefined behavior introduced by atributos estándar .

   constexpr double d1 = 2.0 / 1.0; // OK
   constexpr double d2 = 2.0 / 0.0; // Error: no definido
   constexpr int n = std::numeric_limits<int>::max() + 1; // Error: desbordamiento
   int x, y, z[30];
   constexpr auto e1 = &y - &x;        // Error: indefinido
   constexpr auto e2 = &z[20] - &z[3]; // OK
   constexpr std::bitset<2> a; 
   constexpr bool b = a[2]; // Comportamiento indefinido, pero no especificado si se detecta

7. (hasta C++17) a expresión lambda
8. an lvalue-to-rvalue conversión implícita unless applied to...
   1. un glvalue de tipo (posiblemente calificado con cv) std::nullptr_t
   2. un glvalue de tipo-literal no volátil que designa un objeto que es utilizable en expresiones constantes

      int main()
      {
          const std::size_t tabsize = 50;
          int tab[tabsize]; // OK: tabsize es una expresión constante
                            // porque tabsize es utilizable en expresiones constantes
                            // porque tiene tipo integral calificado con const, y
                            // su inicializador es un inicializador constante
          std::size_t n = 50;
          const std::size_t sz = n;
          int tab2[sz]; // Error: sz no es una expresión constante
                        // porque sz no es utilizable en expresiones constantes
                        // porque su inicializador no fue un inicializador constante
      }

   3. un glvalue de tipo-literal no volátil que se refiere a un objeto no volátil cuyo tiempo de vida comenzó dentro de la evaluación de esta expresión
9. an lvalue-to-rvalue conversión implícita 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 cuyo valor es indeterminado
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. (hasta C++20) an assignment expression that would change the active member of a union
13. conversion from puntero a void to a pointer-to-object type T* a menos que el puntero contenga un valor de puntero nulo o apunte a un objeto cuyo tipo sea similar a T (since C++26)
14. dynamic_cast cuyo operando es un glvalue que se refiere a un objeto cuyo tipo dinámico es constexpr-desconocido (desde C++20)
15. reinterpret_cast
16. (hasta C++20) pseudo-destructor call
17. (hasta C++14) an increment or a decrement operator
18. (desde 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); // Error: incr(k) no es una expresión constante central
                                   // porque el tiempo de vida de k
                                   // comenzó fuera de la expresión incr(k)
        return x;
    }
    constexpr int h(int k)
    {
        int x = incr(k); // OK: x no necesita ser inicializado
                         // con una expresión constante central
        return x;
    }
    constexpr int y = h(1); // OK: inicializa y con el valor 2
                            // h(1) es una expresión constante central porque
                            // el tiempo de vida de k comienza dentro de la expresión h(1)

19. (desde 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 y ese glvalue se refiere a un objeto cuyo tipo dinámico es constexpr-desconocido (desde C++20)
21. a new expresión , a menos que se cumpla una de las siguientes condiciones: (desde C++20)

    La función de asignación seleccionada es una función de asignación global reemplazable y el almacenamiento asignado se desasigna dentro de la evaluación de esta expresión.

    (since C++20)

    La función de asignación seleccionada es una forma no asignadora con un tipo asignado T , y el argumento de colocación satisface todas las siguientes condiciones: Apunta a: un objeto cuyo tipo es similar a T , si T no es un tipo array, o el primer elemento de un objeto de un tipo similar a T , si T es un tipo array. Apunta a almacenamiento cuya duración comenzó dentro de la evaluación de esta expresión.

    (since C++26)

22. a delete expresión , a menos que desasigne una región de memoria asignada dentro de la evaluación de esta expresión (since C++20)
23. (desde C++20) Coroutines: an expresión await or a expresión-yield
24. (desde C++20) a comparación de tres vías when the result is unspecified
25. an equality or relational operator whose result is unspecified
26. (hasta C++14) an assignment or a compound assignment operator
27. (hasta C++26) una expresión throw
28. (desde C++26) una construcción de un objeto de excepción, a menos que el objeto de excepción y todas sus copias implícitas creadas por invocaciones de std::current_exception o std::rethrow_exception sean destruidas dentro de la evaluación de esta expresión

    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 desde C++26
    static_assert(always_throw()); // Error: excepción no capturada

29. una declaración asm
30. una invocación de la macro va_arg
31. una sentencia goto
32. una expresión dynamic_cast o typeid o una expresión new (desde C++26) que lanzaría una excepción donde no hay disponible una definición del tipo de excepción (desde C++26)
33. dentro de una expresión lambda, una referencia a this o a una variable definida fuera de esa lambda, si esa referencia sería un odr-use

    void g()
    {
        const int n = 0;
        constexpr int j = *&n; // OK: fuera de una expresión lambda
        [=]
        {
            constexpr int i = n;   // OK: 'n' no es odr-used y no se captura aquí.
            constexpr int j = *&n; // Mal formado: '&n' sería un odr-use de 'n'.
        };
    }

    nótese que si el odr-use ocurre en una llamada a función de un cierre, no se refiere a this o a una variable envolvente, ya que accede a un miembro de datos del cierre en su lugar // OK: 'v' & 'm' son odr-used pero no ocurren en una expresión constante // dentro de la lambda anidada auto monad = [](auto v){ return [=]{ return v; }; }; auto bind = [](auto m){ return [=](auto fvm){ return fvm(m()); }; }; // OK tener capturas de objetos automáticos creados durante la evaluación de expresión constante. static_assert(bind(monad(2))(monad)() == monad(2)());

    (desde C++17)

Requisitos adicionales

Aunque una expresión E no evalúe nada mencionado anteriormente, está definido por la implementación si E es una expresión constante del núcleo si evaluar E resultaría en comportamiento indefinido en tiempo de ejecución .

Aunque una expresión E no evalúe nada de lo mencionado anteriormente, no está especificado si E es una core constant expression si evaluar E evaluaría cualquiera de los siguientes:

• Una operación con comportamiento indefinido en la biblioteca estándar .
• Una invocación de la macro va_start .

Para los propósitos de determinar si una expresión es una expresión constante núcleo, la evaluación del cuerpo de una función miembro de std:: allocator < T > se ignora si T es un tipo literal.

Para los propósitos de determinar si una expresión es una expresión constante central, la evaluación de una llamada a un constructor de copia/desplazamiento trivial u operador de asignación de copia/desplazamiento de una union se considera que copia/desplaza el miembro activo de la union, si existe alguno.

Durante la evaluación de la expresión como una expresión constante principal, todas las expresiones de identificador y usos de * this que se refieren a un objeto o referencia cuyo tiempo de vida comenzó fuera de la evaluación de la expresión se tratan como referencias a una instancia específica de ese objeto o referencia cuyo tiempo de vida y el de todos los subobjetos (incluyendo todos los miembros de unión) incluye toda la evaluación constante.

• Para tal objeto que no es usable en expresiones constantes (desde C++20) , el tipo dinámico del objeto es constexpr-unknown .
• Para tal referencia que no es usable en expresiones constantes (desde C++20) , la referencia se trata como si se vinculara a un objeto no especificado del tipo referenciado cuyo tiempo de vida y el de todos los subobjetos incluye toda la evaluación constante y cuyo tipo dinámico es constexpr-unknown.

Expresión constante entera

Expresión constante entera es una expresión de tipo entero o de enumeración no delimitada convertida implícitamente a un prvalue, donde la expresión convertida es una expresión constante principal.

Si una expresión de tipo clase se utiliza donde se espera una expresión constante integral, la expresión es convertida implícitamente contextualmente a un tipo integral o de enumeración no acotada.

Expresión constante convertida

Una expresión constante convertida de tipo T es una expresión convertida implícitamente al tipo T , donde la expresión convertida es una expresión constante, y la secuencia de conversión implícita contiene únicamente:

• constexpr conversiones definidas por el usuario
• conversiones de lvalue a rvalue
• promociones integrales
• no restrictivas conversiones integrales
• promociones de punto flotante
• no restrictivas conversiones de punto flotante

Y si tiene lugar cualquier enlace de referencia , solo puede ser enlace directo .

Los siguientes contextos requieren una expresión constante convertida:

• la expresión-constante de las case etiquetas
• inicializadores de enumerador cuando el tipo subyacente está fijo
• argumentos de plantilla (hasta C++17) constantes integrales y de enumeración

Una expresión constante convertida contextualmente de tipo bool es una expresión convertida contextualmente a bool , donde la expresión convertida es una expresión constante y la secuencia de conversión contiene únicamente las conversiones mencionadas anteriormente.

Los siguientes contextos requieren una expresión constante convertida contextualmente de tipo bool :

• noexcept especificaciones

Funciones y variables necesarias para evaluación constante

Las siguientes expresiones o conversiones son potencialmente evaluadas como constantes :

• expresiones manifiestamente evaluadas como constantes
• expresiones potencialmente evaluadas
• subexpresiones inmediatas de un inicializador entre llaves (puede ser necesaria evaluación constante para determinar si una conversión es de estrechamiento )
• expresiones de toma de dirección que ocurren dentro de una entidad templatizada (puede ser necesaria evaluación constante para determinar si dicha expresión es dependiente de valor )
• subexpresiones de una de las anteriores que no son subexpresión de un operando no evaluado anidado

Una función es necesaria para evaluación constante si es una función constexpr y nombrada por una expresión que es potencialmente evaluada de forma constante.

Una variable es necesaria para evaluación constante si es una variable constexpr o es de tipo integral calificado const no volátil o de tipo referencia y la expresión de identificador que la denota es potencialmente evaluada de forma constante.

Definición de una función por defecto e instanciación de una function template specialization o variable template specialization (since C++14) se activan si la función o variable (since C++14) es necesaria para evaluación constante.

Subexpresión constante

Una subexpresión constante es una expresión cuya evaluación como subexpresión de una expresión e no impediría que e sea una expresión constante central , donde e no es ninguna de las siguientes expresiones:

• throw expresión

• expresión de asignación
• expresión de coma

Notas

Ejemplo

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

Véase también