Const avant ou const après ?

Question

Pour commencer, vous savez probablement que const peut être utilisé pour rendre les données d'un objet ou un pointeur non modifiable 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 est le côté de l'astérisque où vous mettez le const mot-clé. Personnellement, je préfère mettre const à gauche du type pour spécifier que ses données ne sont pas modifiables, car je trouve que cela se lit mieux dans mon 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 const et dans quelle situation préféreriez-vous ou auriez-vous besoin de l'un plutôt que de l'autre, le cas échéant ?

Edit :

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

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

Answer 1

pourquoi y a-t-il deux façons correctes de spécifier const et dans quelle situation préféreriez-vous ou auriez-vous besoin de l'un plutôt que de l'autre, le cas échéant ?

Essentiellement, la raison pour laquelle la position de const dans les spécificateurs 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 finissait de traiter chaque jeton au fur et à mesure qu'il le consommait. Consommer le * change l'état de la déclaration actuelle en un type de pointeur. Rencontre avec const après * signifie que const est appliqué à la déclaration d'un pointeur ; s'il est rencontré avant la déclaration de l'indicateur * signifie que le qualificatif est appliqué aux données pointées.

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

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

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

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

Une fois encore, il convient de noter que la syntaxe du langage prend en charge un analyseur syntaxique de gauche à droite.

Answer 2

La règle est la suivante :

const s'applique à ce qu'il en reste. S'il n'y a rien à gauche, elle s'applique à la chose qui est à sa droite.

Je préfère utiliser const à droite de la chose qui doit être const, simplement parce que c'est la façon "originale" dont const est défini.

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

Answer 3

Je préfère la deuxième syntaxe. Elle m'aide à garder la trace de "ce qui" 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

Answer 4

L'ordre des mots-clés dans une déclaration n'est pas si fixe que ça. Il existe de nombreuses alternatives au "seul véritable ordre". Par exemple

int long const long unsigned volatile i = 0;

ou devrait-il être

volatile unsigned long long int const i = 0;

? ?

Answer 5

La première règle est d'utiliser le format que vos normes de codage locales exigent. Ensuite, il faut mettre le const devant mène à une confusion sans fin lorsque confusion lorsque des typedefs sont impliqués, par ex :

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

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