int a[] = {1,2,};为什么允许在初始化列表中使用尾随逗号？

Question

也许我不是来自这个星球，但在我看来，以下内容应该是语法错误：

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

但事实并非如此。当这段代码在 Visual Studio 上编译时，我感到很惊讶，但就 C++ 规则而言，我已经学会了不要信任 MSVC 编译器，所以我检查了标准，它是也是标准所允许的。不信的话你可以看8.5.1的语法规则。

为什么允许这样做？这可能是一个愚蠢无用的问题，但我希望你明白我为什么问。如果这是一般语法规则的子情况，我会理解 - 他们决定不让一般语法变得更加困难，只是不允许在初始化列表末尾使用多余的逗号。但不可以，额外的逗号是明确允许的。例如，不允许在函数调用参数列表末尾有多余的逗号（当函数采用 ... 时），这是正常的 。

那么，再次强调，是否有任何特殊原因明确允许使用这种多余的逗号？

Answer 1

我看到其他答案中未提及的一个用例，
我们最喜欢的宏：

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

添加宏来处理最后一个 , 会很痛苦。通过语法上的这个小变化，管理起来就很简单了。这比机器生成的代码更重要，因为通常用图灵完整语言比非常有限的预处理器更容易做到这一点。

Answer 2

据我所知，允许这样做的原因之一是自动生成代码应该很简单；您不需要对最后一个元素进行任何特殊处理。

Answer 3

它使生成数组或枚举的代码生成器变得更容易。

想象一下：

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

即，不需要对第一个或最后一个项目进行特殊处理以避免吐出尾随逗号。

例如，如果代码生成器是用 Python 编写的，则可以使用 str.join() 函数轻松避免吐出尾随逗号：

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

Answer 4

原因很简单：易于添加/删除行。

想象一下以下代码：

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

现在，您可以轻松地向列表添加/删除项目，而无需有时添加/删除尾随逗号。

与其他答案相比，我真的不认为生成列表的容易性是一个有效的理由：毕竟，代码对最后一行（或第一行）进行特殊处理是微不足道的。代码生成器编写一次并使用多次。

Answer 5

它允许每一行遵循相同的形式。首先，这使得添加新行变得更容易，并使版本控制系统有意义地跟踪更改，并且还允许您更轻松地分析代码。我想不出技术原因。

Answer 6

在实践中*，唯一不允许的语言是 Javascript，它会导致无数的问题。例如，如果您复制 &从数组中间粘贴一行，将其粘贴到末尾，然后忘记删除逗号，那么对于 IE 访问者来说，您的网站将完全崩溃。

*理论上是允许的，但 Internet Explorer 不遵循标准并将其视为错误

Answer 7

对于机器来说，它更容易，即解析和生成代码。
对于人类来说也更容易，即通过一致性进行修改、注释和视觉优雅。

假设用C，你会写出以下内容吗？

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

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

    return EXIT_SUCCESS
}

不。不仅因为最后的语句是错误的，而且还因为它不一致。那么为什么要对集合做同样的事情呢？即使在允许省略最后一个分号和逗号的语言中，社区通常也不喜欢它。例如，Perl 社区似乎不喜欢省略分号和俏皮话。他们也将其应用于逗号。

不要在多行集合中省略逗号，其原因与在多行代码块中不省略分号的原因相同。我的意思是，即使语言允许，你也不会这样做，对吗？正确的？

Answer 8

这可以防止因在长列表中移动元素而导致的错误。

例如，假设我们有一个如下所示的代码。

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

它很棒，因为它展示了 Stack Exchange 站点的原始三部曲。

Stack Overflow
Super User
Server Fault

但它有一个问题。你看，这个网站的页脚在超级用户之前显示了服务器故障。最好在有人注意到之前解决这个问题。

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

毕竟，移动线路并没有那么困难，不是吗？

Stack Overflow
Server FaultSuper User

我知道，没有一个名为“Server FailureSuper User”的网站，但我们的编译器声称它存在。现在的问题是 C 具有字符串连接功能，它允许您编写两个双引号字符串并不使用任何东西连接它们（类似的问题也可能发生在整数上，因为 - 符号有多种含义） 。

现在，如果原始数组末尾有一个无用的逗号怎么办？好吧，线路会移动，但这样的错误就不会发生。很容易错过像逗号这样小的东西。如果您记得在每个数组元素后面加一个逗号，这样的错误就不会发生。您不想浪费四个小时调试某些内容，直到您发现逗号是问题的原因。

Answer 9

与许多事情一样，数组初始值设定项中的尾随逗号是 C++ 从 C 继承的内容之一（并且必须永远支持）。 与这里的观点完全不同的观点在“Deep C Secrets”一书中提到。

在一个包含多个“逗号悖论”的例子之后：

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

我们读到：

...最终初始化程序后面的逗号不是拼写错误，而是从原始 C 继承下来的语法中的一个问题。它的存在或不存在是允许的，但没有意义。 ANSI C 基本原理中声称的理由是它使 C 的自动生成变得更容易。 如果每个逗号分隔列表中都允许使用尾随逗号（例如在枚举声明中或单个声明中的多个变量声明符），则该声明会更可信。他们不是。

...对我来说这更有意义

Answer 10

除了代码生成和编辑容易之外，如果你想实现一个解析器，这种类型的语法更简单，更容易实现。 C# 在多个地方都遵循此规则，即有一个以逗号分隔的项目列表，例如 enum 定义中的项目。

Answer 11

它使生成代码变得更容易，因为您只需要添加一行，并且不需要将添加最后一个条目视为特殊情况。当使用宏生成代码时尤其如此。有人试图消除语言中对宏的需求，但许多语言确实随着宏的可用而不断发展。额外的逗号允许定义和使用如下宏：

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

用法：

LIST_BEGIN
   LIST_ENTRY(1)
   LIST_ENTRY(2)
LIST_END

这是一个非常简化的示例，但宏通常使用此模式来定义调度、消息、事件或转换映射和表等内容。如果末尾不允许使用逗号，我们就需要一个特殊的：

#define LIST_LAST_ENTRY(x) x

，这使用起来会很尴尬。

Answer 12

这样，当两个人在不同分支的列表中添加新项目时，Git 可以正确合并更改，因为 Git 是按行工作的。

Answer 13

它使编辑代码变得更加容易。
我将 editinc c/c++ 数组元素与编辑 json 文档进行比较 - 如果您忘记删除最后一个逗号，则 JSON 将无法解析。 （是的，我知道 JSON 不适合手动编辑）

Answer 14

此规则有用性的另一个很好的例子是与参数包一起使用，该参数包可能为空。演示：

template <int I, int... Is>    // at least one template argument is required...
struct Test {
  void test() {
    int arr[] = { I, Is... };  // ...because arrays of 0 length are not allowed
  }
};

如果不允许尾随逗号，则在参数包为空的情况下将无法编译，例如：

Test<1> t;  // results in 'int arr[] = { 1, };'
t.test();

现场演示： https://godbolt.org/z/c6fbY87Mr

Answer 15

它使得生成源代码变得更加容易，也使得编写可以在以后轻松扩展的代码变得更加容易。考虑添加额外条目需要什么：

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

... 您必须将逗号添加到现有行并添加新行。与这三个已经后面有逗号的情况相比，您只需添加一行即可。同样，如果您想删除一行，您可以这样做而不必担心它是否是最后一行，并且您可以对行重新排序而无需摆弄逗号。基本上，这意味着您对待线条的方式是一致的。

现在考虑生成代码。像（伪代码）这样​​的东西：

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

无需担心您正在写出的当前项目是第一个还是最后一个。简单多了。

Answer 16

如果你做这样的事情，它会很有用：

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

Answer 17

我认为开发人员易于使用。

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

此外，如果出于某种原因您有一个可以为您生成代码的工具；该工具不必关心它是否是初始化中的最后一项。

Answer 18

我一直认为它可以更容易地附加额外的元素：

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

简单地变成：

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

在以后的日期。

Answer 19

我很惊讶，这么长时间以来都没有人引用带注释的 C++ 参考手册（ARM ），它说了以下关于[dcl.init]的内容，重点是我的：

显然有太多的初始化符号，但每种符号似乎都能很好地服务于特定的使用风格。 ={initializer_list,opt} 表示法继承自 C，非常适合数据结构和数组的初始化。 [...]

尽管自 ARM 编写以来语法已经发生了演变，但其起源仍然存在。

我们可以转到 C99 基本原理看看为什么这在 C 中是允许的，它说：

K&R 允许在初始化程序末尾使用尾随逗号
初始化列表。标准保留了这种语法，因为它
提供从初始值设定项添加或删除成员的灵活性
列表，并简化此类列表的机器生成。

Answer 20

每个人所说的关于添加/删除/生成行的简便性的一切都是正确的，但这种语法的真正亮点是在将源文件合并在一起时。想象一下您有这个数组：

int ints[] = {
    3,
    9
};

并假设您已将此代码签入存储库。

然后你的好友编辑它，添加到结尾：

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

你同时编辑它，添加到开头：

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

从语义上讲，这些类型的操作（添加到开头，添加到结尾）应该是完全合并安全的，并且你的版本控制软件（希望是 git ）应该能够自动合并。遗憾的是，情况并非如此，因为您的版本在 9 之后没有逗号，而您的好友则有。然而，如果原始版本有尾随 9，它们就会自动合并。

所以，我的经验法则是：如果列表跨越多行，则使用尾随逗号；如果列表位于单行，则不要使用它。

Answer 21

我认为出于向后兼容性的原因允许使用尾随逗号。有很多现有代码（主要是自动生成的）会在末尾添加逗号。它使得在最后没有特殊条件的情况下编写循环变得更容易。
例如，

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

对于程序员来说实际上没有任何优势。

PS 虽然这种方式自动生成代码更容易，但实际上我总是注意不要放置尾随逗号，工作量很小，可读性得到提高，这是更重要的。您编写一次代码，然后多次阅读它。