Khi nào sử dụng trình khởi tạo có dấu ngoặc nhọn?

Trong C ++ 11, chúng ta có cú pháp mới để khởi tạo các lớp mang lại cho chúng ta một số lượng lớn các khả năng về cách khởi tạo biến.

{ // Example 1
  int b(1);
  int a{1};
  int c = 1;
  int d = {1};
}
{ // Example 2
  std::complex<double> b(3,4);
  std::complex<double> a{3,4};
  std::complex<double> c = {3,4};
  auto d = std::complex<double>(3,4);
  auto e = std::complex<double>{3,4};
}
{ // Example 3
  std::string a(3,'x');
  std::string b{3,'x'}; // oops
}
{ // Example 4
  std::function<int(int,int)> a(std::plus<int>());
  std::function<int(int,int)> b{std::plus<int>()};
}
{ // Example 5
  std::unique_ptr<int> a(new int(5));
  std::unique_ptr<int> b{new int(5)};
}
{ // Example 6
  std::locale::global(std::locale("")); // copied from 22.4.8.3
  std::locale::global(std::locale{""});
}
{ // Example 7
  std::default_random_engine a {}; // Stroustrup's FAQ
  std::default_random_engine b;
}
{ // Example 8
  duration<long> a = 5; // Stroustrup's FAQ too
  duration<long> b(5);
  duration<long> c {5};
}

Đối với mỗi biến tôi khai báo, tôi phải nghĩ mình nên sử dụng cú pháp khởi tạo nào và điều này làm chậm tốc độ viết mã của tôi. Tôi chắc rằng đó không phải là ý định giới thiệu các dấu ngoặc nhọn.

Khi nói đến mã mẫu, việc thay đổi cú pháp có thể dẫn đến các ý nghĩa khác nhau, vì vậy đi đúng cách là điều cần thiết.

Tôi tự hỏi liệu có một hướng dẫn chung nào mà người ta nên chọn cú pháp không.

Tôi nghĩ những điều sau đây có thể là một hướng dẫn tốt:

• Nếu giá trị (đơn) mà bạn đang khởi tạo nhằm là giá trị chính xác của đối tượng, hãy sử dụng =khởi tạo copy ( ) (vì sau đó trong trường hợp có lỗi, bạn sẽ không bao giờ vô tình gọi một hàm tạo rõ ràng, thường diễn giải giá trị được cung cấp khác nhau). Ở những nơi không có khởi tạo sao chép, hãy xem liệu khởi tạo dấu ngoặc nhọn có đúng ngữ nghĩa không, và nếu có, hãy sử dụng điều đó; nếu không, hãy sử dụng khởi tạo dấu ngoặc đơn (nếu điều đó cũng không khả dụng, bạn vẫn gặp may).

• Nếu các giá trị bạn đang khởi tạo là danh sách các giá trị được lưu trữ trong đối tượng (như các phần tử của vectơ / mảng hoặc phần thực / ảo của một số phức), hãy sử dụng khởi tạo dấu ngoặc nhọn nếu có.

• Nếu các giá trị bạn đang khởi tạo không phải là các giá trị được lưu trữ, nhưng mô tả giá trị / trạng thái dự định của đối tượng, hãy sử dụng dấu ngoặc đơn. Ví dụ là đối số kích thước của a vectorhoặc đối số tên tệp của an fstream.

Tôi khá chắc rằng sẽ không bao giờ có một hướng dẫn chung. Cách tiếp cận của tôi là sử dụng dấu ngoặc nhọn luôn nhớ rằng

1. Các hàm tạo danh sách khởi tạo được ưu tiên hơn các hàm tạo khác
2. Tất cả các vùng chứa thư viện chuẩn và std :: basic_string đều có các hàm tạo danh sách trình khởi tạo.
3. Khởi tạo dấu ngoặc nhọn không cho phép chuyển đổi thu hẹp.

Vì vậy, dấu ngoặc tròn và ngoặc nhọn không thể hoán đổi cho nhau. Nhưng biết chúng khác nhau ở điểm nào cho phép tôi sử dụng khởi tạo dấu ngoặc nhọn trên vòng trong hầu hết các trường hợp (một số trường hợp mà tôi không thể hiện là lỗi trình biên dịch).

Bên ngoài mã chung (tức là các mẫu), bạn có thể (và tôi cũng vậy) sử dụng dấu ngoặc nhọn ở mọi nơi . Một ưu điểm là nó hoạt động ở mọi nơi, chẳng hạn ngay cả khi khởi tạo trong lớp:

struct foo {
    // Ok
    std::string a = { "foo" };

    // Also ok
    std::string b { "bar" };

    // Not possible
    std::string c("qux");

    // For completeness this is possible
    std::string d = "baz";
};

hoặc cho các đối số hàm:

void foo(std::pair<int, double*>);
foo({ 42, nullptr });
// Not possible with parentheses without spelling out the type:
foo(std::pair<int, double*>(42, nullptr));

Đối với các biến mà tôi không chú ý nhiều giữa các T t = { init };hoặc các T t { init };kiểu, tôi thấy sự khác biệt là nhỏ và tệ nhất sẽ chỉ dẫn đến một thông báo trình biên dịch hữu ích về việc sử dụng sai một hàm explicittạo.

Đối với các kiểu chấp nhận std::initializer_listmặc dù rõ ràng là đôi khi cần các hàm không phải là std::initializer_listcấu tử (ví dụ cổ điển là std::vector<int> twenty_answers(20, 42);). Khi đó không cần niềng răng cũng được.

Khi nói đến mã chung (tức là trong các mẫu), đoạn cuối cùng lẽ ra phải đưa ra một số cảnh báo. Hãy xem xét những điều sau:

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args)
{ return std::unique_ptr<T> { new T { std::forward<Args>(args)... } }; }

Sau đó, auto p = make_unique<std::vector<T>>(20, T {});tạo một vectơ có kích thước 2 nếu Tlà ví dụ int, hoặc một vectơ có kích thước 20 nếu Tlà std::string. Một dấu hiệu rất rõ ràng rằng có điều gì đó rất sai đang xảy ra ở đây là không có đặc điểm nào có thể cứu bạn ở đây (ví dụ: với SFINAE): std::is_constructiblelà về mặt khởi tạo trực tiếp, trong khi chúng tôi đang sử dụng khởi tạo dấu ngoặc nhọn để định hướng thành trực tiếp- khởi tạo nếu và chỉ khi không có hàm tạo nào std::initializer_listcan thiệp. Tương tự std::is_convertiblekhông có ích gì.

Tôi đã điều tra xem liệu có thực sự có thể tự tay cuộn một đặc điểm có thể khắc phục điều đó hay không nhưng tôi không quá lạc quan về điều đó. Trong mọi trường hợp, tôi không nghĩ rằng chúng ta sẽ thiếu nhiều, tôi nghĩ rằng thực tế make_unique<T>(foo, bar)dẫn đến kết quả xây dựng tương đương với T(foo, bar)rất trực quan; đặc biệt là vì điều đó make_unique<T>({ foo, bar })khá khác nhau và chỉ có ý nghĩa nếu foovà barcó cùng một loại.

Do đó, đối với mã chung, tôi chỉ sử dụng dấu ngoặc nhọn để khởi tạo giá trị (ví dụ T t {};hoặc T t = {};), điều này rất thuận tiện và tôi nghĩ là tốt hơn so với cách C ++ 03 T t = T();. Nếu không, đó là cú pháp khởi tạo trực tiếp (tức là T t(a0, a1, a2);) hoặc đôi khi là cấu trúc mặc định ( T t; stream >> t;là trường hợp duy nhất tôi sử dụng mà tôi nghĩ).

Điều đó không có nghĩa là tất cả các niềng răng đều xấu, hãy xem xét ví dụ trước với các bản sửa lỗi:

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args)
{ return std::unique_ptr<T> { new T(std::forward<Args>(args)...) }; }

Điều này vẫn sử dụng dấu ngoặc nhọn để xây dựng std::unique_ptr<T>, mặc dù kiểu thực tế phụ thuộc vào tham số mẫu T.