Ne sont-ils pas fondamentalement les mêmes?
Non, absolument pas. Pas même proche.
Outre le fait que votre macro est une intet votre constexpr unsignedest une unsigned, il existe des différences importantes et les macros n'ont qu'un seul avantage.
Portée
Une macro est définie par le préprocesseur et est simplement substituée dans le code à chaque fois qu'elle se produit. Le préprocesseur est stupide et ne comprend pas la syntaxe ou la sémantique C ++. Les macros ignorent les portées telles que les espaces de noms, les classes ou les blocs fonctionnels, vous ne pouvez donc pas utiliser de nom pour autre chose dans un fichier source. Ce n'est pas vrai pour une constante définie comme une variable C ++ appropriée:
#define MAX_HEIGHT 720
constexpr int max_height = 720;
class Window {
int max_height;
};
C'est bien d'avoir une variable membre appelée max_heightcar c'est un membre de classe et a donc une portée différente, et est distincte de celle de la portée de l'espace de noms. Si vous essayez de réutiliser le nom MAX_HEIGHTdu membre, le préprocesseur le changera en ce non-sens qui ne compilerait pas:
class Window {
int 720;
};
C'est pourquoi vous devez donner des macros UGLY_SHOUTY_NAMESpour vous assurer qu'elles se démarquent et vous pouvez faire attention à les nommer pour éviter les conflits. Si vous n'utilisez pas de macros inutilement, vous n'avez pas à vous en soucier (ni à lire SHOUTY_NAMES).
Si vous voulez juste une constante à l'intérieur d'une fonction, vous ne pouvez pas le faire avec une macro, car le préprocesseur ne sait pas ce qu'est une fonction ou ce que cela signifie d'être à l'intérieur. Pour limiter une macro à une seule partie d'un fichier, vous en avez besoin à #undefnouveau:
int limit(int height) {
#define MAX_HEIGHT 720
return std::max(height, MAX_HEIGHT);
#undef MAX_HEIGHT
}
Comparez avec le plus sensible:
int limit(int height) {
constexpr int max_height = 720;
return std::max(height, max_height);
}
Pourquoi préféreriez-vous le macro?
Un véritable emplacement mémoire
Une variable constexpr est une variable donc elle existe réellement dans le programme et vous pouvez faire des choses C ++ normales comme prendre son adresse et lui lier une référence.
Ce code a un comportement non défini:
#define MAX_HEIGHT 720
int limit(int height) {
const int& h = std::max(height, MAX_HEIGHT);
return h;
}
Le problème est que ce MAX_HEIGHTn'est pas une variable, donc l'appel à std::maxun temporaire intdoit être créé par le compilateur. La référence retournée par std::maxpeut alors faire référence à ce temporaire, qui n'existe pas après la fin de cette instruction, donc return haccède à la mémoire non valide.
Ce problème n'existe tout simplement pas avec une variable appropriée, car il a un emplacement fixe en mémoire qui ne disparaît pas:
int limit(int height) {
constexpr int max_height = 720;
const int& h = std::max(height, max_height);
return h;
}
(En pratique, vous déclareriez probablement int hnon, const int& hmais le problème peut survenir dans des contextes plus subtils.)
Conditions du préprocesseur
Le seul moment pour préférer une macro est lorsque vous avez besoin que sa valeur soit comprise par le préprocesseur, pour une utilisation dans des #ifconditions, par exemple
#define MAX_HEIGHT 720
#if MAX_HEIGHT < 256
using height_type = unsigned char;
#else
using height_type = unsigned int;
#endif
Vous ne pouvez pas utiliser de variable ici, car le préprocesseur ne comprend pas comment faire référence aux variables par leur nom. Il ne comprend que les choses de base très basiques comme l'expansion de macro et les directives commençant par #(comme #includeet #defineet #if).
Si vous voulez une constante compréhensible par le préprocesseur, vous devez utiliser le préprocesseur pour la définir. Si vous voulez une constante pour le code C ++ normal, utilisez du code C ++ normal.
L'exemple ci-dessus est juste pour démontrer une condition de préprocesseur, mais même ce code pourrait éviter d'utiliser le préprocesseur:
using height_type = std::conditional_t<max_height < 256, unsigned char, unsigned int>;