Mengapa inisialisasi daftar (menggunakan kurung kurawal) lebih baik daripada alternatifnya?

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

Mengapa?

Saya tidak dapat menemukan jawaban di SO, jadi izinkan saya menjawab pertanyaan saya sendiri.

Pada dasarnya menyalin dan menempel dari Bjarne Stroustrup "The C ++ Programming Language 4th Edition" :

Inisialisasi daftar tidak memungkinkan penyempitan (§.88.4.4). Itu adalah:

• Integer tidak dapat dikonversi ke integer lain yang tidak dapat menyimpan nilainya. Misalnya, char to int diizinkan, tetapi tidak int ke char.
• Nilai titik-mengambang tidak dapat dikonversi ke jenis titik-mengambang lain yang tidak dapat menyimpan nilainya. Sebagai contoh, float to double diperbolehkan, tetapi tidak double to float.
• Nilai floating-point tidak dapat dikonversi ke tipe integer.
• Nilai integer tidak dapat dikonversi ke tipe floating-point.

Contoh:

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)

}

Satu- satunya situasi di mana = lebih disukai daripada {} adalah ketika menggunakan autokata kunci untuk mendapatkan jenis yang ditentukan oleh penginisialisasi.

Contoh:

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

Kesimpulan

Lebih suka {} inisialisasi daripada alternatif kecuali Anda memiliki alasan kuat untuk tidak melakukannya.

Sudah ada jawaban yang bagus tentang keuntungan menggunakan inisialisasi daftar, namun aturan pribadi saya adalah TIDAK untuk menggunakan kurung kurawal bila memungkinkan, tetapi sebaliknya membuatnya tergantung pada makna konseptual:

• Jika objek yang saya buat secara konseptual memiliki nilai yang saya berikan dalam konstruktor (mis. Kontainer, POD struct, atomics, smart pointer, dll.), Maka saya menggunakan kawat gigi.
• Jika konstruktor menyerupai pemanggilan fungsi normal (ia melakukan beberapa operasi yang lebih atau kurang kompleks yang ditentukan oleh argumen) maka saya menggunakan sintaks pemanggilan fungsi normal.
• Untuk inisialisasi default, saya selalu menggunakan kurung kurawal.
  Untuk satu, dengan cara itu saya selalu yakin bahwa objek akan diinisialisasi terlepas dari apakah itu misalnya kelas "nyata" dengan konstruktor default yang akan dipanggil tetap atau tipe builtin / POD. Kedua itu - dalam banyak kasus - konsisten dengan aturan pertama, sebagai objek default diinisialisasi sering mewakili objek "kosong".

Dalam pengalaman saya, aturan ini dapat diterapkan jauh lebih konsisten daripada menggunakan kurung kurawal secara default, tetapi harus secara eksplisit mengingat semua pengecualian ketika mereka tidak dapat digunakan atau memiliki makna yang berbeda dari sintaks pemanggilan fungsi "normal" dengan tanda kurung (memanggil kelebihan beban yang berbeda).

Misalnya cocok dengan tipe perpustakaan standar seperti 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

Ada alasan BANYAK untuk inisialisasi penggunaan brace, tetapi Anda harus menyadari bahwa yang initializer_list<>konstruktor lebih disukai untuk konstruktor lain , pengecualian menjadi default-konstruktor. Ini mengarah ke masalah dengan konstruktor dan template di mana Tkonstruktor tipe dapat berupa daftar penginisialisasi atau ctor tua yang polos.

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!!!
}

Dengan asumsi Anda tidak menemukan kelas-kelas seperti itu, ada sedikit alasan untuk tidak menggunakan daftar intializer.

Ini hanya lebih aman selama Anda tidak membangun dengan -Sekarang menyempit seperti kata Google di Chromium. Jika Anda melakukannya, maka itu KURANG aman. Tanpa tanda itu, hanya case yang tidak aman akan diperbaiki oleh C ++ 20 sekalipun.

Catatan: A) Kurung keriting lebih aman karena tidak memungkinkan penyempitan. B) Kurung kurawal kurang aman karena mereka dapat memotong konstruktor pribadi atau dihapus, dan memanggil konstruktor bertanda eksplisit secara implisit.

Kedua gabungan itu berarti mereka lebih aman jika apa yang ada di dalamnya adalah konstanta primitif, tetapi kurang aman jika mereka adalah objek (meskipun tetap dalam C ++ 20)