Pourquoi quelqu'un voudrait-il utiliser des #define pour définir des constantes?

Il est question simple, mais pourquoi quelqu'un voudrait-il utiliser des #define pour définir des constantes?

Quelle est la différence entre

#define sum 1 et const int sum = 1;

  • Je suis honnêtement vraiment tenté de dire, "parce qu'ils sont n00bs"... +1 bonne question
  • wow , comment puis-je savoir qui est droit , compliqué réponses 😕
  • Ouais celui-ci devrait apporter quelques réponses amusantes
  • Très simple, si vous êtes à la programmation en C++ -- il suffit de suivre Scott Meyer les conseils de l'Article#1 'Préfère const et inline #define'. Utiliser "#define " comme un dernier recours lorsque const ne fonctionnerait pas. Par exemple, l'en-tête de l'inclusion des gardes etc.
  • Vous êtes dangereusement proche de poser une question religieuse
  • Voici une astuce pour réduire le risque d'obtenir beaucoup de réponses disparates: ne pas poser une question dans un titre et une autre question dans le corps. Elles sont similaires, mais ont différentes façons de répondre.
  • bien sûr, sinon comment peut-il accumuler quelques points de rep vite? 😛
  • Les mecs que dois-je faire , est AndreyT répondre par vrai , je ne connais pas les règles, mais encore plus de points pour une réponse signifie qu'il est juste !?
  • Le haut/downvote ratio est en aucun cas d'autorité, mais c'est l'opinion de la majorité et en tant que tel, il est une bonne indication pour la correction que vous pouvez obtenir sur DONC. (Cependant, comme @Victor a souligné, dans ce cas, il est d'accord avec les premiers conseils de Scott Meyers a largement acclamé livre. C'est une bien meilleure indication.)

InformationsquelleAutor | 2011-06-08
  1. 39

    #define a de nombreuses applications différentes, mais votre question semble être au sujet d'une application spécifique: la définition nommé constantes.

    En C++ il y a rarement une raison d'utiliser #define de définir nommé constantes.

    #define est normalement largement utilisé dans le code C, depuis le langage C est très différent de C++ quand il s'agit de définir des constantes. En bref, const int objets ne sont pas constantes en C, ce qui signifie que C le principal moyen de définir une véritable constante est d'utiliser #define. (Aussi, pour int constantes, on peut utiliser les énumérations).

    • qu'en est énumérations?
    • l'homme j'ai peur là 😐 , ce qui est la règle, est-ce vrai réponse , à cause de points ?
    • plus de points pour une réponse ne signifie pas que c'est toujours vrai
    • static const int et enum {...} sont de véritables constantes les constantes en C++
    • En C++ il n'y a pas besoin de static en face de const int. En C++ const objets ont une liaison interne par défaut.
    • "const int objets ne sont pas constantes dans C" - Attendez, vraiment? Pourquoi est-ce?
    • Danny Pflughoeft: eh Bien, tout simplement parce que la langue est définie de cette façon. En langage C, vous ne pouvez pas utiliser const int objet comme case étiquette, en tant que champ de bits de taille, car la taille du tableau pour les non-VLA tableau, précisément parce que const int objets ne sont pas constantes dans C. Le terme "constante" dans C se réfère aux constantes littérales (comme 25) et enum membres, mais de ne pas const objets.
    • Danny Pflughoeft: j'ai une explication plus détaillée ici stackoverflow.com/questions/2308194/...

    InformationsquelleAutor AnT
  2. 38

    Ne devrait pas!

    En fait, On devrait préférer const int sum = 1; sur #define sum 1 pour un certain nombre de raisons:

    Étendue En Fonction De Mécanisme:

    #defines ne respectent pas les étendues donc il n'y a aucun moyen de créer une classe étendue de l'espace de noms. Tout const variables peut être portée dans les classes.

    Éviter Bizarre de magique 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, il sera source de confusion car le message d'erreur l'habitude de consulter le nom de la macro, mais la valeur et il apparaîtra une soudaine valeur, et l'on perdrait beaucoup de temps de suivi vers le bas dans le code.

    Facilité de Débogage:

    Aussi pour les mêmes raisons mentionnées dans le #2, tandis que le débogage #define apporterait pas aider vraiment.

    Ainsi, pour éviter des situations ci-dessus const sera un meilleur choix.

    • C'était un accident, à droite 😉
    • Fernandes: ouais, C'était oublier "" pour les #define...
    • si tout de la réponse commence par # en SORTE, alors il fait tout dans big gras.
    • +1 a un sens, même s'il est discutable de savoir si c'est une bonne chose ou une mauvaise chose je pense.
    • X peut être pratiquement étendue à l'aide des #undef X
    • Pas vraiment. Si c'est déjà définie, il va perdre de la valeur précédente -- c'est pas comme push/pop avec une pile.
    • lol, "pourquoi voudrait-on utiliser des #define ?" "pour un certain nombre de raisons: 1) elle les suce 2) elle suce 3) il est nul"
    • Fernandes: 😉 lol Le Q titre sérieusement besoin d'un edit!
    • je souhaite que je pourrais accepter le vôtre aussi , merci pour vos infos sir sur les erreurs de compilation et de la facilité de débogage , merci

    InformationsquelleAutor Alok Save
  3. 8

    Pour l'exemple que vous venez de donner, je voudrais l'utiliser normalement const. Sauf, bien entendu, le #define peut être utilisé pour la compilation conditionnelle ailleurs:

    #if SOME_DEFINE == 1
    //Conditional code
#endif

    C'est quelque chose que vous ne pouvez pas faire avec une const. Si vous n'avez pas besoin de la valeur pour être accessible à partir du préprocesseur, je dirais que l'utilisation const moins qu'il y a une raison pour laquelle ce n'est pas possible. Il y a quelques trucs à ce sujet dans le C++ FAQ lite, où ils soulignent à juste titre que juste parce que le préprocesseur est "mal", ça ne veut pas dire que vous n'aurez jamais besoin.

    • Je ne dirais pas que la constante ne peut pas être utilisé pour la compilation conditionnelle. Vous pouvez vous spécialiser un modèle pour la constante. Prendre un coup d'oeil here par exemple.
    • Oui, mais je ne peux pas l'utiliser pour conditionnellement #include <windows.h> selon la plate-forme ou quelque chose comme ça. Je dirais donc que ça ne peut pas être utilisé pour certains types de compilation conditionnelle. 😉
    • Je voudrais utiliser le système de compilation de faire une telle sorte de choix, plutôt que de defines.
    • Je ne suis pas toute recommandation sur la façon de faire de la compilation conditionnelle, je suis juste souligner une chose que vous pouvez faire avec #définit qui n'est pas (facilement) réalisé avec un const.
    InformationsquelleAutor Sven
  4. 3

    #define est nécessaire pour faire des choses comme l'inclusion des gardes de travail, parce que le C++ n'est pas un réel module de système d'importation.

    #define provoque un littéral textuelle de substitution. Le préprocesseur comprend la façon de marquer le code source, mais n'ont pas la moindre idée de ce que tout cela signifie réellement. Lorsque vous écrivez #define sum 1, le préprocesseur va sur votre code et un look pour chaque instance du jeton sum et le remplace par le jeton 1.

    Cela a une variété de limites: #define sq(x) x * x ne fonctionnera pas bien si vous l'utilisez comme une sq(3+3); et à l'aide de #define pour une constante ne respecte pas la portée d'une quelconque manière, ni le fait d'associer toute sorte de type de la constante. Cependant, #define peut être utilisé (en particulier en combinaison avec certains autres trucs comme la # et ## préprocesseur opérateurs) pour faire un peu de magie qui par ailleurs n'est pas possible (sauf manuellement en faisant ce que le préprocesseur n').

    • Je dirais que la première phrase est une réponse, et le reste est juste des choses que l'OP probablement déjà connu.
    • J'ai pensé que l'on devrait utiliser #pragma once au lieu de l'inclusion des gardes en C++.
    • #pragma once est spécifique au compilateur. La Norme ne définit pas le sens de pragmas.
    • Mais elle est largement soutenue et, habituellement, #define inutile à cet effet.
    • d'accord, mais la plupart(tous?) les compilateurs de la soutenir.
    InformationsquelleAutor Karl Knechtel
  5. 2

    Toujours essayer d'utiliser un "const int", plutôt que des #define.

    Utiliser des #define, seulement lorsque le préprocesseur code peut être lu par un autre outil, et il est plus facile pour elle d'aller avec le préprocesseur, plutôt que d'analyser la langue.

    Aussi que c'est la seule manière de définir quelque chose à vérifier plus tard par #si/#else/#endif

    InformationsquelleAutor malkia
  6. 1

    De Introduction à la programmation avec C++ qui a été écrit par Daniel Liang a déclaré que:

    Lorsque vous définissez une constante à l'aide de #define directive, la constante est
    pas stockées dans la mémoire.La constante sera remplacé par une valeur par
    compilateur. Lorsque vous déclarez une constante à l'aide de const mot, de la
    constant est stocké dans la mémoire comme variable.

    Si besoin constant d'être utilisé dans plusieurs programmes, utilisez #define de la définir dans fichier d'en-tête de sorte qu'il peut être inclus dans un autre programme. Si la constante utilisée uniquement dans un programme, à l'aide de const à déclarer est plus efficace.

    InformationsquelleAutor John Joe
  7. 0

    const int est juste un int qui ne peuvent pas changer. #define est une directive du préprocesseur C, ce qui est beaucoup plus que juste pour définir des constantes.

    Voir ici pour plus de détails: http://en.wikipedia.org/wiki/C_preprocessor

    • Ne pas répondre à l'OP de la question de savoir pourquoi l'un est utilisé par rapport à l'autre. (Ne veux pas être sévère, mais il n'a vraiment pas de réponse, désolé.) -1
    InformationsquelleAutor robbrit
  8. 0

    En mots simples

    #define sum 1  /*is pre processed*/

    Ce qui signifie, que sum n'existe pas après l'étape de prétraitement est fini.

    const int sum = 1; /*is compiled/linked*/

    Qui signifie sum existe jusqu'à l'exécutable est faite de sortir de votre programme.

    • Ne pas répondre à l'OP de la question de savoir pourquoi l'un est utilisé par rapport à l'autre. (Ne veux pas être sévère, mais il n'a vraiment pas de réponse, désolé.) -1
    • Illustrant pourquoi #define est utilisé sera trop à écrire. C'est pourquoi j'ai gardé les choses simples en disant #define est prétraité. 🙂
    InformationsquelleAutor iammilind
  9. -1

    La première est une directive de préprocesseur, avant de le compilateur compile le code, il faudra passer par le et remplacez-la somme de 1. Le second déclare une variable en mémoire pour contenir cette quantité. Je suis sûr qu'il peut faire valoir à ce qui est meilleur, mais le "const int" est probablement plus fréquent en C++ (quand il s'agit de constantes numériques).

    http://www.geekpedia.com/KB114_What-is-the-difference-between-sharpdefine-and-const.html

    • const int ne pas déclarer une variable dans la mémoire, l'article lié est incorrect.
    • ne pouvez-vous pas faire const int sum = 1; const int* sum_ptr = &sum;?
    • Ne pas répondre à l'OP de la question de savoir pourquoi l'un est utilisé par rapport à l'autre. (Ne veux pas être sévère, mais il n'a vraiment pas de réponse, désolé.) -1
    • "déclarer une variable en mémoire" n'est probablement pas assez précis pour être décrit comme vrai ou faux, vraiment.
    • Fernandes: C++ Standard 7.1.5.1.3: "Un pointeur ou une référence à un cv qualifiés de type n'a pas besoin réellement de point ou de consulter un cv qualifiés de l'objet, mais elle est traitée comme si elle n'." Jetant const-ness et l'affectation à un tel pointeur ou une référence a un comportement indéterminé.
    • Je n'ai pas lu l'article lié. Il est en effet incorrect lorsqu'il dit que "la mémoire est allouée pour la constante". Je vais du côté de Karl et de réclamer "la déclaration d'une variable en mémoire" est suffisamment vague pour être considérée comme correcte 😛
    • L'important, c'est que const int déclare une variable dans portée. C'est la principale différence par rapport à une constante créé avec #define. Si à attribuer à la variable de mémoire ou pas, c'est pour le compilateur.

    InformationsquelleAutor Synxmax