int a [] = {1,2,}; Dấu phẩy lạ cho phép. Bất kỳ lý do cụ thể nào?

Có thể tôi không đến từ hành tinh này, nhưng dường như sau đây tôi sẽ bị lỗi cú pháp:

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

Nhưng nó không phải là. Tôi đã rất ngạc nhiên khi mã này được biên dịch trên Visual Studio, nhưng tôi đã học được cách không tin tưởng trình biên dịch MSVC khi có liên quan đến các quy tắc C ++, vì vậy tôi đã kiểm tra tiêu chuẩn và nó cũng được cho phép theo tiêu chuẩn. Bạn có thể xem 8.5.1 cho các quy tắc ngữ pháp nếu bạn không tin tôi.

Tại sao điều này được cho phép? Đây có thể là một câu hỏi vô dụng ngu ngốc nhưng tôi muốn bạn hiểu lý do tại sao tôi hỏi. Nếu đó là một trường hợp phụ của quy tắc ngữ pháp chung, tôi sẽ hiểu - họ quyết định không làm cho ngữ pháp chung trở nên khó khăn hơn chỉ để không cho phép một dấu phẩy thừa ở cuối danh sách khởi tạo. Nhưng không, dấu phẩy bổ sung được cho phép rõ ràng . Ví dụ: không được phép có dấu phẩy thừa ở cuối danh sách đối số gọi hàm (khi hàm thực hiện ...), điều này là bình thường .

Vì vậy, một lần nữa, có bất kỳ lý do cụ thể nào dấu phẩy thừa này được cho phép rõ ràng ?

Nó giúp việc tạo mã nguồn dễ dàng hơn và cũng có thể viết mã có thể dễ dàng gia hạn vào một ngày sau đó. Xem xét những gì cần thiết để thêm một mục bổ sung vào:

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

... bạn phải thêm dấu phẩy vào dòng hiện có và thêm một dòng mới. So sánh với trường hợp cả ba đã có dấu phẩy sau nó, trong đó bạn chỉ cần thêm một dòng. Tương tự như vậy, nếu bạn muốn xóa một dòng, bạn có thể làm như vậy mà không cần lo lắng về việc đó có phải là dòng cuối cùng hay không và bạn có thể sắp xếp lại các dòng mà không phải loay hoay với dấu phẩy. Về cơ bản, điều đó có nghĩa là có sự đồng nhất trong cách bạn đối xử với các dòng.

Bây giờ hãy nghĩ về việc tạo mã. Một cái gì đó như (mã giả):

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

Không cần phải lo lắng về việc mục hiện tại bạn viết ra là đầu tiên hay cuối cùng. Đơn giản hơn nhiều.

Thật hữu ích nếu bạn làm một cái gì đó như thế này:

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

Dễ sử dụng cho các nhà phát triển, tôi sẽ nghĩ.

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

Ngoài ra, nếu vì bất kỳ lý do gì bạn có một công cụ tạo mã cho bạn; công cụ không phải quan tâm đến việc đó có phải là mục cuối cùng trong quá trình khởi tạo hay không.

Tôi luôn cho rằng việc gắn các yếu tố phụ dễ dàng hơn:

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

đơn giản trở thành:

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

vào một ngày sau đó

Mọi thứ mọi người đều nói về việc dễ dàng thêm / xóa / tạo dòng là chính xác, nhưng vị trí thực sự của cú pháp này là khi hợp nhất các tệp nguồn với nhau. Hãy tưởng tượng bạn đã có mảng này:

int ints[] = {
    3,
    9
};

Và giả sử bạn đã kiểm tra mã này vào một kho lưu trữ.

Sau đó, bạn của bạn chỉnh sửa nó, thêm vào cuối:

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

Và bạn đồng thời chỉnh sửa nó, thêm vào đầu:

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

Về mặt ngữ nghĩa các loại hoạt động này (thêm vào đầu, thêm vào cuối) nên hoàn toàn hợp nhất an toàn và phần mềm phiên bản của bạn (hy vọng git) sẽ có thể tự động hóa. Đáng buồn thay, đây không phải là trường hợp vì phiên bản của bạn không có dấu phẩy sau số 9 và bạn của bạn cũng vậy. Trong khi đó, nếu phiên bản gốc có 9 dấu, chúng sẽ tự động hóa.

Vì vậy, quy tắc ngón tay cái của tôi là: sử dụng dấu phẩy nếu danh sách kéo dài nhiều dòng, không sử dụng nó nếu danh sách nằm trên một dòng.

Dấu phẩy tôi tin là được phép vì lý do tương thích ngược. Có rất nhiều mã hiện có, chủ yếu được tạo tự động, đặt dấu phẩy. Nó làm cho nó dễ dàng hơn để viết một vòng lặp mà không có điều kiện đặc biệt ở cuối. ví dụ

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

Thực sự không có bất kỳ lợi thế nào cho lập trình viên.

PS Mặc dù việc tự động mã hóa theo cách này dễ dàng hơn, tôi thực sự luôn chú ý không đặt dấu phẩy, các nỗ lực là tối thiểu, khả năng đọc được cải thiện và điều đó quan trọng hơn. Bạn viết mã một lần, bạn đọc nó nhiều lần.

Một trong những lý do điều này được cho phép theo như tôi biết là nó đơn giản để tự động tạo mã; bạn không cần bất kỳ xử lý đặc biệt nào cho phần tử cuối cùng.

Nó làm cho các trình tạo mã phun ra các mảng hoặc liệt kê dễ dàng hơn.

Hãy tưởng tượng:

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

Tức là, không cần phải xử lý đặc biệt của mục đầu tiên hoặc cuối cùng để tránh nhổ dấu phẩy.

Ví dụ, nếu trình tạo mã được viết bằng Python, thì có thể dễ dàng tránh việc tạo dấu phẩy bằng cách sử dụng str.join()hàm:

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

Tôi ngạc nhiên sau tất cả thời gian này, không ai trích dẫn Tài liệu tham khảo C ++ được chú thích ( ARM ), nó nói như sau về [dcl.init] với phần nhấn mạnh của tôi:

Rõ ràng có quá nhiều ký hiệu cho việc khởi tạo, nhưng mỗi ký hiệu dường như phục vụ tốt một phong cách sử dụng cụ thể. Ký hiệu = {initizer_list, opt} được kế thừa từ C và phục vụ tốt cho việc khởi tạo cấu trúc dữ liệu và mảng. [...]

mặc dù ngữ pháp đã phát triển kể từ khi ARM được viết, nguồn gốc vẫn còn.

và chúng ta có thể đi đến lý do C99 để xem tại sao điều này được cho phép trong C và nó nói:

K & R cho phép dấu phẩy trong bộ khởi tạo ở cuối danh sách khởi tạo. Tiêu chuẩn đã giữ lại cú pháp này, vì nó cung cấp sự linh hoạt trong việc thêm hoặc xóa các thành viên khỏi danh sách khởi tạo và đơn giản hóa việc tạo ra các danh sách đó.

Tôi thấy một trường hợp sử dụng không được đề cập trong các câu trả lời khác, Macros yêu thích của chúng tôi:

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

Thêm macro để xử lý cuối cùng ,sẽ là nỗi đau lớn. Với sự thay đổi nhỏ trong cú pháp này, đây là chuyện nhỏ để quản lý. Và điều này quan trọng hơn mã do máy tạo ra bởi vì thường rất dễ thực hiện trong Turing langue hoàn chỉnh hơn so với preprocesor rất hạn chế.

Ngôn ngữ duy nhất mà nó - trong thực tế * - không được phép là Javascript và nó gây ra vô số vấn đề. Ví dụ: nếu bạn sao chép và dán một dòng từ giữa mảng, dán nó ở cuối và quên xóa dấu phẩy thì trang web của bạn sẽ bị hỏng hoàn toàn cho khách truy cập IE của bạn.

* Về lý thuyết thì được phép nhưng Internet Explorer không tuân theo tiêu chuẩn và coi đó là lỗi

Nó dễ dàng hơn cho các máy, tức là phân tích cú pháp và tạo mã. Nó cũng dễ dàng hơn cho con người, tức là sửa đổi, bình luận và thanh lịch bằng hình ảnh thông qua tính nhất quán.

Giả sử C, bạn sẽ viết như sau?

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

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

    return EXIT_SUCCESS
}

Không. Không chỉ bởi vì tuyên bố cuối cùng là một lỗi, mà còn bởi vì nó không nhất quán. Vậy tại sao làm tương tự với các bộ sưu tập? Ngay cả trong các ngôn ngữ cho phép bạn bỏ qua dấu chấm phẩy và dấu phẩy cuối cùng, cộng đồng thường không thích nó. Ví dụ, cộng đồng Perl dường như không thích bỏ dấu chấm phẩy, thanh một lớp. Họ áp dụng điều đó cho dấu phẩy quá.

Đừng bỏ qua dấu phẩy trong các bộ sưu tập nhiều dòng vì cùng một lý do bạn không sử dụng dấu chấm phẩy cho các khối mã đa dòng. Ý tôi là, bạn sẽ không làm điều đó ngay cả khi ngôn ngữ cho phép, phải không? Đúng?

Lý do là tầm thường: dễ dàng thêm / xóa dòng.

Hãy tưởng tượng đoạn mã sau:

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

Giờ đây, đôi khi bạn có thể dễ dàng thêm / xóa các mục vào danh sách mà không cần phải thêm / xóa dấu phẩy.

Ngược lại với các câu trả lời khác, tôi thực sự không nghĩ rằng việc dễ dàng tạo danh sách là một lý do hợp lệ: xét cho cùng, việc đặt mã cho trường hợp đặc biệt là dòng cuối cùng (hoặc đầu tiên) là chuyện nhỏ. Trình tạo mã được viết một lần và sử dụng nhiều lần.

Nó cho phép mọi dòng theo cùng một hình thức. Thứ nhất, điều này giúp dễ dàng thêm các hàng mới và có hệ thống kiểm soát phiên bản theo dõi sự thay đổi một cách có ý nghĩa và nó cũng cho phép bạn phân tích mã dễ dàng hơn. Tôi không thể nghĩ ra một lý do kỹ thuật.

Điều này được phép bảo vệ khỏi những sai lầm gây ra bởi các yếu tố di chuyển xung quanh trong một danh sách dài.

Ví dụ: giả sử chúng ta có một mã trông như thế này.

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

Và thật tuyệt vời, vì nó cho thấy bộ ba trang web Stack Exchange ban đầu.

Stack Overflow
Super User
Server Fault

Nhưng có một vấn đề với nó. Bạn thấy, phần chân trang trên trang web này hiển thị Lỗi máy chủ trước Siêu người dùng. Sửa chữa tốt hơn trước khi bất cứ ai thông báo.

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

Rốt cuộc, việc di chuyển xung quanh không thể khó đến thế, phải không?

Stack Overflow
Server FaultSuper User

Tôi biết, không có trang web nào gọi là "Máy chủ FaultSuper", nhưng trình biên dịch của chúng tôi tuyên bố nó tồn tại. Bây giờ, vấn đề là C có tính năng nối chuỗi, cho phép bạn viết hai chuỗi trích dẫn kép và nối chúng không sử dụng gì (vấn đề tương tự cũng có thể xảy ra với số nguyên, vì -dấu có nhiều nghĩa).

Bây giờ nếu mảng ban đầu có dấu phẩy vô dụng thì sao? Chà, các dòng sẽ được di chuyển xung quanh, nhưng lỗi như vậy sẽ không xảy ra. Thật dễ dàng để bỏ lỡ một cái gì đó nhỏ như dấu phẩy. Nếu bạn nhớ đặt dấu phẩy sau mỗi phần tử mảng, lỗi đó không thể xảy ra. Bạn sẽ không muốn lãng phí bốn giờ để gỡ lỗi một cái gì đó, cho đến khi bạn thấy dấu phẩy là nguyên nhân gây ra vấn đề của bạn .

Giống như nhiều thứ khác, dấu phẩy trong bộ khởi tạo mảng là một trong những thứ C ++ được thừa hưởng từ C (và sẽ phải hỗ trợ mãi mãi). Một quan điểm hoàn toàn khác với những quan điểm được đặt ở đây được đề cập trong cuốn sách "Bí mật Deep C" .

Trong một ví dụ có nhiều hơn một "nghịch lý dấu phẩy":

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

chúng tôi đọc :

... mà dấu dấu phẩy sau initializer thức không phải là một lỗi đánh máy, nhưng là một đốm sáng trong cú pháp chuyển sang từ thổ dân C . Sự hiện diện hay vắng mặt của nó được cho phép nhưng không có ý nghĩa . Sự biện minh được tuyên bố trong lý do ANSI C là nó làm cho việc tạo C tự động dễ dàng hơn. Khiếu nại sẽ đáng tin cậy hơn nếu dấu phẩy được cho phép trong mọi danh sách được xếp hạng bằng dấu phẩy , chẳng hạn như trong khai báo enum hoặc nhiều khai báo biến trong một khai báo. Họ không phải.

... với tôi điều này có ý nghĩa hơn

Ngoài việc tạo mã và chỉnh sửa dễ dàng, nếu bạn muốn triển khai trình phân tích cú pháp, loại ngữ pháp này đơn giản và dễ thực hiện hơn. C # tuân theo quy tắc này ở một số nơi có danh sách các mục được phân tách bằng dấu phẩy, như các mục trong enumđịnh nghĩa.

Nó giúp việc tạo mã dễ dàng hơn khi bạn chỉ cần thêm một dòng và không cần xử lý thêm mục cuối như thể đó là trường hợp đặc biệt. Điều này đặc biệt đúng khi sử dụng macro để tạo mã. Có một nỗ lực để cố gắng loại bỏ sự cần thiết của macro từ ngôn ngữ, nhưng rất nhiều ngôn ngữ đã phát triển cùng với các macro có sẵn. Dấu phẩy thừa cho phép các macro như sau được xác định và sử dụng:

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

Sử dụng:

LIST_BEGIN
   LIST_ENTRY(1)
   LIST_ENTRY(2)
LIST_END

Đó là một ví dụ rất đơn giản, nhưng thường mẫu này được các macro sử dụng để xác định những thứ như công văn, thông báo, sự kiện hoặc bản đồ dịch và bảng. Nếu dấu phẩy không được phép ở cuối, chúng ta sẽ cần một đặc biệt:

#define LIST_LAST_ENTRY(x) x

và điều đó sẽ rất khó sử dụng.

Vì vậy, khi hai người thêm một mục mới vào danh sách trên các nhánh riêng biệt, Git có thể hợp nhất các thay đổi, vì Git hoạt động trên cơ sở dòng.

Nếu bạn sử dụng một mảng không có độ dài được chỉ định, VC ++ 6.0 có thể tự động xác định độ dài của nó, vì vậy nếu bạn sử dụng "int a [] = {1,2,};" thì độ dài của a là 3, nhưng chiều dài cuối cùng là ' Được khởi tạo, bạn có thể sử dụng "cout <