constexpr es un especificador que le indica al compilador que una entidad (variable o función) tiene la capacidad de ser evaluada durante la fase de compilación. No es simplemente una etiqueta de “no modificable” como const; es una instrucción que permite al compilador ejecutar lógica de programación antes de que el binario se ejecute, transformando cálculos en valores constantes puros.
El propósito de esta evolución ha sido permitir que la potencia del lenguaje de programación se traslade del tiempo de ejecución al tiempo de compilación, reduciendo el consumo de CPU en el cliente final y permitiendo el uso de tipos complejos como parámetros de plantillas o tamaños de arrays. En su versión original en C++11, constexpr era extremadamente restrictivo: una función solo podía tener una sentencia return y ninguna lógica de control, lo que la limitaba a expresiones matemáticas simples. Con C++14, las reglas se relajaron permitiendo múltiples sentencias, variables locales mutables y bucles. La verdadera revolución llegó con C++20, donde se permitió la gestión de memoria dinámica (como std::vector o std::string) dentro de contextos constexpr, siempre y cuando la memoria se libere antes de que la evaluación termine. Finalmente, C++23 introdujo if consteval para facilitar la escritura de funciones que se comportan de forma distinta si se ejecutan en tiempo de compilación o en tiempo de ejecución.
Debes usar constexpr siempre que un valor sea intrínsecamente constante o cuando una función de utilidad sea capaz de generar resultados que puedan ser utilizados en contextos que requieren constantes (como el tamaño de un std::array).
Si intentas usar constexpr en una función que dependa de datos de tiempo de ejecución (como leer un archivo o std::cin), la función seguirá siendo válida pero se ejecutará de forma normal en runtime, perdiendo cualquier ventaja de optimización. El error más crítico ocurre cuando intentas usar lógica de runtime (como imprimir en consola) dentro de una evaluación constexpr, lo que provocará un error de compilación inmediato.
#include <iostream>
#include <vector>
#include <type_traits>
#include <numeric>
// [C++11] Variable constante garantizada en tiempo de compilación
constexpr int LIMITE_MAXIMO = 100;
// [C++14] Funciones con lógica compleja: bucles y variables locales
// Antes de C++14, esto no habría compilado.
constexpr int suma_secuencial(int n) {
int acumulador = 0; // Variable local mutable permitida desde C++14
for (int i = 1; i <= n; ++i) { // Bucles permitidos desde C++14
acumulador += i;
}
return acumulador;
}
// [C++20] Uso de std::vector en contexto constexpr
// La memoria se asigna y libera durante la compilación.
// No podemos devolver el vector, pero sí un valor calculado con él.
constexpr int calcular_media_procedimental(int n) {
std::vector<int> datos;
for (int i = 1; i <= n; ++i) {
datos.push_back(i);
}
int suma = std::accumulate(datos.begin(), datos.end(), 0);
return suma / n;
}
// [C++23] Uso de 'if consteval' para bifurcación de ejecución
// Esta función puede ser llamada en runtime o en compile-time.
int optimizador_inteligente(int valor) {
if consteval {
// Este bloque solo se compila si la llamada es parte de una
// expresión constante.
return valor * 2;
} else {
// Este bloque se usa en el mundo real (runtime).
return valor + 42;
}
}
int main() {
// static_assert garantiza que el cálculo sea correcto en compilación
static_assert(suma_secuencial(10) == 55, "Error en suma");
static_assert(calcular_media_procedimental(5) == 3, "Error en media");
// Valor calculado en compilación
constexpr int constante_dinamica = calcular_media_procedimental(10);
// Valor calculado en runtime
int variable_runtime = 10;
int resultado_opt = optimizador_inteligente(variable_runtime);
std::cout << "Constante (compile-time): " << constante_dinamica << "\n";
std::cout << "Runtime (optimizado): " << resultado_opt << "\n";
return 0;
}
Desglose del código
En el ejemplo anterior, hemos visto cómo ha evolucionado la capacidad de cómputo del compilador.
La función suma_secuencial demuestra la libertad otorgada en C++14; fíjate en la variable acumulador y el bucle for. En C++11, el compilador habría rechazado esto porque no se puede tener un estado mutable durante la evaluación constante.
Con calcular_media_procedimental, aprovechamos las capacidades de C++20. Al usar std::vector, el compilador realiza una “asignación dinámica” en un área de memoria especial durante la compilación. Es crucial entender que, aunque el std::vector es válido dentro de la función, no podrías devolver el objeto datos desde una función constexpr hacia un contexto de runtime, ya que el puntero interno a la memoria sería inválido fuera del proceso de evaluación constante.
En optimizador_inteligente, implementamos una técnica de diseño moderna. Mediante if consteval (C++23), permitimos que la misma función tenga dos implementaciones: una extremadamente eficiente para cuando el valor es conocido (como para optimizaciones matemáticas) y otra estándar para el flujo normal del programa. Esto es más limpio que usar std::is_constant_evaluated() (C++20) porque if consteval garantiza que el código del bloque de tiempo de ejecución sea descartado por completo si se llama en un contexto constante, evitando dependencias de runtime en el binario optimizado.
El uso de static_assert en el main es la prueba definitiva: si suma_secuencial no fuera una constante pura, el compilador lanzaría un error en esa línea, no en la ejecución.
El error frecuente
Un error común al usar if consteval [C++23] o std::is_constant_evaluated [C++20] es asumir que la función se ejecutará en tiempo de compilación simplemente por tener el especificador constexpr.
// ERROR COMÚN
constexpr int fallo_logica(int n) {
if consteval {
return n * 2; // Se ejecutará en compilación si n es constante
} else {
// Si n es una variable de runtime, este bloque se ejecuta.
// Pero, ¿qué pasa si olvidamos el 'else' o si el 'else' no es suficiente?
return n;
}
}
int main() {
int x = 10;
int r = fallo_logica(x); // Ejecución en runtime (correcto, pero no es constexpr)
// Si intentas usar esto en un contexto que REQUIERE una constante:
// static_assert(fallo_logica(x) == 20, "Error"); // ERROR DE COMPILACIÓN
}
Si intentas usar una función que contiene lógica if consteval dentro de un static_assert pero la rama else no es capaz de satisfacer los requisitos de una expresión constante (por ejemplo, si el else contiene un std::cout), el compilador fallará al intentar compilar la versión de runtime para esa rama, incluso si la versión de compilación es perfecta. Siempre asegúrate de que ambas ramas sean semánticamente válidas para el contexto en el que se llamarán.
N° 46