Когда использовать инициализатор, заключенный в скобки?

Я почти уверен, что никогда не будет универсального руководства. Мой подход заключается в использовании всегда фигурных скобок, помня, что

1. конструкторы списка инициализаторов имеют приоритет над другими конструкторами
2. все стандартные контейнеры библиотеки и std::basic_string имеют конструкторы списка инициализаторов.
3. инициализация фигурной скобки не позволяет сужать преобразования.

такие круглые и фигурные скобки не являются взаимозаменяемыми. Но знание того, где они отличаются, позволяет мне использовать инициализацию curly over round bracket в большинстве случаев (некоторые из случаев, когда я не могу в настоящее время ошибки компилятора).

вне общего кода (т. е. шаблонов), вы можете (и я делаю) использовать фигурные скобки везде. Одним из преимуществ является то, что он работает везде, например, даже для инициализации в классе:

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

или для аргументов функции:

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));

для переменных я не обращаю особого внимания между T t = { init }; или T t { init }; стили, я считаю, что разница незначительна и в худшем случае приведет только к полезному сообщению компилятора о неправильном использовании explicit конструктор.

для типов, которые принимают std::initializer_list хотя, очевидно, иногда неstd::initializer_list необходимы конструкторы (классический пример std::vector<int> twenty_answers(20, 42);). Это нормально, чтобы не использовать фигурные скобки тогда.

---

когда дело доходит до общего кода (т. е. в шаблонах), что самый последний абзац должен был вызвать некоторые предупреждения. Рассмотрим следующее:

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

затем auto p = make_unique<std::vector<T>>(20, T {}); создает вектор размера 2, Если T например int, или вектор размера 20, если T и std::string. Очень красноречивым признаком того, что здесь происходит что-то очень неправильное, является то, что есть нет черта, которая может спасти вас здесь (например, с SFINAE):std::is_constructible С точки зрения прямой инициализации, тогда как мы используем brace-инициализацию, которая переносится на прямую инициализацию если и только если там нет конструктора принимая std::initializer_list вмешательства. Точно так же std::is_convertible не поможет.

я исследовал, если это на самом деле возможно ручной рулон черта, которая может исправить это, но я не слишком оптимистично об этом. В любом случае я не думаю, что мы будем много пропускать, я думаю, что тот факт, что make_unique<T>(foo, bar) результат в конструкции, эквивалентной T(foo, bar) очень понятный, особенно учитывая, что make_unique<T>({ foo, bar }) - это совсем другое и имеет смысл, только если foo и bar иметь тот же тип.

отсюда для общего кода я использую только фигурные скобки для инициализации значения (например,T t {}; или T t = {};), что очень удобно, и я думаю, что превосходит c++03 way T t = T();. в противном случае это либо непосредственный синтаксис инициализации (т. е. T t(a0, a1, a2);), или иногда конструкция по умолчанию (T t; stream >> t; будучи единственным случаем, когда я использую это, я думаю).

это не значит, что все фигурные скобки плохи, хотя, рассмотрим предыдущий пример с исправлениями:

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

это все еще использует фигурные скобки для построения std::unique_ptr<T>, даже если фактический тип зависит от параметра шаблона T.