int a [] = {1,2,}; Virgola strana consentita. Qualche motivo particolare?

Forse non vengo da questo pianeta, ma mi sembra che quanto segue dovrebbe essere un errore di sintassi:

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

Ma non lo è. Sono stato sorpreso quando questo codice è stato compilato su Visual Studio, ma ho imparato a non fidarmi del compilatore MSVC per quanto riguarda le regole C ++, quindi ho controllato lo standard ed è consentito anche dallo standard. Puoi vedere 8.5.1 per le regole grammaticali se non mi credi.

Perché è permesso? Questa potrebbe essere una stupida domanda inutile, ma voglio che tu capisca perché lo sto chiedendo. Se fosse un sotto-caso di una regola grammaticale generale, capirei: hanno deciso di non rendere la grammatica generale più difficile solo per non consentire una virgola ridondante alla fine di un elenco di inizializzatori. Ma no, la virgola aggiuntiva è esplicitamente consentita. Ad esempio, non è consentito avere una virgola ridondante alla fine di un elenco di argomenti di chiamata di funzione (quando la funzione accetta ...), che è normale .

Quindi, di nuovo, c'è qualche motivo particolare per cui questa virgola ridondante è esplicitamente consentita?

Semplifica la generazione di codice sorgente e anche la scrittura di codice che può essere facilmente esteso in un secondo momento. Considera cosa è necessario per aggiungere una voce aggiuntiva a:

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

... devi aggiungere la virgola alla riga esistente e aggiungere una nuova riga. Confrontalo con il caso in cui i tre già una virgola dopo di essa, in cui devi solo aggiungere una riga. Allo stesso modo, se vuoi rimuovere una linea, puoi farlo senza preoccuparti se è l'ultima linea o meno, e puoi riordinare le linee senza armeggiare con le virgole. Fondamentalmente significa che c'è un'uniformità nel modo in cui tratti le linee.

Ora pensa a generare codice. Qualcosa di simile (pseudo-codice):

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

Non devi preoccuparti se l'elemento corrente che stai scrivendo è il primo o l'ultimo. Molto più semplice

È utile se fai qualcosa del genere:

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

Facile da usare per lo sviluppatore, penso.

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

Inoltre, se per qualsiasi motivo disponessi di uno strumento che ha generato codice per te; lo strumento non deve preoccuparsi se è l'ultimo elemento nell'inizializzazione o meno.

Ho sempre pensato che rendere più semplice aggiungere ulteriori elementi:

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

diventa semplicemente:

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

in un secondo momento.

Tutto ciò che tutti dicono sulla facilità di aggiungere / rimuovere / generare linee è corretto, ma il vero posto che questa sintassi brilla è quando si uniscono i file di origine. Immagina di avere questo array:

int ints[] = {
    3,
    9
};

E supponi di aver controllato questo codice in un repository.

Quindi il tuo amico lo modifica, aggiungendo alla fine:

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

E lo modifichi simultaneamente, aggiungendo all'inizio:

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

Semanticamente questo tipo di operazioni (aggiungendo all'inizio, aggiungendo alla fine) dovrebbe essere completamente sicuro e il tuo software di controllo delle versioni (speriamo che git) dovrebbe essere in grado di automergere. Purtroppo, questo non è il caso perché la tua versione non ha una virgola dopo il 9 e quella del tuo amico. Considerando che, se la versione originale avesse il 9 finale, avrebbero automerged.

Quindi, la mia regola empirica è: usare la virgola finale se l'elenco si estende su più righe, non usarlo se l'elenco è su una sola riga.

La virgola finale credo sia consentita per motivi di compatibilità con le versioni precedenti. C'è molto codice esistente, principalmente generato automaticamente, che mette una virgola finale. Semplifica la scrittura di un loop senza condizioni speciali alla fine. per esempio

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

Non c'è davvero alcun vantaggio per il programmatore.

PS Sebbene sia più facile generare automaticamente il codice in questo modo, in realtà mi sono sempre preoccupato di non mettere la virgola finale, gli sforzi sono minimi, la leggibilità è migliorata e questo è più importante. Scrivi il codice una volta, lo leggi molte volte.

Uno dei motivi per cui è consentito, per quanto ne so, è che dovrebbe essere semplice generare automaticamente il codice; non è necessaria alcuna gestione speciale per l'ultimo elemento.

Rende più facili i generatori di codice che emettono array o enumerazioni.

Immaginare:

std::cout << "enum Items {\n";
for(Items::iterator i(items.begin()), j(items.end); i != j; ++i)
    std::cout << *i << ",\n";
std::cout << "};\n";

Vale a dire, non è necessario eseguire una gestione speciale del primo o dell'ultimo elemento per evitare di sputare la virgola finale.

Se il generatore di codice è scritto in Python, ad esempio, è facile evitare di sputare la virgola finale usando la str.join()funzione:

print("enum Items {")
print(",\n".join(items))
print("}")

Sono sorpreso dopo tutto questo tempo che nessuno ha citato il Manuale di riferimento C ++ annotato ( ARM ), dice quanto segue su [dcl.init] con enfasi il mio:

Esistono chiaramente troppe notazioni per le inizializzazioni, ma ognuna sembra servire bene un particolare stile di utilizzo. La notazione = {initializer_list, opt} è stata ereditata da C e serve bene per l'inizializzazione di strutture e matrici di dati. [...]

sebbene la grammatica si sia evoluta da quando è stato scritto ARM, l'origine rimane.

e possiamo andare alla logica C99 per vedere perché questo è stato permesso in C e dice:

K&R consente una virgola finale in un inizializzatore alla fine di un elenco di inizializzatori. Lo standard ha mantenuto questa sintassi, poiché fornisce flessibilità nell'aggiunta o eliminazione di membri da un elenco di inizializzatori e semplifica la generazione automatica di tali elenchi.

Vedo un caso d'uso che non è stato menzionato in altre risposte, i nostri macro preferiti:

int a [] = {
#ifdef A
    1, //this can be last if B and C is undefined
#endif
#ifdef B
    2,
#endif
#ifdef C
    3,
#endif
};

L'aggiunta di macro per gestire l'ultimo ,sarebbe un grande dolore. Con questo piccolo cambiamento nella sintassi, questo è banale da gestire. E questo è più importante del codice generato dalla macchina perché di solito è molto più facile farlo in Turing langue completo rispetto a un preprocesor molto limitato.

L'unico linguaggio in cui - in pratica * - non è consentito è Javascript e causa una quantità innumerevole di problemi. Ad esempio, se copi e incolli una linea dal centro dell'array, la incolli alla fine e dimentichi di rimuovere la virgola, il tuo sito verrà completamente interrotto per i tuoi visitatori IE.

* In teoria è consentito, ma Internet Explorer non segue lo standard e lo considera un errore

È più facile per le macchine, ovvero l'analisi e la generazione di codice. È anche più facile per gli esseri umani, ovvero modifica, commento e eleganza visiva tramite coerenza.

Supponendo C, scriveresti quanto segue?

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

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

    return EXIT_SUCCESS
}

No. Non solo perché la dichiarazione finale è un errore, ma anche perché è incoerente. Quindi perché fare lo stesso con le collezioni? Anche nelle lingue che ti consentono di omettere gli ultimi punti e virgole e virgole, alla community di solito non piace. La comunità Perl, ad esempio, non sembra voler omettere i punti e virgola, escludendo le righe. Lo applicano anche alle virgole.

Non omettere le virgole nelle raccolte multilinea per lo stesso motivo per cui non si omettono punti e virgola per blocchi di codice multilinea. Voglio dire, non lo faresti anche se la lingua lo permettesse, giusto? Destra?

Il motivo è banale: facilità di aggiunta / rimozione di linee.

Immagina il seguente codice:

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

Ora, puoi facilmente aggiungere / rimuovere elementi dall'elenco senza dover aggiungere / rimuovere la virgola finale a volte.

Contrariamente ad altre risposte, non credo davvero che la facilità di generare l'elenco sia un motivo valido: dopo tutto, è banale che il codice specifichi l'ultima riga (o la prima). I generatori di codice vengono scritti una volta e utilizzati più volte.

Consente a ogni riga di seguire la stessa forma. In primo luogo ciò semplifica l'aggiunta di nuove righe e un sistema di controllo della versione tiene traccia delle modifiche in modo significativo e consente anche di analizzare il codice più facilmente. Non riesco a pensare a un motivo tecnico.

Ciò è consentito per proteggere da errori causati dallo spostamento di elementi in un lungo elenco.

Ad esempio, supponiamo di avere un codice simile a questo.

#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;
    }
}

Ed è fantastico, in quanto mostra la trilogia originale dei siti di Stack Exchange.

Stack Overflow
Super User
Server Fault

Ma c'è un problema con esso. Vedete, il piè di pagina su questo sito Web mostra Server Fault prima di Super User. Meglio risolverlo prima che qualcuno se ne accorga.

#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;
    }
}

Dopotutto, spostare le linee non potrebbe essere così difficile, vero?

Stack Overflow
Server FaultSuper User

Lo so, non esiste un sito Web chiamato "Server FaultSuper User", ma il nostro compilatore afferma che esiste. Ora, il problema è che C ha una funzione di concatenazione di stringhe, che consente di scrivere due stringhe tra virgolette doppie e concatenarle usando nulla (problema simile può verificarsi anche con numeri interi, poiché il -segno ha significati multipli).

E se la matrice originale avesse una virgola inutile alla fine? Bene, le linee sarebbero state spostate, ma un tale bug non si sarebbe verificato. È facile perdere qualcosa di piccolo come una virgola. Se ricordi di inserire una virgola dopo ogni elemento dell'array, tale errore non può accadere. Non vorrai perdere quattro ore a eseguire il debug di qualcosa, finché non scoprirai che la virgola è la causa dei tuoi problemi .

Come molte altre cose, la virgola finale in un inizializzatore di array è una delle cose che C ++ ha ereditato da C (e dovrà supportare per sempre). Una visione totalmente diversa da quelle qui collocate è menzionata nel libro "Deep C secrets" .

Qui dopo un esempio con più di un "paradosso virgola":

char *available_resources[] = {
"color monitor"           ,
"big disk"                ,
"Cray"                      /* whoa! no comma! */
"on-line drawing routines",
"mouse"                   ,
"keyboard"                ,
"power cables"            , /* and what's this extra comma? */
};

noi leggiamo :

... quella virgola finale dopo l'inizializzatore finale non è un errore di battitura, ma un blip nella sintassi riportata dalla C aborigena . La sua presenza o assenza è consentita ma non ha significato . La giustificazione richiesta nella logica ANSI è che facilita la generazione automatizzata di C. L'affermazione sarebbe più credibile se le virgole finali fossero consentite in ogni elenco con virgola sepa , come nelle dichiarazioni enum o in più dichiaratori variabili in un'unica dichiarazione. Non sono.

... per me questo ha più senso

Oltre alla facilità di generazione e modifica del codice, se si desidera implementare un parser, questo tipo di grammatica è più semplice e più facile da implementare. C # segue questa regola in diversi punti in cui esiste un elenco di elementi separati da virgola, come gli elementi in una enumdefinizione.

Rende più semplice la generazione di codice in quanto è necessario solo aggiungere una riga e non è necessario trattare l'aggiunta dell'ultima voce come se fosse un caso speciale. Ciò è particolarmente vero quando si utilizzano le macro per generare codice. C'è una spinta a cercare di eliminare la necessità di macro dalla lingua, ma gran parte della lingua si è evoluta di pari passo con la disponibilità delle macro. La virgola aggiuntiva consente di definire e utilizzare macro come le seguenti:

#define LIST_BEGIN int a[] = {
#define LIST_ENTRY(x) x,
#define LIST_END };

Uso:

LIST_BEGIN
   LIST_ENTRY(1)
   LIST_ENTRY(2)
LIST_END

Questo è un esempio molto semplificato, ma spesso questo modello viene utilizzato dalle macro per definire elementi come mappe e tabelle di invio, messaggio, evento o traduzione. Se alla fine non fosse consentita una virgola, avremmo bisogno di uno speciale:

#define LIST_LAST_ENTRY(x) x

e sarebbe molto imbarazzante da usare.

In modo che quando due persone aggiungono un nuovo elemento in un elenco su rami separati, Git può unire correttamente le modifiche, perché Git funziona su una linea.

Se si utilizza un array senza lunghezza specificata, VC ++ 6.0 può identificarne automaticamente la lunghezza, quindi se si utilizza "int a [] = {1,2,};" la lunghezza di a è 3, ma l'ultima non ha ' t inizializzato, puoi usare "cout <