Tại sao khởi tạo danh sách (sử dụng dấu ngoặc nhọn) tốt hơn so với các lựa chọn thay thế?

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

Tại sao?

Tôi không thể tìm thấy câu trả lời trên SO, vì vậy hãy để tôi trả lời câu hỏi của riêng tôi.

Về cơ bản sao chép và dán từ "Phiên bản thứ 4 của ngôn ngữ lập trình C ++" của Bjarne Stroustrup :

Danh sách khởi tạo không cho phép thu hẹp (§iso.8.5.4). Đó là:

• Một số nguyên không thể được chuyển đổi thành một số nguyên khác không thể giữ giá trị của nó. Ví dụ: char to int được cho phép, nhưng không cho phép int.
• Không thể chuyển đổi giá trị của dấu phẩy động sang loại dấu phẩy động khác mà không thể giữ giá trị của nó. Ví dụ, float to double được cho phép, nhưng không được double để float.
• Không thể chuyển đổi giá trị dấu phẩy động thành loại số nguyên.
• Một giá trị số nguyên không thể được chuyển đổi thành loại dấu phẩy động.

Thí dụ:

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)

}

Các chỉ tình huống mà = được ưa thích hơn {} là khi sử dụng autotừ khóa để có được những loại xác định bởi initializer.

Thí dụ:

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

Phần kết luận

Thích khởi tạo {} hơn các lựa chọn thay thế trừ khi bạn có lý do chính đáng để không.

Đã có câu trả lời tuyệt vời về những lợi ích của việc sử dụng khởi tạo danh sách, tuy nhiên quy tắc cá nhân của tôi là KHÔNG sử dụng dấu ngoặc nhọn bất cứ khi nào có thể, mà thay vào đó làm cho nó phụ thuộc vào ý nghĩa khái niệm:

• Nếu đối tượng tôi đang tạo về mặt khái niệm giữ các giá trị mà tôi truyền trong hàm tạo (ví dụ: container, cấu trúc POD, nguyên tử, con trỏ thông minh, v.v.), thì tôi đang sử dụng dấu ngoặc nhọn.
• Nếu hàm tạo giống như một lệnh gọi hàm bình thường (nó thực hiện một số thao tác phức tạp hơn hoặc ít hơn được tham số hóa bởi các đối số) thì tôi đang sử dụng cú pháp gọi hàm bình thường.
• Để khởi tạo mặc định tôi luôn sử dụng dấu ngoặc nhọn.
  Đối với một người, theo cách đó, tôi luôn chắc chắn rằng đối tượng được khởi tạo bất kể nó là lớp "thực" với hàm tạo mặc định sẽ được gọi bằng cách nào hoặc kiểu dựng sẵn / POD. Thứ hai, đó là - trong hầu hết các trường hợp - phù hợp với quy tắc đầu tiên, vì một đối tượng khởi tạo mặc định thường đại diện cho một đối tượng "trống".

Theo kinh nghiệm của tôi, quy tắc này có thể được áp dụng nhất quán hơn nhiều so với sử dụng dấu ngoặc nhọn theo mặc định, nhưng phải nhớ rõ tất cả các ngoại lệ khi chúng không thể được sử dụng hoặc có ý nghĩa khác với cú pháp gọi hàm "thông thường" với dấu ngoặc đơn (gọi là quá tải khác nhau).

Nó ví dụ phù hợp độc đáo với các loại thư viện tiêu chuẩn như 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

Có NHIỀU lý do để sử dụng khởi tạo dấu ngoặc, nhưng bạn nên lưu ý rằng hàm initializer_list<>tạo được ưu tiên hơn các hàm tạo khác , ngoại lệ là hàm tạo mặc định. Điều này dẫn đến các vấn đề với các hàm tạo và các mẫu trong đó hàm tạo kiểu Tcó thể là danh sách khởi tạo hoặc một ctor cũ đơn giản.

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

Giả sử bạn không gặp phải các lớp như vậy, có rất ít lý do để không sử dụng danh sách intializer.

Nó chỉ an toàn hơn miễn là bạn không xây dựng với - Thu hẹp như Google nói trong Chromium. Nếu bạn làm, thì đó là ÍT an toàn. Không có cờ đó, các trường hợp không an toàn sẽ được sửa bởi C ++ 20.

Lưu ý: A) Dấu ngoặc nhọn an toàn hơn vì chúng không cho phép thu hẹp. B) Người lùn xoăn ít an toàn hơn vì họ có thể bỏ qua các nhà xây dựng riêng tư hoặc bị xóa và gọi ngầm các nhà xây dựng được đánh dấu rõ ràng.

Hai kết hợp đó có nghĩa là chúng an toàn hơn nếu những gì bên trong là hằng số nguyên thủy, nhưng kém an toàn hơn nếu chúng là các đối tượng (mặc dù đã được cố định trong C ++ 20)