Por que a inicialização de lista (usando chaves) é melhor que as alternativas?

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

Por quê?

Não consegui encontrar uma resposta no SO, então deixe-me responder minha própria pergunta.

Basicamente, copia e cola do "The C ++ Programming Language 4th Edition" de Bjarne Stroustrup :

A inicialização da lista não permite restringir (§iso.8.5.4). Isso é:

• Um número inteiro não pode ser convertido para outro número inteiro que não pode conter seu valor. Por exemplo, char para int é permitido, mas não int para char.
• Um valor de ponto flutuante não pode ser convertido para outro tipo de ponto flutuante que não pode conter seu valor. Por exemplo, é permitido flutuar para dobrar, mas não dobrar para flutuar.
• Um valor de ponto flutuante não pode ser convertido em um tipo inteiro.
• Um valor inteiro não pode ser convertido em um tipo de ponto flutuante.

Exemplo:

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)

}

A única situação em que = é preferível a {} é ao usar a autopalavra-chave para obter o tipo determinado pelo inicializador.

Exemplo:

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

Conclusão

Prefira a inicialização {} sobre as alternativas, a menos que você tenha um forte motivo para não fazê-lo.

Já existem ótimas respostas sobre as vantagens de usar a inicialização de lista, no entanto, minha regra pessoal NÃO é usar chaves sempre que possível, mas torná-la dependente do significado conceitual:

• Se o objeto que estou criando conceitualmente mantém os valores que estou passando no construtor (por exemplo, contêineres, estruturas de POD, atômica, ponteiros inteligentes etc.), então estou usando os chavetas.
• Se o construtor se assemelhar a uma chamada de função normal (ele executa algumas operações mais ou menos complexas que são parametrizadas pelos argumentos), então estou usando a sintaxe da chamada de função normal.
• Para inicialização padrão, eu sempre uso chaves.
  Por um lado, dessa forma, eu sempre tenho certeza de que o objeto é inicializado, independentemente de, por exemplo, ser uma classe "real" com um construtor padrão que seria chamado assim mesmo ou um tipo interno / POD. Segundo, é - na maioria dos casos - consistente com a primeira regra, pois um objeto inicializado padrão geralmente representa um objeto "vazio".

Na minha experiência, esse conjunto de regras pode ser aplicado de maneira muito mais consistente do que usar chaves, por padrão, mas ter que lembrar explicitamente todas as exceções quando elas não puderem ser usadas ou tiverem um significado diferente da sintaxe "normal" de chamada de função com parênteses (chama uma sobrecarga diferente).

Por exemplo, ele se encaixa muito bem com os tipos de biblioteca padrão, como 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

Existem MUITAS razões para usar a inicialização entre parênteses, mas você deve estar ciente de que o initializer_list<>construtor é preferido aos outros construtores , a exceção sendo o construtor padrão. Isso leva a problemas com construtores e modelos nos quais o Tconstrutor de tipos pode ser uma lista de inicializadores ou um ctor antigo simples.

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

Supondo que você não encontre essas classes, há poucas razões para não usar a lista do inicializador.

É mais seguro, desde que você não construa com o -Wno-estreitando, como o Google faz no Chromium. Se o fizer, é MENOS seguro. Sem esse sinalizador, os únicos casos inseguros serão corrigidos pelo C ++ 20.

Nota: A) Os colchetes são mais seguros porque não permitem o estreitamento. B) Os brackers encaracolados são menos seguros porque podem ignorar construtores particulares ou excluídos e chamar implicitamente marcadores explícitos.

Esses dois combinados significam que eles são mais seguros se o que está dentro são constantes primitivas, mas menos seguros se forem objetos (embora fixados no C ++ 20)