int a [] = {1,2,}; Tuhaf virgül kullanılmasına izin verildi. Belirli bir nedeni var mı?

Belki ben bu gezegenden değilim, ama bana öyle geliyor ki bir sözdizimi hatası olmalı:

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

Ama değil. Bu kod Visual Studio üzerinde derlenmiş zaman şaşırdı, ama ben standardını kontrol ve uzak C ++ kurallar söz konusu olduğunda, bu nedenle MSVC derleyici güvenmemeyi öğrendim olduğu standardı tarafından izin de. Bana inanmıyorsanız dilbilgisi kuralları için 8.5.1'i görebilirsiniz.

Buna neden izin veriliyor? Bu aptalca bir işe yaramaz soru olabilir ama neden sorduğumu anlamanızı istiyorum. Genel bir dilbilgisi kuralının alt vakası olsaydı, anladım - genel dilbilgisini, bir başlangıç ​​listesinin sonunda gereksiz bir virgüle izin vermemek için daha zor hale getirmeye karar verdiler. Ancak hayır, ek virgüle açıkça izin verilir. Örneğin, (işlevi alan bir fonksiyon çağrısı bağımsız değişken listesinin sonuna fazladan bir virgül izin verilmez ...), normal .

Peki, yine, bu gereksiz virgülün açıkça izin verilmesinin belirli bir nedeni var mı?

Kaynak kodu oluşturmayı ve daha sonraki bir tarihte kolayca genişletilebilen kod yazmayı kolaylaştırır. Ek bir giriş eklemek için nelerin gerekli olduğunu düşünün:

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

... Varolan hattına virgül eklemek zorunda ve yeni bir satır ekleyin. Bunu, üçünün zaten bir virgülün bulunduğu durumda , sadece bir satır eklemeniz gereken durumla karşılaştırın . Benzer şekilde, bir satırı kaldırmak isterseniz, son satır olup olmadığından endişe etmeden bunu yapabilirsiniz ve virgüllerle uğraşmadan satırları yeniden sıralayabilirsiniz. Temel olarak, çizgilere nasıl davrandığınız konusunda tekdüzelik olduğu anlamına gelir.

Şimdi kod oluşturmayı düşünün. Gibi bir şey (sözde kod):

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

Yazdığınız mevcut öğenin ilk veya son olup olmadığı konusunda endişelenmenize gerek yok. Çok daha basit.

Böyle bir şey yaparsanız yararlı olur:

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

Geliştirici için kullanım kolaylığı olduğunu düşünüyorum.

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

Ayrıca, herhangi bir nedenle sizin için kod üreten bir aracınız varsa; aracın başlangıçtaki son öğe olup olmadığına dikkat etmesi gerekmez.

Her zaman ekstra öğeler eklemeyi kolaylaştırdığını varsaydım:

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

basitçe olur:

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

daha sonraki bir tarihte.

Herkesin satır ekleme / çıkarma / oluşturma kolaylığı hakkında söylediği her şey doğrudur, ancak bu sözdiziminin parladığı gerçek yer, kaynak dosyaları bir araya getirirken. Bu diziye sahip olduğunuzu düşünün:

int ints[] = {
    3,
    9
};

Ve bu kodu bir havuzda kontrol ettiğinizi varsayalım.

Sonra arkadaşınız onu düzenler, sonuna ekler:

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

Ve başlangıca ekleyerek aynı anda düzenlersiniz:

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

Anlamsal olarak bu tür işlemler (başlangıca ekleme, sonuna ekleme) tamamen güvenli olmalı ve sürüm yazılımınız (umarım git) otomasyona geçebilmelidir. Ne yazık ki, durum böyle değil çünkü 9'unuzdan sonra sürümünüzde virgül yok ve arkadaşınız var. Oysa, orijinal versiyonda izleyen 9 varsa, otomatikleştirilirdi.

Yani, temel kuralım: Liste birden fazla satıra yayılıyorsa, virgül kullan, liste tek bir satırdaysa kullanmayın.

Sondaki virgül, geriye dönük uyumluluk nedeniyle izin verildiğine inanıyorum. Sonunda virgül koyan, öncelikle otomatik olarak oluşturulan birçok kod var. Sonunda özel koşul olmadan bir döngü yazmayı kolaylaştırır. Örneğin

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

Programcı için gerçekten bir avantaj yok.

PS Bu şekilde kodu otomatik olarak oluşturmak daha kolay olsa da, aslında her zaman sondaki virgül koymamaya dikkat ettim, çabalar asgari, okunabilirlik geliştirildi ve bu daha önemli. Kodu bir kez yazarsınız, birçok kez okursunuz.

Bildiğim kadarıyla bu izin verilen nedenlerden biri otomatik kod oluşturmak için basit olması gerektiğidir; son eleman için özel bir işleme ihtiyacınız yoktur.

Dizileri veya numaralandırmaları dışarı veren kod üreticilerini kolaylaştırır.

Hayal etmek:

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

Yani, sondaki virgülün tükürülmesini önlemek için ilk veya son öğenin özel bir şekilde işlenmesine gerek yoktur.

Örneğin, kod üreteci Python'da yazıldıysa, aşağıdaki virgül str.join()işlevini kullanarak tükürmeyi önlemek kolaydır :

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

Bunca zamandan sonra hiç kimse Açıklamalı C ++ Referans Kılavuzu'nu ( ARM ) alıntılamadı , vurgulu mayınla [dcl.init] hakkında aşağıdakileri söylüyor :

Başlatmalar için açıkça çok fazla gösterim var, ancak her biri belirli bir kullanım tarzına iyi hizmet ediyor gibi görünüyor. = {İnitializer_list, tercih} gösterimde C miras kalan ve veri yapıları ve dizilerin başlatma için de hizmet eder. [...]

Her ne kadar ARM yazıldığından beri dilbilgisi evrimleşmiş olsa da başlangıç ​​noktası kalmıştır.

ve C'de buna neden izin verildiğini görmek için C99 mantığına gidebiliriz ve şöyle diyor:

K&R, bir başlatıcı listesinin sonunda bir başlatıcıda sondaki virgüllere izin verir. Standart, bir başlangıç ​​listesi eklemek veya listeden üye silmek için esneklik sağladığı ve bu tür listelerin makine üretimini basitleştirdiği için bu sözdizimini korumuştur .

Diğer cevaplarda belirtilmeyen bir kullanım durumu görüyorum, favori Makrolarımız:

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

Son işlemek için makrolar eklemek ,büyük acı olur. Sözdizimindeki bu küçük değişiklikle, bu yönetilmesi önemsizdir. Ve bu, makine tarafından üretilen koddan daha önemlidir, çünkü Turing'in tam dilde yapılması genellikle çok sınırlı ön işlemciden daha kolaydır.

Uygulamada * izin verilmediği tek dil Javascript'tir ve sayısız soruna neden olur. Örneğin, dizinin ortasından bir çizgi kopyalayıp yapıştırırsanız, sonuna yapıştırır ve virgül kaldırmayı unutursanız, siteniz IE ziyaretçileriniz için tamamen bozulur.

* Teoride izin verilir, ancak Internet Explorer standardı takip etmez ve hata olarak kabul eder

Makineler için daha kolay, yani kodların ayrıştırılması ve oluşturulması. İnsanlar için, yani değişiklik, yorum yapma ve görsel zarafet gibi tutarlılık için daha kolaydır.

C varsayarsak, aşağıdakileri yazar mısınız?

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

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

    return EXIT_SUCCESS
}

Hayır. Sadece son ifade bir hata olduğu için değil, aynı zamanda tutarsız olduğu için. Öyleyse neden koleksiyonlar için aynı şey geçerli? Son noktalı virgülleri ve virgülleri atlamanıza izin veren dillerde bile, topluluk genellikle bunu sevmez. Örneğin Perl topluluğu, noktalı virgülleri atlamaktan hoşlanmıyor gibi görünüyor, tek katmanlı çubuklar. Bunu virgüllere de uygularlar.

Çok satırlı kod blokları için noktalı virgül kullanmazsanız, çok satırlı koleksiyonlarda virgül kullanmayın. Yani, dil izin verse bile yapmazdın, değil mi? Sağ?

Nedeni önemsiz: satır ekleme / çıkarma kolaylığı.

Aşağıdaki kodu düşünün:

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

Artık, bazen virgül eklemek / kaldırmak zorunda kalmadan listeye kolayca öğe ekleyebilir / kaldırabilirsiniz.

Diğer cevapların aksine, gerçekten liste oluşturma kolaylığı geçerli bir neden olduğunu düşünmüyorum: sonuçta, özel durum için son (veya ilk) satır için kod önemsizdir. Kod oluşturucular bir kez yazılır ve birçok kez kullanılır.

Her çizginin aynı formu izlemesini sağlar. Öncelikle bu, yeni satır eklemeyi kolaylaştırır ve değişikliği anlamlı bir şekilde takip eden bir sürüm kontrol sistemine sahip olmasını sağlar ve ayrıca kodu daha kolay analiz etmenizi sağlar. Teknik bir sebep düşünemiyorum.

Bunun, öğeleri uzun bir listede hareket ettirmekten kaynaklanan hatalardan korunmasına izin verilir.

Örneğin, şöyle bir kodumuz olduğunu varsayalım.

#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 sitelerinin orijinal üçlemesini gösterdiği için harika.

Stack Overflow
Super User
Server Fault

Ancak bununla ilgili bir sorun var. Görüyorsunuz, bu web sitesindeki altbilgi Süper Kullanıcıdan Önce Sunucu Hatası gösteriyor. Herkes fark etmeden daha iyi düzeltin.

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

Sonuçta, hareket eden çizgiler o kadar zor olamazdı, değil mi?

Stack Overflow
Server FaultSuper User

Biliyorum, "Server FaultSuper User" adında bir web sitesi yok, ancak derleyicimiz var olduğunu iddia ediyor. Şimdi sorun, C'nin iki çift tırnaklı dize yazmanıza ve bunları hiçbir şey kullanmadan birleştirmenize izin veren bir dize birleştirme özelliğine sahip olmasıdır ( -işaretin birden çok anlamı olduğu için tamsayılarda da benzer bir sorun olabilir ).

Peki ya orijinal dizinin sonunda işe yaramazsa virgül varsa? Çizgiler hareket edecekti, ama böyle bir hata olmazdı. Virgül kadar küçük bir şeyi kaçırmak kolaydır. Her dizi öğesinden sonra virgül koymayı hatırlarsanız, bu hata gerçekleşemez. Sen sen virgül sorunlarının nedenidir bulacağını kadar şey ayıklama dört saat harcamak istemem .

Birçok şey gibi, bir dizi başlatıcısındaki sondaki virgül C ++ 'ın C'den devralınan şeylerden biridir (ve sonsuza dek desteklemesi gerekecektir). "Derin C sırları" kitabında , buraya yerleştirilenlerden tamamen farklı bir görünümden bahsediliyor .

Burada birden fazla "virgül paradoksu" bulunan bir örnek var:

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

Biz okuyoruz :

... son başlatıcıdan sonra sondaki virgül bir yazım hatası değil , sözdiziminde bir Aborijin C'den taşınan bir çarpmadır . Varlığına veya yokluğuna izin verilir, ancak hiçbir önemi yoktur . ANSI C mantığında iddia edilen gerekçe, otomatik C üretimini kolaylaştırmasıdır. Enum bildirimlerinde olduğu gibi her virgül-sepa derecelendirmeli listede veya tek bir bildiride birden çok değişkenli bildiricide izleyen virgüllere izin verilirse talep daha güvenilir olacaktır . Onlar değil.

... bu bana daha mantıklı geliyor

Kod oluşturma ve düzenleme kolaylığına ek olarak, bir ayrıştırıcı uygulamak istiyorsanız, bu tür dilbilgisi uygulamak daha basit ve kolaydır. C #, bu kuralı, bir enumtanımdaki öğeler gibi, virgülle ayrılmış öğeler içeren bir liste izler .

Yalnızca bir satır eklemeniz gerektiğinden kod oluşturmayı kolaylaştırır ve son girişi özel bir durum gibi eklemeyi düşünmenize gerek yoktur. Bu özellikle kod oluşturmak için makrolar kullanıldığında geçerlidir. Dilden makro ihtiyacını ortadan kaldırmaya çalışmak için bir itme var, ancak dilin birçoğu makrolar mevcutken el ele gelişti. Ek virgül, aşağıdakiler gibi makroların tanımlanmasına ve kullanılmasına izin verir:

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

Kullanımı:

LIST_BEGIN
   LIST_ENTRY(1)
   LIST_ENTRY(2)
LIST_END

Bu çok basitleştirilmiş bir örnektir, ancak genellikle bu model makrolar tarafından gönderim, mesaj, etkinlik veya çeviri haritaları ve tabloları gibi şeyleri tanımlamak için kullanılır. Sonunda virgül kullanılmasına izin verilmezse, özel bir şeye ihtiyacımız olurdu:

#define LIST_LAST_ENTRY(x) x

ve bu kullanımı çok garip olurdu.

Böylece, iki kişi ayrı dallardaki bir listeye yeni bir öğe eklediğinde Git değişiklikleri düzgün bir şekilde birleştirebilir, çünkü Git satır bazında çalışır.

Belirtilen uzunlukta olmayan bir dizi kullanırsanız, VC ++ 6.0 uzunluğunu otomatik olarak belirleyebilir, bu nedenle "int a [] = {1,2,};" kullanırsanız a uzunluğu 3'tür, ancak sonuncusu Başlatılmadıysa, "cout <