Liste başlatma (kıvırcık parantez kullanarak) neden alternatiflerden daha iyi?

MyClass a1 {a};     // clearer and less error-prone than the other three
MyClass a2 = {a};
MyClass a3 = a;
MyClass a4(a);

Neden?

SO ile ilgili bir cevap bulamadım, bu yüzden kendi sorumu yanıtlamama izin verin.

Temel olarak Bjarne Stroustrup'un "The C ++ Programming Language 4th Edition" dan kopyalanması ve yapıştırılması :

Listenin başlatılması daralmaya izin vermemektedir (§iso.8.5.4). Yani:

• Bir tam sayı, değerini tutamayan başka bir tam sayıya dönüştürülemez. Örneğin, char'dan int'e izin verilir, ancak char'a int için izin verilmez.
• Kayan nokta değeri, değerini tutamayan başka bir kayan nokta türüne dönüştürülemez. Örneğin, şamandıra iki katına izin verilir, ancak iki kat yüzmeye izin verilmez.
• Kayan nokta değeri bir tamsayı tipine dönüştürülemez.
• Bir tam sayı değeri kayan nokta türüne dönüştürülemez.

Misal:

void fun(double val, int val2) {

    int x2 = val; // if val==7.9, x2 becomes 7 (bad)

    char c2 = val2; // if val2==1025, c2 becomes 1 (bad)

    int x3 {val}; // error: possible truncation (good)

    char c3 {val2}; // error: possible narrowing (good)

    char c4 {24}; // OK: 24 can be represented exactly as a char (good)

    char c5 {264}; // error (assuming 8-bit chars): 264 cannot be 
                   // represented as a char (good)

    int x4 {2.0}; // error: no double to int value conversion (good)

}

Sadece kullanırken = daha fazla tercih edilir bir durum {} olan autobaşlatıcısı tarafından belirlenen tipini almak için anahtar kelime.

Misal:

auto z1 {99};   // z1 is an int
auto z2 = {99}; // z2 is std::initializer_list<int>
auto z3 = 99;   // z3 is an int

Sonuç

Güçlü bir nedeniniz olmadıkça {} alternatiflere göre başlatmayı tercih edin.

Liste başlatmanın kullanılmasının avantajları hakkında zaten büyük cevaplar var, ancak kişisel başparmak kuralım mümkün olduğunda kıvırcık parantez kullanmak DEĞİL, bunun yerine kavramsal anlama bağlı hale getirmek:

• Oluşturduğum nesne kavramsal olarak yapıcıda geçirdiğim değerleri tutarsa ​​(örn. Kaplar, POD yapıları, atomlar, akıllı işaretçiler vb.), Kaşlı ayraçları kullanıyorum.
• Yapıcı normal bir işlev çağrısına benziyorsa (bağımsız değişkenler tarafından parametrelenen az çok karmaşık işlemleri gerçekleştirirse) normal işlev çağrısı sözdizimini kullanıyorum.
• Varsayılan başlatma için her zaman kıvırcık parantez kullanırım.
  Birincisi, bu şekilde her zaman, örneğin, yine de çağrılacak varsayılan bir kurucu veya bir yerleşik / POD türü ile "gerçek" bir sınıf olup olmadığına bakılmaksızın nesnenin başlatıldığından eminim. İkincisi - çoğu durumda - ilk kuralla tutarlıdır, çünkü varsayılan olarak başlatılmış bir nesne genellikle "boş" bir nesneyi temsil eder.

Deneyimlerime göre, bu kural seti varsayılan olarak kıvırcık parantez kullanmaktan çok daha tutarlı bir şekilde uygulanabilir, ancak kullanılamadığında veya istisna "normal" işlev çağrısı sözdiziminden farklı bir anlamı olduğunda tüm istisnaları açıkça hatırlamak zorunda (farklı bir aşırı yük çağırır).

Örneğin, aşağıdaki gibi standart kütüphane türlerine çok uygundur std::vector:

vector<int> a{10,20};   //Curly braces -> fills the vector with the arguments

vector<int> b(10,20);   //Parentheses -> uses arguments to parametrize some functionality,                          
vector<int> c(it1,it2); //like filling the vector with 10 integers or copying a range.

vector<int> d{};      //empty braces -> default constructs vector, which is equivalent
                      //to a vector that is filled with zero elements

Orada kullanım ayracı başlatma için birçok neden vardır, ancak bilmelidir yapıcı diğer kurucular tercih edilir istisna varsayılan-yapıcı olmak. Bu, tür yapıcısının bir başlatıcı listesi veya düz eski bir ctor olabileceği yapıcılar ve şablonlarla ilgili sorunlara yol açar .initializer_list<>T

struct Foo {
    Foo() {}

    Foo(std::initializer_list<Foo>) {
        std::cout << "initializer list" << std::endl;
    }

    Foo(const Foo&) {
        std::cout << "copy ctor" << std::endl;
    }
};

int main() {
    Foo a;
    Foo b(a); // copy ctor
    Foo c{a}; // copy ctor (init. list element) + initializer list!!!
}

Bu tür sınıflarla karşılaşmadığınızı varsayarsak, intializer listesini kullanmamak için çok az neden vardır.

Google'ın Chromium'da yaptığı gibi -Wno-daralma ile oluşturmadığınız sürece daha güvenlidir. Eğer yaparsanız, o zaman daha az güvenlidir. Bu bayrak olmadan, sadece güvensiz durumlar C ++ 20 tarafından düzeltilecektir.

Not: A) Kıvırcık parantezler daha da güvenlidir, çünkü daralmaya izin vermezler. B) Kıvırcık parantezler daha az güvenlidir, çünkü özel veya silinmiş kurucuları atlayabilir ve açık işaretli kurucuları dolaylı olarak çağırabilirler.

Bu iki birleşik, içerideki şey ilkel sabitler ise daha güvenli, ancak nesneler ise daha az güvenli oldukları anlamına gelir (C ++ 20'de düzeltilmiş olsa da)