Почему инициализация списка (с использованием фигурных скобок) лучше, чем альтернативы?

В основном копирование и вставка из The C ++ Programming Language 4th Edition Бьярна Страуструпа:

Инициализация списка не позволяет сужать (§iso.8.5.4). То есть:

• Целое число не может быть преобразовано в другое целое число, которое не может содержать свое значение. Например, допускается преобразование char в int, но не из int в char.
• Значение с плавающей запятой нельзя преобразовать в другой тип с плавающей запятой, который не может содержать свое значение. Например, можно использовать float для double, но не double для float.
• Значение с плавающей запятой нельзя преобразовать в целочисленный тип.
• Целочисленное значение нельзя преобразовать в тип с плавающей запятой.

Пример:

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)

}

Единственная ситуация, когда = предпочтительнее {}, - это использование ключевого слова auto для получения типа, определенного инициализатором.

Пример:

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

Заключение

Предпочитайте {} инициализацию альтернативным вариантам, если у вас нет веских причин не делать этого.

Уже есть отличные ответы о преимуществах использования инициализации списка, однако мое личное эмпирическое правило - НЕ использовать фигурные скобки, когда это возможно, а вместо этого делать его зависимым от концептуального значения:

• Если объект, который я создаю, концептуально содержит значения, которые я передаю в конструкторе (например, контейнеры, структуры POD, атомики, интеллектуальные указатели и т. Д.), Я использую фигурные скобки.
• Если конструктор похож на обычный вызов функции (он выполняет некоторые более или менее сложные операции, которые параметризуются аргументами), то я использую обычный синтаксис вызова функции.
• Для инициализации по умолчанию я всегда использую фигурные скобки.
  Во-первых, таким образом я всегда уверен, что объект инициализируется независимо от того, например, - это «настоящий» класс с конструктором по умолчанию, который все равно будет вызываться, или встроенным типом / POD. Во-вторых, это - в большинстве случаев - соответствует первому правилу, поскольку инициализированный объект по умолчанию часто представляет собой «пустой» объект.

По моему опыту, этот набор правил можно применять гораздо более последовательно, чем использование фигурных скобок по умолчанию, но необходимо явно запоминать все исключения, когда они не могут быть использованы или имеют другое значение, чем «нормальный» синтаксис вызова функции с круглыми скобками. (вызывает другую перегрузку).

Это, например, хорошо сочетается со стандартными типами библиотек, такими как 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

Существует МНОГО причин использовать инициализацию скобок, но вы должны знать, что конструктор initializer_list<> предпочтительнее других конструкторов, за исключением конструктора по умолчанию. Это приводит к проблемам с конструкторами и шаблонами, где конструктор типа T может быть либо списком инициализаторов, либо простым старым ctor.

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

Предполагая, что вы не сталкиваетесь с такими классами, есть небольшая причина не использовать список инициализаторов.

Это безопаснее, если вы не строите с -Wno-сужением, как, скажем, Google в Chromium. Если да, то это МЕНЬШЕ безопасно. Однако без этого флага единственные небезопасные случаи будут исправлены C ++ 20.

Примечание: A) Фигурные скобки безопаснее, потому что они не позволяют сужаться. Б) Фигурные скобки менее безопасны, потому что они могут обходить частные или удаленные конструкторы и неявно вызывать явно отмеченные конструкторы.

Эти две комбинации означают, что они безопаснее, если то, что находится внутри, является примитивными константами, но менее безопасно, если они являются объектами (хотя и исправлено в C ++ 20).