Especificador constexpr (desde C++11)

• constexpr - Especifica que el valor de una variable o función puede aparecer en expresiones constantes.

[editar] Explicación

El especificador constexpr declara que es posible evaluar el valor de la función o variable en tiempo de compilación. Tales variables y funciones pueden entonces utilizarse pueden donde solamente se permiten expresiones constantes en tiempo de compilación (dado que se suministren los argumentos de función apropiados). Un especificador constexpr utilizado en una declaración de objeto o función miembro no estática (hasta C++14) implica const. Un especificador constexpr utilizado en una función o la declaración de una variable miembro estática (desde C++17) implica inline. Si alguna declaración de una función o plantilla de función tiene un especificador constexpr, cada declaración debe contener ese especificador.

Una variable constexpr debe cumplir los siguientes requisitos:

• su tipo debe de ser un LiteralType;
• debe inicializarse inmediatemente;
• la expresión completa de su inicialización, incluyendo todas las conversiones implícitas, llamadas a constructores, etc., deben ser una expresión constante;

Una función constexpr debe cumplir los siguientes requisitos:

• su tipo de retorno (si lo tiene) debe ser un LiteralType;
• cada uno de sus parámetros deben ser un LiteralType
• para el constructor y destructor (desde C++20), la clase no debe tener clases base virtuales;
• existe al menos un conjunto de valores de argumentos tal que la invocación de la función podría ser una subexpresión evaluada de un expresión constante central (para los constructores, el uso en un inicializador constante es suficiente) (desde C++14). No se requiere diagnóstico de una violación de esta viñeta;

Un constructor constexpr cuyo cuerpo de función no es =delete; debe cumplir los requisitos siguientes:

• cada constructor seleccionado para inicializar datos miembro no estáticos y clases base debe ser un constructor constexpr.

Para las plantillas de función constexpr y las funciones miembro constexpr de las plantillas de clase, al menos una especialización debe cumplir los requisitos mencionados anteriormente. Otras especializaciones todavía se consideran constexpr, aunque una llamada a dicha función no pueda aparecer en una expresión constante.

[editar] Notas

constexpr int f(); 
constexpr bool b1 = noexcept(f()); // falso, función constexpr indefinida
constexpr int f() { return 0; }
constexpr bool b2 = noexcept(f()); // verdadero, f() es una expresión constante

Se permiten los constructores constexpr para clases que no son tipos literal. Por ejemplo, el constructor por defecto de std::unique_ptr es constexpr, permitiendo la inicialización por constante.

Las variables referencia pueden declararse constexpr (sus inicializadores tiene que ser expresiones de referencia constante ):

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

[editar] Palabras clave

constexpr

[editar] Ejemplo

#include <iostream>
#include <stdexcept>
 
// las funciones constexpr en C++11 usan recursión en lugar de iteración
// (las funciones constexpr en C++14 pueden usar variables locales y bucles)
constexpr int factorial(int n)
{
    return n <= 1 ? 1 : (n * factorial(n - 1));
}
 
// 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) {}
 
    // en C++11, las funciones constexpr señalan los errores lanzando
    // excepciones, deben hacerlo desde el operador condicional ?:
    constexpr char operator[](std::size_t n) {
        return n < sz ? p[n] : throw std::out_of_range("");
    }
    constexpr std::size_t size() { return sz; }
};
 
// las funciones constexpr en C++11 tenían que poner todo en una sola instrucción 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 :
           s[n] >= 'a' && s[n] <= 'z' ? countlower(s, n+1, c+1) :
           countlower(s, n+1, c);
}
 
// función de salida que requiere una constante en tiempo de compilación para prueba
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 utilizando volatile
    std::cout << k << "! = " << factorial(k) << '\n'; // calculado en tiempo de ejecución
 
    std::cout << "Numero de letras minusculas en \"Hola, mundo!\" es ";
    constN<countlower("Hola, mundo!")> out2; // convertido implícitamente a conststr
}

4! = 24
8! = 40320
Numero de letras minusculas en "Hola, mundo!" es 8

[editar] Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

[editar] Véase también

• Expresión constante
• consteval
• constinit