Const avant ou const après?

Pour commencer, vous savez probablement que cela constpeut être utilisé pour rendre les données d'un objet ou 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 avoir de l'importance, c'est de quel côté de l'astérisque vous mettez le constmot - clé. Personnellement, je préfère mettre constà gauche du type pour spécifier que les données ne sont pas modifiables car je trouve qu'elles se lisent mieux dans mon état d'esprit de gauche à droite, mais quelle syntaxe est venue en premier?

Plus important encore, pourquoi y a-t-il deux façons correctes de spécifier les constdonnées et dans quelle situation préféreriez-vous ou auriez-vous besoin de l'une par rapport à l'autre, le cas échéant?

Éditer:

Il semble donc que ce soit une décision arbitraire lorsque la norme sur la façon dont les compilateurs doivent interpréter les choses a été rédigée bien avant ma naissance. Depuis constest appliqué à ce qui est à gauche du mot-clé (par défaut?) Je suppose qu'ils ont pensé qu'il n'y avait aucun mal à ajouter des "raccourcis" pour appliquer des mots-clés et des qualificatifs de type d'une autre manière au moins jusqu'à ce que la déclaration change par analyse d'un * ou & ...

C'était aussi le cas en C alors je suppose?

Pourquoi y a-t-il deux façons correctes de spécifier les constdonnées et dans quelle situation préférez-vous ou avez-vous besoin de l'une par rapport à l'autre, le cas échéant?

Essentiellement, la raison pour laquelle la position des constspécificateurs à l'intérieur avant un astérisque n'a pas d'importance est que la grammaire C a été définie de cette façon par Kernighan et Ritchie.

La raison pour laquelle ils ont défini la grammaire de cette manière était probablement que leur compilateur C analysait l'entrée de gauche à droite et avait fini de traiter chaque jeton au fur et à mesure qu'il consommait cela. La consommation du *jeton change l'état de la déclaration actuelle en un type de pointeur. Rencontre constaprès* signifie que le constqualificatif est appliqué à une déclaration de pointeur; le rencontrer avant le *moyen auquel le qualificatif est appliqué aux données pointées.

Parce que la signification sémantique ne change pas si le const qualificatif apparaît avant ou après les spécificateurs de type, il est accepté dans les deux cas.

Un cas similaire se produit lors de la déclaration de pointeurs de fonction, où:

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

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

Encore une fois, la chose à noter est que la syntaxe du langage prend en charge un analyseur de gauche à droite.

La règle est:

const s'applique à la chose qui en reste. S'il n'y a rien à gauche, cela s'applique à la chose à droite.

Je préfère utiliser const à droite de la chose pour être const juste parce que c'est la manière «originale» de définir const.

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

Je préfère la deuxième syntaxe. Cela m'aide à garder une trace de `` quoi '' est constant en lisant 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

L'ordre des mots-clés dans une déclaration n'est pas tout à fait fixe. Il existe de nombreuses alternatives au «seul vrai ordre». Comme ça

int long const long unsigned volatile i = 0;

ou devrait-il être

volatile unsigned long long int const i = 0;

??

La première règle consiste à utiliser le format requis par vos normes de codage locales. Après cela: mettre le constdevant ne mène à aucune confusion lorsque des typedefs sont impliqués, par exemple:

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

Si votre standard de codage autorise les typedef de pointeurs, alors il devrait vraiment insister pour mettre le const après le type. Dans tous les cas, sauf lorsqu'il est appliqué au type, const doit suivre ce à quoi il s'applique, donc la cohérence plaide également en faveur de la const après. Mais les directives de codage locales l'emportent sur tous ces éléments; la différence n'est normalement pas assez importante pour revenir en arrière et modifier tout le code existant.

Il y a des raisons historiques pour lesquelles la gauche ou la droite est acceptable. Stroustrup avait ajouté const au C ++ en 1983 , mais il ne l'a fait en C qu'en C89 / C90.

En C ++, il y a une bonne raison de toujours utiliser const sur la droite. Vous serez cohérent partout car les fonctions membres const doivent être déclarées de cette façon:

int getInt() const;