int a[] = {1,2,}; Bizarre virgule permis. Une raison en particulier?

Il est plus facile de générer du code source, et aussi d'écrire du code qui peut être facilement étendu à une date ultérieure. Considérer ce qui est nécessaire pour ajouter une entrée supplémentaire:

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

... vous devez ajouter la virgule à la ligne existante et ajouter une nouvelle ligne. Comparer avec le cas où les trois déjà a une virgule après elle, où vous avez juste à ajouter une ligne. De même, si vous souhaitez supprimer une ligne, vous pouvez le faire sans se soucier de savoir si c'est la dernière ligne ou pas, et vous pouvez réorganiser les lignes sans besoin de se battre avec des virgules. Fondamentalement, cela signifie qu'il y a une uniformité dans la façon dont vous traitez les lignes.

Maintenant, pensez à la génération de code. Quelque chose comme (pseudo-code):

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

Pas besoin de s'inquiéter de savoir si l'actuel article que vous écrivez est le premier ou le dernier. Beaucoup plus simple.

OriginalL'auteur Jon Skeet

La facilité d'utilisation pour les développeurs, 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 quelque raison que ce soit vous aviez un outil que le code généré pour vous; l'outil n'avez pas à vous soucier de savoir si c'est le dernier élément de l'initialiser ou non.

OriginalL'auteur vcsjones

Tout tout le monde a dit à propos de la facilité d'ajout/suppression/création de lignes est correcte, mais le lieu réel de cette syntaxe brille est lors de la fusion de fichiers source d'ensemble. Imaginez que vous avez ce tableau:

int ints[] = {
    3,
    9
};

Et supposons que vous avez vérifié ce code dans un référentiel.

Alors votre copain l'édite, en ajoutant à la fin:

int ints[] = {
    3,
    9,
    12
};

Et vous modifier simultanément, en lui ajoutant des le début:

int ints[] = {
    1,
    3,
    9
};

Sémantiquement ces sortes d'opérations (en ajoutant au début, en ajoutant à la fin), devrait être entièrement fusion et de la gestion des versions de logiciels (heureusement git) devrait être en mesure de automerge. Malheureusement, ce n'est pas le cas parce que votre version n'a pas de virgule après le 9 et votre copain n'. Considérant que, si la version d'origine a l'arrière 9, ils auraient automerged.

Donc, ma règle d'or est: l'utilisation de la virgule si la liste s'étend sur plusieurs lignes, ne l'utilisez pas si la liste est sur une seule ligne.

OriginalL'auteur amoss

L'une des raisons pour cela est autorisé pour autant que je sais, c'est qu'il devrait être simple de générer automatiquement du code; vous n'avez pas besoin d'un traitement spécial pour le dernier élément.

OriginalL'auteur Fredrik Pihl

Je suis surpris, après tout ce temps personne n'a cité le Annoté C++ Manuel De Référence(BRAS), il est dit ce qui suit au sujet de [dcl.init] avec l'accent de la mine:

Il y a clairement trop de notations pour les initialisations, mais chacun semble servir un style particulier d'utilisation. La ={initializer_list,opt} notation a été hérité de C et sert bien pour l'initialisation des structures de données et les tableaux. [...]

bien que la grammaire a évolué depuis BRAS a été écrit à l'origine en reste.

et nous pouvons aller à la C99 justification pour voir pourquoi il a été autorisé en C et il dit:

K&R permet une virgule dans un initialiseur à la fin d'une
initialisation de la liste. Le Standard a conservé cette syntaxe, car il
offre de la souplesse dans ajouter ou supprimer des membres d'un initialiseur
liste, et simplifie la machine de génération de ces listes.

OriginalL'auteur Shafik Yaghmour

C'est plus facile pour les machines, c'est à dire l'analyse et la génération de code.
Il est également plus facile pour les humains, c'est à dire de modification, de les commenter, et le visuel de l'élégance grâce à la cohérence.

En supposant que C, seriez-vous d'écrire la suite?

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    puts("Line 1");
    puts("Line 2");
    puts("Line 3");

    return EXIT_SUCCESS
}

Pas. Pas seulement parce que l'état final est une erreur, mais aussi parce que c'est incohérent. Alors pourquoi faire de même pour les collections? Même dans les langues qui vous permet d'omettre la dernière des points-virgules et les virgules, la communauté a l'habitude de ne l'aime pas. La communauté Perl, par exemple, ne semble pas aimer l'omission des points-virgules, bar one-liners. Ils appliquent que pour des virgules.

N'omettez pas de virgules dans multiligne collections pour la même raison, vous n'avez pas omettre des points-virgules pour multiligne blocs de code. Je veux dire, vous ne pouvez pas le faire, même si la langue a permis, non? Droit?

OriginalL'auteur Louis

La raison est simple: la facilité d'ajout/suppression de lignes.

Imaginez le code suivant:

int a[] = {
   1,
   2,
   //3, //- not needed any more
};

Maintenant, vous pouvez facilement ajouter/supprimer des éléments de la liste sans avoir à ajouter/supprimer la virgule parfois.

Contrairement à d'autres réponses, je ne pense vraiment pas que la facilité de génération de la liste est une raison valable: après tout, il est trivial pour que le code spécial de la dernière (ou première) ligne. -Générateurs de Code sont écrits à la fois et utilisé de nombreuses fois.

OriginalL'auteur Vlad

Il est permis de le protéger contre les erreurs causées par le déplacement d'éléments dans une liste.

Par exemple, imaginons que nous avons un code qui ressemble à ceci.

#include <iostream>
#include <string>
#include <cstddef>
#define ARRAY_SIZE(array) (sizeof(array) / sizeof *(array))
int main() {
    std::string messages[] = {
        "Stack Overflow",
        "Super User",
        "Server Fault"
    };
    size_t i;
    for (i = 0; i < ARRAY_SIZE(messages); i++) {
        std::cout << messages[i] << std::endl;
    }
}

Et c'est génial, car il montre que la trilogie originale de la Pile des sites d'Échange.

Stack Overflow
Super User
Server Fault

Mais il y a un problème avec elle. Vous voyez, le pied de page sur ce site web montre de Serveur Faute avant le Super Utilisateur. Mieux corriger ça avant que quelqu'un ne le remarque.

#include <iostream>
#include <string>
#include <cstddef>
#define ARRAY_SIZE(array) (sizeof(array) / sizeof *(array))
int main() {
    std::string messages[] = {
        "Stack Overflow",
        "Server Fault"
        "Super User",
    };
    size_t i;
    for (i = 0; i < ARRAY_SIZE(messages); i++) {
        std::cout << messages[i] << std::endl;
    }
}

Après tout, le déplacement des lignes autour ne pouvait pas être si difficile que ça, pourrait-il être?

Stack Overflow
Server FaultSuper User

Je sais, il n'y a pas de site web appelé "Serveur FaultSuper Utilisateur", mais notre compilateur prétend qu'il existe. Maintenant, le problème est que C est une concaténation de chaîne automatique, qui vous permet d'écrire deux chaînes entre guillemets doubles et les concaténer en utilisant rien d'autre (même problème peut également se produire avec des nombres entiers, comme - signe a plusieurs sens).

Maintenant, si le tableau d'origine avait une inutile virgule à la fin? Ainsi, les lignes seraient déplacés, mais tel bug ne serait pas arrivé. Il est facile de rater quelque chose d'aussi petit qu'une virgule. Si vous n'oubliez pas de mettre une virgule après chaque élément du tableau, tel bug juste ne peut pas se produire. Vous ne veulent pas perdre de quatre heures de débogage quelque chose, jusqu'à ce que vous trouver la virgule est la cause de vos problèmes.

OriginalL'auteur Konrad Borowski

En plus à la génération de code et l'édition de facilité, si vous souhaitez mettre en place un analyseur, ce type de grammaire est plus simple et plus facile à mettre en œuvre. C# suit cette règle à plusieurs endroits qu'il y a une liste séparée par des virgules des éléments, comme les éléments d'une enum définition.

OriginalL'auteur Iravanchi

Si vous utilisez un tableau sans longueur spécifiée,VC++6.0 peut automatiquement identifier sa longueur,de sorte que si vous utilisez "int a[]={1,2,};"la longueur est de 3,mais ce dernier n'a pas été initialisée,vous pouvez utiliser le "cout<

OriginalL'auteur zhi_jian