¿No son básicamente iguales?
No absolutamente no. Ni siquiera cerca.
Aparte del hecho de que su macro es una inty su constexpr unsignedes una unsigned, existen diferencias importantes y las macros solo tienen una ventaja.
Alcance
Una macro la define el preprocesador y simplemente se sustituye en el código cada vez que ocurre. El preprocesador es tonto y no comprende la sintaxis ni la semántica de C ++. Las macros ignoran ámbitos como espacios de nombres, clases o bloques de funciones, por lo que no puede usar un nombre para nada más en un archivo fuente. Eso no es cierto para una constante definida como una variable C ++ adecuada:
#define MAX_HEIGHT 720
constexpr int max_height = 720;
class Window {
int max_height;
};
Está bien tener una variable miembro llamada max_heightporque es un miembro de la clase y, por lo tanto, tiene un alcance diferente y es diferente de la que se encuentra en el alcance del espacio de nombres. Si intenta reutilizar el nombre MAX_HEIGHTdel miembro, el preprocesador lo cambiaría a esta tontería que no compilaría:
class Window {
int 720;
};
Es por eso que debe proporcionar macros UGLY_SHOUTY_NAMESpara asegurarse de que se destaquen y puede tener cuidado al nombrarlas para evitar conflictos. Si no usa macros innecesariamente, no tiene que preocuparse por eso (y no tiene que leer SHOUTY_NAMES).
Si solo desea una constante dentro de una función, no puede hacer eso con una macro, porque el preprocesador no sabe qué es una función o qué significa estar dentro de ella. Para limitar una macro a solo una determinada parte de un archivo, debe volver a #undefhacerlo:
int limit(int height) {
#define MAX_HEIGHT 720
return std::max(height, MAX_HEIGHT);
#undef MAX_HEIGHT
}
Compare con el mucho más sensato:
int limit(int height) {
constexpr int max_height = 720;
return std::max(height, max_height);
}
¿Por qué preferirías el macro?
Una ubicación de memoria real
Una variable constexpr es una variable, por lo que realmente existe en el programa y puede hacer cosas normales de C ++ como tomar su dirección y vincular una referencia a ella.
Este código tiene un comportamiento indefinido:
#define MAX_HEIGHT 720
int limit(int height) {
const int& h = std::max(height, MAX_HEIGHT);
return h;
}
El problema es que MAX_HEIGHTno es una variable, por lo que la llamada a std::maxun temporal intdebe ser creada por el compilador. La referencia que devuelve std::maxpodría referirse a ese temporal, que no existe después del final de esa declaración, por lo que return haccede a la memoria no válida.
Ese problema simplemente no existe con una variable adecuada, porque tiene una ubicación fija en la memoria que no desaparece:
int limit(int height) {
constexpr int max_height = 720;
const int& h = std::max(height, max_height);
return h;
}
(En la práctica, probablemente declararía que int hno, const int& hpero el problema puede surgir en contextos más sutiles).
Condiciones del preprocesador
El único momento para preferir una macro es cuando necesita que el preprocesador entienda su valor, para su uso en #ifcondiciones, p. Ej.
#define MAX_HEIGHT 720
#if MAX_HEIGHT < 256
using height_type = unsigned char;
#else
using height_type = unsigned int;
#endif
No puede usar una variable aquí, porque el preprocesador no entiende cómo referirse a las variables por su nombre. Solo comprende cosas muy básicas como la expansión macro y las directivas que comienzan con #(como #includey #definey #if).
Si desea una constante que el preprocesador pueda entender , debe usar el preprocesador para definirla. Si desea una constante para el código C ++ normal, utilice el código C ++ normal.
El ejemplo anterior es solo para demostrar una condición de preprocesador, pero incluso ese código podría evitar el uso del preprocesador:
using height_type = std::conditional_t<max_height < 256, unsigned char, unsigned int>;