constexpr vs const en C++: ¿cuál es la diferencia? Guía completa

Introducción: la batalla eterna de las constantes en C++

Si alguna vez has escrito en C++ (o incluso si apenas estás empezando a aprenderlo), seguramente te has topado con const. Este prefijo mágico promete que el valor de una variable no cambiará. Pero luego llegó C++11 y trajo consigo constexpr. Y comenzó la confusión.

En Stack Overflow, la pregunta "What's the difference between constexpr and const?" ha acumulado cientos de miles de visitas. Programadores de todo tipo confunden estos dos conceptos, usándolos como sinónimos. ¡Pero es un gran error!

En este tutorial, aclararemos de una vez por todas en qué se diferencian constexpr y const en C++. Aprenderás:

\n
• Qué es una constante en tiempo de compilación y una constante en tiempo de ejecución.
\n
• Por qué const no siempre se trata de rendimiento.
\n
• Cómo constexpr convierte a C++ en un lenguaje moderno y seguro.
\n
• Cuándo usar cada una de estas construcciones.
\n

¡Allá vamos! 🚀

Capítulo 1. const: una promesa, no una garantía

Empecemos por lo básico. const en C++ es un calificador de tipo que le dice al compilador: "Oye, este valor no se puede modificar después de la inicialización". Suena simple, pero hay un detalle.

Ejemplo 1: const en acción

#include <iostream>\n\nint main() {\n    const int x = 42;  // Promesa: x no cambiará\n    // x = 100;        // Error de compilación — ¡perfecto!\n    \n    std::cout << x;   // Imprime 42\n    return 0;\n}

Todo bien. Pero, ¿qué pasa si el valor de una variable const se calcula solo durante la ejecución?

Ejemplo 2: const que se calcula en tiempo de ejecución

#include <iostream>\n\nint get_value() {\n    return 42;  // La función devuelve un valor\n}\n\nint main() {\n    const int y = get_value();  // ¿Sigue siendo const?\n    // ¡Pero el valor de y solo se conoce en tiempo de ejecución!\n    \n    // Intentemos usarlo en un array:\n    // int arr[y];  // ¡Error! ¡y no es una constante en tiempo de compilación!\n    \n    return 0;\n}

¡Aquí está el truco principal! const protege a la variable de ser modificada, pero no garantiza que su valor se conozca en la etapa de compilación. Si el valor se obtiene de una función, se calcula solo al ejecutar el programa.

Conclusión clave: const es un contrato de inmutabilidad, no de calculabilidad en tiempo de compilación.

Capítulo 2. constexpr: constantes que viven en el código

Aquí entra en escena constexpr. Este especificador apareció en C++11 y cambió radicalmente el enfoque hacia las constantes. constexpr significa: "Este valor debe calcularse durante la compilación". O, al menos, puede calcularse.

Ejemplo 3: variable constexpr

#include <iostream>\n\nint main() {\n    constexpr int z = 42;  // Garantía: el valor se conoce en tiempo de compilación\n    \n    int arr[z];  // ¡Funciona! z es una constante en tiempo de compilación\n    \n    std::cout << sizeof(arr) / sizeof(arr[0]);  // Imprime 42\n    return 0;\n}

La diferencia es evidente: constexpr permite usar la variable donde el compilador necesita conocer el valor exacto, por ejemplo, para el tamaño de un array o parámetros de plantilla.

Ejemplo 4: funciones constexpr

Pero lo más interesante son las funciones. constexpr se puede aplicar a funciones, y entonces pueden calcularse durante la compilación, si todos los argumentos también son constantes en tiempo de compilación.

#include <iostream>\n\nconstexpr int square(int x) {\n    return x * x;\n}\n\nint main() {\n    constexpr int result = square(5);  // ¡Se calcula en tiempo de compilación!\n    int arr[result];                   // Funciona\n    \n    std::cout << result;  // 25\n    \n    int runtime_value =