on devrait préférer const int sum = 1; à #define sum 1 pour plusieurs raisons:

Mécanisme Fondé Sur La Portée:

#define s ne respectent pas les portées, il n'y a donc aucun moyen de créer un espace de noms de classe. Tandis que les variables de const peuvent être scopées dans les classes.

Eviter les nombres magiques bizarres pendant les erreurs de compilation:

si vous utilisez #define ceux-ci sont remplacés par le pré-processeur au moment de la précompilation donc si vous recevez une erreur lors de la compilation, ce sera déroutant parce que le message d'erreur ne référera pas le nom de la macro mais la valeur et il apparaîtra une valeur soudaine, et on perdrait beaucoup de temps à le traquer en code.

facilité de débogage:

Aussi pour les mêmes raisons, tout en déboguant #define ne fournirait aucune aide vraiment.

Pour éviter les deux situations ci-dessus const sera un meilleur choix.

une autre différence est qu'une variable const a une mémoire et peut être référencée par un pointeur. Macro est juste le autocomplete qui se produira avant la compilation, donc le nom est perdu pendant la compilation.

aussi macro peut être juste plus qu'une constante. Il peut être suis d'expression ou tout ce qui est syntaxiquement correct, même l'ensemble de définition d'une fonction.

sont utilisées pour décrire la programmation les choix, par exemple la taille de la pile; tandis que cosnt est utilisé pour décrire les constantes du monde réel comme la valeur de Pi ou E.

(posté à l'origine pour const statique vs #define - reproduit ici car cette question semble avoir plus de"momentum"... permettez-moi de savoir si c'est inapproprié... )

pour et contre à tout, selon l'usage:

• consts
  • correctement portée / l'identificateur de choc questions traitées joliment
  • fort, simple, du type spécifié par l'utilisateur
    • vous pourriez essayer de" type "a #define ala #define S std::string("abc") , mais la constante évite la construction répétée de temporels distincts à chaque point d'utilisation
  • une règle de définition complications
  • peut prendre l'adresse, créer des références const à eux, etc.
• définit
  • "" portée globale / plus sujettes à des conflits d'usages, qui peuvent produire des problèmes de compilation difficiles à résoudre et des résultats d'exécution inattendus plutôt que des messages d'erreur sains; pour les atténuer, il faut:
    • identificateurs longs, obscurs et/ou coordonnés au niveau central, et l'accès à ceux-ci ne peut pas bénéficier de la correspondance implicite used/current/Koenig-searched-namespace, namespace aliases etc.
    • l'utilisation de tous les caractères majuscules est généralement requise et réservée au préprocesseur définit (une ligne directrice importante pour l'utilisation des préprocesseurs à l'échelle de l'entreprise doit rester gérable, et on peut s'attendre à ce que les bibliothèques tierces suivent), dont l'observation implique la migration des consts ou des enum existants vers definition implique un changement de la capitalisation (et donc affecte le code client). (Personnellement, je capitalise la première lettre d'enums mais pas consts, donc je serais frappé ici de toute façon - peut-être le temps de repenser cela.)
  • plus d'opérations de compilation possibles: chaîne de caractères concaténation littérale, stringification (compte tenu de leur dimension))
    • l'inconvénient est que donné #define X "x" et une certaine utilisation client ala "pre" X "post" , vous êtes en difficulté si vous voulez ou avez besoin de faire X une variable runtime-changeable plutôt qu'une constante, alors que cette transition est plus facile à partir d'un const char* ou const std::string étant donné qu'ils forcent déjà l'utilisateur à intégrer des opérations de concaténation.
  • ne peut pas utiliser sizeof directement sur une constante numérique définie
  • non typé (GCC ne pas avertir en cas de rapport non signé)
  • certaines chaînes compilateur/linker/debugger ne présentent pas l'identifiant, vous serez donc réduit à regarder "magic numbers" (chaînes, peu importe...)
  • ne peut pas prendre l'adresse
  • la valeur substituée n'a pas besoin d'être légale (ou discrète) dans le contexte où le # define est créé, car il est évalué à chaque point d'utilisation, de sorte que vous pouvez faire référence à des objets non encore déclarés, dépend de "l'implémentation" qui n'a pas besoin d'être pré-inclus, créer des "constantes" telles que { 1, 2 } qui peuvent être utilisées pour initialiser des tableaux, ou #define MICROSECONDS *1E-6 etc. ( certainement ne la recommande pas!)
  • certaines choses spéciales comme __FILE__ et __LINE__ peuvent être intégrées dans la macro substitution
• enums
  • seulement possible pour les valeurs entières
  • correctement portée / l'identificateur de choc questions traitées joliment
  • fortement dactylographié, mais à une taille int signée-ou-non signée assez grande sur laquelle vous n'avez aucun contrôle (en C++03)
  • ne peut pas prendre l'adresse
  • usage restreint renforcé (p.ex. incrementing - template <typename T> void f(T t) { cout << ++t; } won't compile)
  • type de chaque constante tiré de l'enveloppe enum, donc template <typename T> void f(T) obtenir une instantiation distincte quand passé la même valeur numérique de différents enums, tous qui sont distincts de n'importe quelle instantiation F(int) réelle.
  • même avec typeof, ne peut pas s'attendre numeric_limits à fournir un aperçu utile des
  • le nom-type de l'enum peut apparaître à différents endroits dans RTTI, dans les messages de compilateurs, etc. - peut-être utile, peut-être obfuscation

en tant que règle générale, j'utilise consts et les considère l'option la plus professionnelle pour l'usage général (bien que les autres ont une simplicité attirant à ce vieux programmeur paresseux).

ne respectent pas scope, et le nom d'une macro peut ne pas être disponible pour un débogueur symbolique. Dan Saks a un article assez complet sur les mérites relatifs des macros (Aucun), les objets constants, et les constantes d'énumération. Comme Stephen Dewhurst , Saks préfère les constantes d'énumération pour les valeurs entières puisqu'elles ne prennent pas de stockage (plus précisément, les constantes d'énumération n'ont ni durée de stockage ni lien).

définir peut être redéfinir , mais const sera la cause d'erreur du compilateur:

échantillon: source : principal.cpp

#define int_constance 4
#define int_constance 8 // ok, compiler will warning ( redefine macro)

const int a = 2;
const int a = 4; // redefine -> error

int main(int argc, char** argv)
{
   std::cout << int_constance ; // if remove second #define line, output will be 8

   return 0;
}

Macro comme #define et const les deux sont utilisés dans le langage de programmation C pour définir les constantes.

voyons la différence entre # define et const:

#define

1. #define est une directive préprocesseur.
2. #define ne peut définir que la constante simple.

const

1. const la variable est exactement comme une variable normale en langage C.
2. const peut aussi définir des constantes complexes.

pour la différence complète: différence entre #define et const en C

une macro a toujours un type, par exemple #define FIVE 5 est de type int.

un avantage pour la variable const par rapport à la macro pourrait être l'utilisation de la mémoire : avec une macro la valeur peut devoir être dupliquée partout où elle est utilisée si une variable const ne sera pas dupliquée en mémoire. (mais je ne suis pas sûr de cette différence)