int a[] = {1,2,} ; Pourquoi une virgule de fin est-elle autorisée dans une liste d'initialisation ?

Question

Je ne suis peut-être pas de cette planète, mais il me semble que ce qui suit devrait être une erreur de syntaxe :

int a[] = {1,2,}; //extra comma in the end

Mais ce n'est pas le cas. J'ai été surpris par la compilation de ce code sur Visual Studio, mais j'ai appris à ne pas faire confiance au compilateur MSVC en ce qui concerne les règles du C++. est également autorisé par la norme. Si vous ne me croyez pas, vous pouvez consulter le point 8.5.1 pour les règles de grammaire.

Pourquoi cela est-il autorisé ? Il s'agit peut-être d'une question stupide et inutile, mais je veux que vous compreniez pourquoi je vous la pose. S'il s'agissait d'un sous-cas d'une règle de grammaire générale, je comprendrais - ils ont décidé de ne pas rendre la grammaire générale plus difficile juste pour interdire une virgule redondante à la fin d'une liste d'initialisateurs. Mais non, la virgule supplémentaire est explicitement autorisé. Par exemple, il n'est pas permis d'avoir une virgule redondante à la fin d'une liste d'arguments d'un appel de fonction (lorsque la fonction prend ... ), ce qui est normal .

Alors, encore une fois, y a-t-il une raison particulière pour laquelle cette virgule redondante est explicitement autorisé ?

Answer 1

Il facilite la génération du code source et l'écriture d'un code qui peut être facilement étendu ultérieurement. Réfléchissez à ce qu'il faut faire pour ajouter une entrée supplémentaire à.. :

int a[] = {
   1,
   2,
   3
};

... il faut ajouter la virgule à la ligne existante et ajouter une nouvelle ligne. Comparez cela avec le cas où les trois déjà est suivi d'une virgule, où il suffit d'ajouter une ligne. De même, si vous souhaitez supprimer une ligne, vous pouvez le faire sans vous soucier de savoir s'il s'agit de la dernière ligne ou non, et vous pouvez réorganiser les lignes sans vous préoccuper des virgules. En gros, cela signifie qu'il y a une uniformité dans la façon dont vous traitez les lignes.

Pensez maintenant à générer du code. Quelque chose comme (pseudo-code) :

output("int a[] = {");
for (int i = 0; i < items.length; i++) {
    output("%s, ", items[i]);
}
output("};");

Il n'est pas nécessaire de se demander si l'élément que vous écrivez est le premier ou le dernier. C'est beaucoup plus simple.

Answer 2

C'est utile si vous faites quelque chose comme ça :

int a[] = {
  1,
  2,
  3, //You can delete this line and it's still valid
};

Answer 3

La facilité d'utilisation pour le développeur, je pense.

int a[] = {
            1,
            2,
            2,
            2,
            2,
            2, /*line I could comment out easily without having to remove the previous comma*/
          }

En outre, si, pour une raison quelconque, vous avez un outil qui génère du code pour vous, l'outil n'a pas à se préoccuper de savoir si c'est le dernier élément de l'initialisation ou non.

Answer 4

J'ai toujours pensé que cela facilitait l'ajout d'éléments supplémentaires :

int a[] = {
            5,
            6,
          };

devient simplement :

int a[] = { 
            5,
            6,
            7,
          };

à une date ultérieure.

Answer 5

La virgule de fin est autorisée, je crois, pour des raisons de compatibilité ascendante. Il y a beaucoup de code existant, principalement généré automatiquement, qui met une virgule de fin. Cela facilite l'écriture d'une boucle sans condition particulière à la fin. Par exemple

for_each(my_inits.begin(), my_inits.end(),
[](const std::string& value) { std::cout << value << ",\n"; });

Il n'y a pas vraiment d'avantage pour le programmeur.

P.S. Bien qu'il soit plus facile d'autogénérer le code de cette manière, j'ai toujours pris soin de ne pas mettre la virgule de fin, les efforts sont minimes, la lisibilité est améliorée, et c'est le plus important. Vous écrivez du code une fois, vous le lisez plusieurs fois.