constexpr specifier (since C++11)

• constexpr - especifica que el valor de una variable , structured binding (since C++26) o función puede aparecer en constant expressions

Explicación

El constexpr especificador declara que es posible evaluar el valor de las entidades en tiempo de compilación. Dichas entidades pueden entonces utilizarse donde solo se permiten expresiones constantes de tiempo de compilación (siempre que se proporcionen los argumentos de función apropiados).

Un constexpr especificador utilizado en una declaración de objeto o función miembro no estática (hasta C++14) implica const .

Un constexpr especificador utilizado en la primera declaración de una función o static miembro de datos (desde C++17) implica inline . Si cualquier declaración de una función o plantilla de función tiene un constexpr especificador, entonces cada declaración debe contener ese especificador.

constexpr variable

Una variable o plantilla de variable (desde C++14) puede declararse constexpr si se cumplen todas las siguientes condiciones:

• La declaración es una definición .
• Es de un literal type .
• Está inicializada (por la declaración).

constexpr función

Una función o plantilla de función puede declararse constexpr .

Una función es constexpr-suitable si se satisfacen todas las siguientes condiciones:

• Si es un constructor o destructor (desde C++20) , su clase no tiene ninguna virtual base class .

Excepto las funciones constexpr instanciadas, las funciones no template constexpr deben ser constexpr-suitable.

Una invocación de una función constexpr en un contexto dado produce el mismo resultado que una invocación de una función no constexpr equivalente en el mismo contexto en todos los aspectos, con las siguientes excepciones:

• Una invocación de una función constexpr puede aparecer en una expresión constante .
• Copy elision no se realiza en una expresión constante.

constexpr constructor

Además de los requisitos de las funciones constexpr , un constructor también debe cumplir todas las siguientes condiciones para ser apto para constexpr:

• La clase no tiene ninguna virtual base class .

constexpr destructor

Notas

constexpr int f(); 
constexpr bool b1 = noexcept(f()); // false, undefined constexpr function
constexpr int f() { return 0; }
constexpr bool b2 = noexcept(f()); // true, f() is a constant expression

void f(int& i) // not a constexpr function
{
    i = 0;
}
constexpr void g(int& i) // well-formed since C++23
{
    f(i); // unconditionally calls f, cannot be a constant expression
}

Los constructores constexpr están permitidos para clases que no son tipos literales. Por ejemplo, el constructor por defecto de std::shared_ptr es constexpr, permitiendo inicialización constante .

Las variables de referencia pueden declararse constexpr (sus inicializadores deben ser expresiones constantes de referencia ):

static constexpr int const& x = 42; // referencia constexpr a un objeto const int
                                    // (el objeto tiene duración de almacenamiento estático
                                    //  debido a la extensión de vida por una referencia estática)

Palabras clave

constexpr

Ejemplo

#include <iostream>
#include <stdexcept>
// Las funciones constexpr de C++11 usan recursión en lugar de iteración
constexpr int factorial(int n)
{
    return n <= 1 ? 1 : (n * factorial(n - 1));
}
// Las funciones constexpr de C++14 pueden usar variables locales y bucles
#if __cplusplus >= 201402L
constexpr int factorial_cxx14(int n)
{
    int res = 1;
    while (n > 1)
        res *= n--;
    return res;
}
#endif // C++14
// Una clase literal
class conststr
{
    const char* p;
    std::size_t sz;
public:
    template<std::size_t N>
    constexpr conststr(const char(&a)[N]): p(a), sz(N - 1) {}
    // Las funciones constexpr señalan errores lanzando excepciones
    // en C++11, deben hacerlo desde el operador condicional ?:
    constexpr char operator[](std::size_t n) const
    {
        return n < sz ? p[n] : throw std::out_of_range("");
    }
    constexpr std::size_t size() const { return sz; }
};
// Las funciones constexpr de C++11 tenían que poner todo en una única sentencia return
// (C++14 no tiene ese requisito)
constexpr std::size_t countlower(conststr s, std::size_t n = 0,
                                             std::size_t c = 0)
{
    return n == s.size() ? c :
        'a' <= s[n] && s[n] <= 'z' ? countlower(s, n + 1, c + 1)
                                   : countlower(s, n + 1, c);
}
// Una función de salida que requiere una constante en tiempo de compilación, para pruebas
template<int n>
struct constN
{
    constN() { std::cout << n << '\n'; }
};
int main()
{
    std::cout << "4! = ";
    constN<factorial(4)> out1; // calculado en tiempo de compilación
    volatile int k = 8; // deshabilitar optimización usando volatile
    std::cout << k << "! = " << factorial(k) << '\n'; // calculado en tiempo de ejecución
    std::cout << "El número de letras minúsculas en \"Hello, world!\" es ";
    constN<countlower("Hello, world!")> out2; // convertido implícitamente a conststr
    constexpr int a[12] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
    constexpr int length_a = sizeof a / sizeof(int); // std::size(a) en C++17,
                                                      // std::ssize(a) en C++20
    std::cout << "Array de longitud " << length_a << " tiene elementos: ";
    for (int i = 0; i < length_a; ++i)
        std::cout << a[i] << ' ';
    std::cout << '\n';
}

4! = 24
8! = 40320
El número de letras minúsculas en "Hello, world!" es 9
Array de longitud 12 tiene elementos: 0 1 2 3 4 5 6 7 8 0 0 0

Informes de defectos

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

1. ↑ Es redundante porque no puede haber más de una declaración de una variable template con el constexpr especificador.

Véase también