Const avant ou const après?

Pour commencer, vous savez probablement que const peut être utilisé pour présenter des données d'un objet ou d'un pointeur non modifiables ou les deux.

const Object* obj; //can't change data
Object* const obj; //can't change pointer
const Object* const obj; //can't change data or pointer

Cependant, vous pouvez également utiliser la syntaxe:

Object const *obj; //same as const Object* obj;

La seule chose qui semble compter, c'est de quel côté de l'astérisque, vous mettez le const mot-clé. Personnellement, je préfère les mettre const sur la gauche de la type pour spécifier des données n'est pas modifiable car je trouve qu'il se lit mieux, à mon de gauche à droite mentalité, mais dont la syntaxe est venu en premier?

Plus important encore, pourquoi il y a deux façons correctes de la spécification const de données et dans quelle situation vous préférez ou besoin de l'un sur l'autre si?

Edit:

De sorte qu'il semble que cela a été une décision arbitraire, lorsque la norme pour la façon dont les compilateurs doivent interpréter les choses a été rédigé avant ma naissance. Depuis const est appliqué à ce qui est à gauche du mot-clé (par défaut?) Je suppose qu'ils ont compris, il n'y a pas de mal à ajouter "raccourcis" pour appliquer des mots-clés et le type de qualificatifs à d'autres égards, au moins jusqu'à ce que les modifications de déclaration par l'analyse d'un * ou & ...

Ce fut le cas en C et puis je suppose?

  • Dans les macros toujours ajouter const après le type, par exemple #define MAKE_CONST(T) T const au lieu de #define MAKE_CONST(T) const T de sorte que MAKE_CONST(int *) correctement s'étendre à int * const au lieu de const int *.
  • J'ai vu ces deux styles dénommé "est const" et "ouest " const".
  • mais vraiment, il devrait être "est const" et "const ouest".
InformationsquelleAutor AJG85 | 2011-03-31
  1. 84

    pourquoi il y a deux façons correctes de la spécification const de données et dans quelle situation vous préférez ou besoin de l'un sur l'autre si?

    Essentiellement, le motif de la position de const dans les spécificateurs avant qu'un astérisque n'a pas d'importance, c'est que le C de la grammaire a été défini ainsi par Kernighan et Ritchie.

    La raison, ils ont défini la grammaire de cette manière était probable que leur compilateur C analysé l'entrée de gauche à droite et a terminé le traitement de chaque jeton comme elle a consommé que. La consommation de la * jeton de changements de l'état actuel de la déclaration d'un type pointeur. Rencontre const après * signifie la const qualificatif est appliqué à une déclaration de pointeur; en rencontrant avant le * signifie le qualificatif est appliquée aux données souligné.

    Parce que la sémantique ne change pas si le const qualificatif avant ou après les spécificateurs de type, il est admis à l'autre.

    Une sorte semblable de cas se pose lors de la déclaration des pointeurs de fonction, d'où:

    • void * function1(void) déclare une fonction qui retourne void *,

    • void (* function2)(void) déclare un pointeur de fonction à une fonction qui retourne void.

    De nouveau la chose à remarquer est que la syntaxe de la langue prend en charge une gauche à droite de l'analyseur.

    • Kernighan co-auteur du livre, mais n'était pas impliqué dans la conception de C, juste Ritchie.
    • OMG, Jusqu'à ce que le temps que j'ai penser à la fois le K&R C a écrit, maintenant, vous dites K seulement d'écrire le livre du C pas du C?
    • Je n'ai jamais pu me rappeler qui est qui. Grâce à vos explications, j'ai enfin pu mnemotechnic de le rappeler. Merci! Avant * analyseur de compilateur ne sait pas qu'il est pointeur donc il est const pour les données de la valeur. Après * elle est liée à la constante pointeur. Brillant. Et enfin, il explique pourquoi je peux faire const char ainsi que char const.
    • Le deviner pourquoi il a été fait de cette façon semble plutôt faible et contradictoire en soi pour moi. Qui est, si je ont été la définition d'une langue et l'écriture d'un compilateur, et je voulais garder les choses simples et "analyser entrée de gauche à droite et de terminer le traitement de chaque jeton qu'il consomme", comme vous dites, il me semble que j'aurais besoin que l' const de toujours venir après que la chose qualification... exactement, donc je peux toujours terminer le traitement de la const immédiatement après, je le consomme. Si cela semble être un argument pour interdisant ouest-const, plutôt que de permettre qu'il.
    • "Parce que la sémantique ne change pas si le qualificatif const avant ou après les spécificateurs de type, il est admis de toute façon." N'est-ce pas un raisonnement circulaire? La question est de pourquoi la sémantique, le sens est défini comme ça, donc je ne pense pas que cette phrase contribue en quoi que ce soit.
    • Vous devez vous rappeler que, par rapport à aujourd'hui et les hypothèses que nous faisons basé sur notre familiarité avec un bon langage de programmation, de conception, de langues ont assez de nouvelles choses alors. Aussi, si l'on a un défaut d'entretien ou restreinte de la langue est un jugement de valeur. E. g., devrait python ont une ++ opérateur? "La phrase", à mon humble avis, m'a aidé à comprendre il n'y avait aucune raison particulière autre que parce qu'ils le pouvaient. Peut-être qu'ils feraient un choix différent aujourd'hui, peut-être pas.
    • Plus simple d'avoir un de moins conditionnelle. Il faut moins logique et moins juste à définir un indicateur booléen sur l'analyse const sans vérifier si il est venu avant ou après.

    InformationsquelleAutor Heath Hunnicutt
  2. 65

    La règle est la suivante:

    const s'applique à la chose qu'il en reste. Si il n'y a rien sur la gauche, ensuite il s'applique à la chose droite.

    Je préfère utiliser const sur le droit de la chose à const juste parce que c'est "l'original" façon const est défini.

    Mais je pense que c'est très subjectif point de vue.

    • Je préfère le mettre sur la gauche, mais je pense que de le mettre sur le droit a plus de sens. Vous lire généralement les types en C++ à partir de la droite-à-gauche, par exemple Object const * est un pointeur vers un const Objet. Si vous mettez la const sur la gauche, il se lise comme un pointeur vers un Objet qui est const, qui n'a pas vraiment de flux très bien.
    • Il n'y a aucune "règle". Avez-vous de toute référence à quelque chose qui revendique, il ya une telle "règle"?
    • J'ai l'impression que sur la gauche est pour l'homme-style de cohérence avec d'autres types de déclarations en C (informatique-sage, il n'est pas correct comme const n'est pas un espace de stockage de classe, mais les gens ne sont pas des analyseurs).
    • Je crois que c'est plus d'une ligne directrice que d'une règle et je l'ai entendu souvent comme un moyen de se souvenir de la façon dont le compilateur va l'interpréter ... je comprends comment ça fonctionne si j'étais seulement curieux de connaître le processus de pensée derrière la décision de l'appui de deux manières.
    • la règle existe, mais c'est juste un peu plus compliqué: c-faq.com/decl/spiral.anderson.html
    • que ne traite pas le style de la question de savoir si const devrait aller de l'avant ou après le type. Et si elle le fait, c'est juste des conseils, pas une règle. La norme est la règle, et il ne fait pas de discrimination de ces deux stages de mot-clé const.
    • la spirale de la règle est la version augmentée de l'auteur du commentaire "Vous lire généralement les types [/C]C++ à partir de la droite-à-gauche". Je présume que vous ont été contredisant cette. Cependant, je pense que vous pouvez à la place ont été en se référant à la réponse elle-même.
    • Même la lecture de droite à gauche fait plus de sens et il est probable que l ' "original" ainsi, le C++ lignes Directrices de Base marqué "const" après " est mauvais 🙂 isocpp.github.io/CppCoreGuidelines/...
    • Bien qu'il soit utile d'aide-mémoire, c'est un peu trompeur de dire que, dans int *const p; la const s'applique à la * plutôt que la chose sur sa droite, p, qui est bien sûr ce qui est const qualifiés dans ce cas.
    • La "règle", a déclaré ici est clairement destinée à être une description de ce qui const signifie... en tant que tel, c'est correct, non? Cela ressemble peut-être que vous avez mal interprété comme étant destiné à être un style de recommandations / conseils / mandat.

    InformationsquelleAutor horstforst
  3. 49

    Je préfère la deuxième syntaxe. Il m'aide à garder une trace de ce qui est constant, par la lecture de la déclaration de type de droite à gauche:

    Object * const obj;        //read right-to-left:  const pointer to Object
Object const * obj;        //read right-to-left:  pointer to const Object
Object const * const obj;  //read right-to-left:  const pointer to const Object
    • Exactement. Un "pointeur constant vers un objet constant" est Object const* const, pas const const Object*. "const" ne peut pas être sur la gauche, sauf dans le cas spécial où tant de gens l'adore. (Voir Heath ci-dessus).
    InformationsquelleAutor Matt Davis
  4. 35

    L'ordre des mots dans une déclaration n'est pas fixe. Il existe de nombreuses solutions de rechange "le seul vrai ordre". Comme ce

    int long const long unsigned volatile i = 0;

    ou devrait-il être

    volatile unsigned long long int const i = 0;

    ??

    • +1 pour un fait déroutant définition d'une variable simple. 🙂
    • Sont-ils tous légaux?
    • Oui, malheureusement, ils sont. La grammaire dit simplement qu'un decl-specifier-seq est une séquence de decl-specifiers. Il n'y a pas d'ordre donné par la grammaire, et le nombre d'événements pour chaque mot-clé est limitée uniquement par des règles sémantiques (vous pouvez avoir un const mais deux long 🙂
    • qu'en est unsigned? J'ai pensé unsigned long etc. étaient des types qui leur est propre, et que unsigned n'était pas vraiment un spécificateur de son propre chef?
    • Oui, unsigned est un type, le même que unsigned int et int unsigned. unsigned long est un autre type, le même que unsigned long int et int long unsigned. Voir le modèle?
    • Je vois le gâchis, a obtenu d'avoir de trois à voir un modèle ;). OK, merci
    • Vous avez utilisé pour être en mesure d'ajouter static pour le pêle-mêle de mots, mais c'est seulement récemment que les compilateurs se sont plaints que static doit venir d'abord.
    • ce qu'il veut dire que unsigned par lui-même est juste un raccourci pour unsigned int (si ce n'était pas clair), de la même façon short par lui-même est le même que short int. (Bien faire attention, il y a une différence entre l'utilisation de char vs unsigned/signed char... ce n'est pas un type de son propre, mais il a son propre sens, car un char pourrait être signé ou non signé à l'interne et il n'a pas vraiment d'importance qui, mais, fondamentalement, essayez de garder les choses cohérentes et pour les fonctions de bibliothèque standard, il suffit d'utiliser le plaine char et de la laisser utiliser sa propre représentation interne.)

    InformationsquelleAutor Bo Persson
  5. 6

    La première règle consiste à utiliser quel que soit le format de votre région normes de codage
    nécessite. D'après: mettre le const devant entraîne pas la fin de
    la confusion quand les typedefs sont impliqués, par exemple:

    typedef int* IntPtr;
const IntPtr p1;   //same as int* const p1;

    Si votre norme de codage permet de définition de type de pointeurs, puis il vraiment
    devrait insister sur la mise const après le type. Dans tous les cas, mais
    lorsqu'il est appliqué à la type, const doit suivre ce qu'il s'applique, de sorte
    la cohérence plaide également en faveur de la const après. Mais de codage local
    lignes directrices préséance sur tous les de ces, la différence n'est normalement pas important
    assez pour revenir en arrière et modifier tout le code existant.

    • Je pense que cela peut mettre en évidence la raison pour laquelle nous avons ne pas ont typedefs de pointeurs dans notre assez vaguement défini des normes dans cette boutique.
    • Ma politique (quand j'arrive à décider seul) c'est que la const après (pour des raisons de cohérence) et de ne pas utiliser typedefs à des pointeurs (ou typedefs beaucoup en général):-). Et BTW, string::iterator vs string::const_iterator devrait probablement être pris en compte dans votre décision ainsi. (Juste pour confondre les choses:-). Il n'y a pas de bonne réponse.)
    • Ah oui je pouvais avoir inclus le comportement de const std::string::const_iterator ainsi, pour faire bonne mesure 😉
    • C'est un bon exemple, et je suis d'accord avec James Kanze. Cependant, il ya une utilisation dans typedeffing un pointeur: Lorsque vous à vous voulez utiliser un smart-point plus tard.
    • Attendez une minute, aide-moi à sortir d'ici... je ne vois pas la confusion dans la posté exemple. Quoi d'autre pourrait const IntPtr p1 peut-être dire autre que "constante pointeur entier" (c'est à dire, "pointeur constant integer")? Personne dans leur bon esprit, même sans savoir comment IntPtr est défini, pourrait penser que p1 est mutable. Et d'ailleurs, pourquoi serait-on penser, à tort, que *p1 est immuable? Qui plus est, en mettant l'const n'importe où ailleurs (par exemple, IntPtr const p1), ne change pas la sémantique à tous.
    • Vous ne pourriez pas voir la confusion, mais la plupart des programmeurs C++ n', et systématiquement mal (sans doute aidé par des choses comme std::vector<T>::const_iterator, où il n'est pas l'itérateur qui est const, mais ce qu'il désigne).
    • Personnellement, j'aurais pensé const IntPtr p1 signifie la même chose que const int *p1 (aka int const *p1). Je n'aurais pas connu avec certitude ce que cela signifie et je voudrais vraiment avoir été confondu.

    InformationsquelleAutor James Kanze
  6. 6

    Il y a des raisons historiques qui soit de gauche ou de droite est acceptable. Stroustrup a ajouté const en C++ en 1983, mais il n'a pas de C jusqu'à ce que C89/C90.

    En C++ il y a une bonne raison de toujours utiliser const sur la droite. Vous allez être uniforme partout, parce que const fonctions de membre doit être déclaré ainsi:

    int getInt() const;
    • ...ainsi, la "bonne raison" n'est pas très convaincante, car d'autres emplacements possibles pour le "const" ne signifie pas la même chose. const int& getInt(); int& const getInt();
    • Je suggère int const& getInt(); est mieux que l'équivalent const int& getInt(); alors que int& const getInt(); que vous la comparez avec est redondant (les références sont déjà const) si la régularité et l'habitude de donner un avertissement. De toute façon, const sur une fonction membre des changements de la this pointeur dans la fonction de Foo* const à Foo const* const.
    • const sur une fonction membre ne signifie pas du tout la même chose—ou est void set(int)&; quelque sorte d'une référence à une fonction?
    InformationsquelleAutor Nick Westgate