int a [] = {1,2,}; Seltsames Komma erlaubt. Irgend ein bestimmter Grund?

Vielleicht bin ich nicht von diesem Planeten, aber es scheint mir, dass das Folgende ein Syntaxfehler sein sollte:

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

Aber es ist nicht. Ich war überrascht, als dieser Code in Visual Studio kompiliert wurde, aber ich habe gelernt, dem MSVC-Compiler in Bezug auf C ++ - Regeln nicht zu vertrauen. Deshalb habe ich den Standard überprüft und er ist auch nach dem Standard zulässig. Sie können 8.5.1 für die Grammatikregeln sehen, wenn Sie mir nicht glauben.

Warum ist das erlaubt? Dies mag eine dumme, nutzlose Frage sein, aber ich möchte, dass Sie verstehen, warum ich frage. Wenn es ein Unterfall einer allgemeinen Grammatikregel wäre, würde ich verstehen - sie haben beschlossen, die allgemeine Grammatik nicht schwieriger zu machen, nur um ein redundantes Komma am Ende einer Initialisiererliste zu verbieten. Aber nein, das zusätzliche Komma ist ausdrücklich erlaubt. Beispielsweise darf am Ende einer Funktionsaufruf-Argumentliste (wenn die Funktion ausgeführt wird ...) kein redundantes Komma stehen , was normal ist .

Gibt es also wieder einen bestimmten Grund, warum dieses redundante Komma ausdrücklich zulässig ist?

Es erleichtert das Generieren von Quellcode und das Schreiben von Code, der zu einem späteren Zeitpunkt problemlos erweitert werden kann. Überlegen Sie, was erforderlich ist, um einen zusätzlichen Eintrag hinzuzufügen:

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

... müssen Sie das Komma zur vorhandenen Zeile hinzufügen und eine neue Zeile hinzufügen. Vergleichen Sie das mit dem Fall, in dem die drei bereits ein Komma hinter sich haben und Sie nur eine Zeile hinzufügen müssen. Wenn Sie eine Zeile entfernen möchten, können Sie dies auch tun, ohne sich Gedanken darüber zu machen, ob es sich um die letzte Zeile handelt oder nicht, und Sie können Zeilen neu anordnen, ohne mit Kommas herumzuspielen. Grundsätzlich bedeutet dies, dass die Behandlung der Linien einheitlich ist.

Denken Sie jetzt daran, Code zu generieren. So etwas wie (Pseudocode):

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

Sie müssen sich keine Sorgen machen, ob der aktuelle Artikel, den Sie schreiben, der erste oder der letzte ist. Viel einfacher.

Es ist nützlich, wenn Sie so etwas tun:

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

Benutzerfreundlichkeit für den Entwickler, würde ich denken.

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

Wenn Sie aus irgendeinem Grund ein Tool hatten, das Code für Sie generiert hat; Das Tool muss sich nicht darum kümmern, ob es das letzte Element in der Initialisierung ist oder nicht.

Ich habe immer angenommen, dass es einfacher ist, zusätzliche Elemente anzuhängen:

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

wird einfach:

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

zu einem späteren Zeitpunkt.

Alles, was alle über das einfache Hinzufügen / Entfernen / Generieren von Zeilen sagen, ist korrekt, aber der eigentliche Ort, an dem diese Syntax leuchtet, ist das Zusammenführen von Quelldateien. Stellen Sie sich vor, Sie haben dieses Array:

int ints[] = {
    3,
    9
};

Angenommen, Sie haben diesen Code in ein Repository eingecheckt.

Dann bearbeitet Ihr Kumpel es und fügt am Ende hinzu:

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

Und Sie bearbeiten es gleichzeitig und fügen am Anfang hinzu:

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

Semantisch sollten diese Arten von Vorgängen (Hinzufügen am Anfang, Hinzufügen am Ende) vollständig zusammenführungssicher sein und Ihre Versionierungssoftware (hoffentlich git) sollte in der Lage sein, automatisiert zu werden. Leider ist dies nicht der Fall, da Ihre Version nach der 9 kein Komma hat und Ihr Freund dies tut. Wenn die ursprüngliche Version die nachfolgende 9 hätte, wären sie automatisch zusammengeführt worden.

Meine Faustregel lautet also: Verwenden Sie das nachfolgende Komma, wenn die Liste mehrere Zeilen umfasst. Verwenden Sie es nicht, wenn sich die Liste in einer einzelnen Zeile befindet.

Nachfolgendes Komma ist meines Erachtens aus Gründen der Abwärtskompatibilität zulässig. Es gibt viel vorhandenen Code, der hauptsächlich automatisch generiert wird und ein nachfolgendes Komma enthält. Es erleichtert das Schreiben einer Schleife ohne besondere Bedingung am Ende. z.B

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

Für den Programmierer gibt es keinen wirklichen Vorteil.

PS Obwohl es einfacher ist, den Code auf diese Weise automatisch zu generieren, habe ich eigentlich immer darauf geachtet, das nachfolgende Komma nicht zu setzen. Der Aufwand ist minimal, die Lesbarkeit wird verbessert, und das ist wichtiger. Sie schreiben Code einmal, Sie lesen ihn oft.

Einer der Gründe, warum dies meines Wissens zulässig ist, ist, dass es einfach sein sollte, automatisch Code zu generieren. Für das letzte Element benötigen Sie keine spezielle Behandlung.

Dies erleichtert Codegeneratoren, die Arrays oder Aufzählungen ausspucken.

Vorstellen:

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

Das heißt, es ist nicht erforderlich, das erste oder letzte Element speziell zu behandeln, um ein spuckendes Komma zu vermeiden.

Wenn der Codegenerator beispielsweise in Python geschrieben ist, können Sie das folgende Komma leicht vermeiden, indem Sie die folgenden str.join()Funktionen verwenden:

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

Ich bin überrascht, dass nach all dieser Zeit niemand das Annotated C ++ Reference Manual ( ARM ) zitiert hat. Es sagt Folgendes über [dcl.init] mit Schwerpunkt auf meinem:

Es gibt eindeutig zu viele Notationen für Initialisierungen, aber jede scheint einem bestimmten Verwendungsstil gut zu dienen. Die Notation = {initializer_list, opt} wurde von C geerbt und dient gut zur Initialisierung von Datenstrukturen und Arrays. [...]

Obwohl sich die Grammatik seit dem Schreiben von ARM weiterentwickelt hat , bleibt der Ursprung erhalten.

und wir können zur C99-Begründung gehen, um zu sehen, warum dies in C erlaubt war und es heißt:

K & R erlaubt ein nachfolgendes Komma in einem Initialisierer am Ende einer Initialisiererliste. Der Standard hat diese Syntax beibehalten, da er Flexibilität beim Hinzufügen oder Löschen von Elementen zu einer Initialisierungsliste bietet und die maschinelle Generierung solcher Listen vereinfacht.

Ich sehe einen Anwendungsfall, der in anderen Antworten nicht erwähnt wurde, unsere Lieblingsmakros:

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

Das Hinzufügen von Makros zum letzten Mal ,wäre ein großer Schmerz. Mit dieser kleinen Änderung der Syntax ist dies trivial zu verwalten. Und dies ist wichtiger als maschinengenerierter Code, da dies in der vollständigen Sprache von Turing normalerweise viel einfacher ist als ein sehr begrenzter Präprozessor.

Die einzige Sprache, in der es - in der Praxis * - nicht erlaubt ist, ist Javascript, und es verursacht unzählige Probleme. Wenn Sie beispielsweise eine Zeile aus der Mitte des Arrays kopieren und einfügen, am Ende einfügen und vergessen haben, das Komma zu entfernen, ist Ihre Site für Ihre IE-Besucher völlig fehlerhaft.

* Theoretisch ist dies zulässig, aber der Internet Explorer folgt nicht dem Standard und behandelt ihn als Fehler

Es ist einfacher für Maschinen, dh das Parsen und Generieren von Code. Es ist auch einfacher für den Menschen, dh Modifikation, Auskommentieren und visuelle Eleganz durch Konsistenz.

Angenommen, C, würden Sie Folgendes schreiben?

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

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

    return EXIT_SUCCESS
}

Nein, nicht nur, weil die endgültige Aussage ein Fehler ist, sondern auch, weil sie inkonsistent ist. Warum also das Gleiche mit Sammlungen tun? Selbst in Sprachen, in denen Sie die letzten Semikolons und Kommas weglassen können, mag es die Community normalerweise nicht. Die Perl-Community zum Beispiel scheint es nicht zu mögen, Semikolons wegzulassen, außer Einzeiler. Sie wenden das auch auf Kommas an.

Lassen Sie Kommas in mehrzeiligen Sammlungen nicht aus demselben Grund weg, aus dem Sie keine Semikolons für mehrzeilige Codeblöcke auslassen. Ich meine, du würdest es nicht tun, selbst wenn die Sprache es zulässt, oder? Recht?

Der Grund ist trivial: Einfaches Hinzufügen / Entfernen von Zeilen.

Stellen Sie sich den folgenden Code vor:

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

Jetzt können Sie der Liste problemlos Elemente hinzufügen / entfernen, ohne manchmal das nachfolgende Komma hinzufügen / entfernen zu müssen.

Im Gegensatz zu anderen Antworten denke ich nicht, dass die einfache Erstellung der Liste ein triftiger Grund ist: Schließlich ist es für den Code trivial, die letzte (oder erste) Zeile als Sonderfall zu verwenden. Codegeneratoren werden einmal geschrieben und oft verwendet.

Es ermöglicht jeder Zeile, der gleichen Form zu folgen. Erstens erleichtert dies das Hinzufügen neuer Zeilen und lässt ein Versionskontrollsystem die Änderung sinnvoll verfolgen, und ermöglicht es Ihnen, den Code einfacher zu analysieren. Ich kann mir keinen technischen Grund vorstellen.

Dies ist vor Fehlern geschützt, die durch das Verschieben von Elementen in einer langen Liste verursacht werden.

Nehmen wir zum Beispiel an, wir haben einen Code, der so aussieht.

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

Und es ist großartig, da es die ursprüngliche Trilogie der Stack Exchange-Sites zeigt.

Stack Overflow
Super User
Server Fault

Aber es gibt ein Problem damit. Sie sehen, die Fußzeile auf dieser Website zeigt Serverfehler vor Superuser. Beheben Sie das besser, bevor es jemand bemerkt.

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

Das Bewegen von Linien könnte doch nicht so schwer sein, oder?

Stack Overflow
Server FaultSuper User

Ich weiß, es gibt keine Website namens "Server FaultSuper User", aber unser Compiler behauptet, dass sie existiert. Das Problem ist nun, dass C über eine Funktion zur Verkettung von Zeichenfolgen verfügt, mit der Sie zwei Zeichenfolgen in doppelten Anführungszeichen schreiben und sie mit nichts verketten können (ein ähnliches Problem kann auch bei Ganzzahlen auftreten, z- Vorzeichen mehrere Bedeutungen hat).

Was wäre, wenn das ursprüngliche Array am Ende ein nutzloses Komma hätte? Nun, die Linien würden verschoben, aber ein solcher Fehler wäre nicht aufgetreten. Es ist leicht, etwas so Kleines wie ein Komma zu übersehen. Wenn Sie daran denken, nach jedem Array-Element ein Komma zu setzen, kann ein solcher Fehler einfach nicht auftreten. Sie möchten nicht vier Stunden damit verschwenden, etwas zu debuggen, bis Sie feststellen, dass das Komma die Ursache für Ihre Probleme ist .

Wie viele andere Dinge ist das nachfolgende Komma in einem Array-Initialisierer eines der Dinge, die C ++ von C geerbt hat (und für immer unterstützen muss). Eine völlig andere Ansicht als die hier platzierte wird im Buch "Deep C Secrets" erwähnt. .

Darin nach einem Beispiel mit mehr als einem "Komma-Paradoxon":

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? */
};

wir lesen :

... dass das nachfolgende Komma nach dem endgültigen Initialisierer kein Tippfehler ist, sondern ein Fehler in der Syntax, der von Aboriginal C übernommen wurde . Seine Anwesenheit oder Abwesenheit ist erlaubt, hat aber keine Bedeutung . Die in der ANSI C-Begründung geltend gemachte Rechtfertigung besteht darin, dass dies die automatisierte Erzeugung von C erleichtert. Die Behauptung wäre glaubwürdiger, wenn in jeder durch Kommas getrennten Liste nachgestellte Kommas zulässig wären , z. B. in Aufzählungsdeklarationen oder in mehreren Deklaratoren mit mehreren Variablen in einer einzigen Deklaration. Sie sind nicht.

... für mich macht das mehr Sinn

Wenn Sie einen Parser implementieren möchten, ist diese Art der Grammatik nicht nur einfacher zu generieren und zu bearbeiten, sondern auch einfacher und einfacher zu implementieren. C # folgt dieser Regel an mehreren Stellen, dass es eine Liste von durch Kommas getrennten Elementen gibt, wie z. B. Elemente in einer enumDefinition.

Dies erleichtert das Generieren von Code, da Sie nur eine Zeile hinzufügen müssen und das Hinzufügen des letzten Eintrags nicht so behandeln müssen, als wäre es ein Sonderfall. Dies gilt insbesondere dann, wenn Makros zum Generieren von Code verwendet werden. Es wird versucht zu versuchen, die Notwendigkeit von Makros aus der Sprache zu entfernen, aber ein Großteil der Sprache hat sich Hand in Hand mit der Verfügbarkeit von Makros entwickelt. Mit dem zusätzlichen Komma können Makros wie die folgenden definiert und verwendet werden:

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

Verwendungszweck:

LIST_BEGIN
   LIST_ENTRY(1)
   LIST_ENTRY(2)
LIST_END

Das ist ein sehr vereinfachtes Beispiel, aber häufig wird dieses Muster von Makros verwendet, um Dinge wie Versand-, Nachrichten-, Ereignis- oder Übersetzungskarten und -tabellen zu definieren. Wenn am Ende kein Komma erlaubt wäre, bräuchten wir ein spezielles:

#define LIST_LAST_ENTRY(x) x

und das wäre sehr umständlich zu bedienen.

Wenn zwei Personen ein neues Element in einer Liste in separaten Zweigen hinzufügen, kann Git die Änderungen ordnungsgemäß zusammenführen, da Git zeilenweise arbeitet.

Wenn Sie ein Array ohne angegebene Länge verwenden, kann VC ++ 6.0 seine Länge automatisch identifizieren. Wenn Sie also "int a [] = {1,2,};" verwenden, beträgt die Länge von a 3, die letzte jedoch nicht. Wenn Sie nicht initialisiert wurden, können Sie "cout <" verwenden