Скобки () {} при инициализации внутри класса

Подскажите пожалуйста, а есть ли разница между использованием круглых и фигурных скобок при инициализации конструктора внутри класса. Оба варианта работают корректно.
class A { public: char c; int d;
A(char ch) :c(ch) {} A(char ch, int i) :c{ch}, d{i} {} };
int main() { A first = A('a'); A second = A('b', 1);
cout << "First: " << first.c << endl; cout << "Second: " << second.c << ' ' << second.d << endl;
return 0; }

Ответ

Начнем с того, что имеются случаи, когда нельзя применять инициализацию одного из видов к членам данных класса.
Например, если у вас имеется член класса, который является агрегатом (структурой или массивом), то возможные виды инициализации ограничены.
Рассмотрим несколько примеров.
В данном примере внутри структуры A объявляется агрегатный член данных B, имеющий тип структуры. Тогда данное объявление конструктора будет некорректныым
struct A { A(int x) : b( x ) {}
struct B { int x; } b; };
int main() { A a( 10 ); }
Компилятор выдаст сообщение об ошибке, говорящее о том, что он не может преобразовать объект типа int в объект типа struct B. Однако если вы замените круглые скобки на фигурные,
struct A { A(int x) : b{ x } {}
struct B { int x; } b; };
int main() { A a( 10 ); }
то код будет успешно компилироваться, так как объект b будет инициализирован как агрегат.
Теперь если в конструкторе заменить тип у параметра с int на A::B, то ситуация изменится.
Данная программа будет успешно компилироваться
struct A { struct B;
A(B x) : b( x ) {}
struct B { int x; } b; };
int main() { A::B b = { 10 }; A a( b ); }
так как структуры, которые являются агрегатами, имеют конструктор копирования, создаваемый компилятором неявно.
Иная ситуация складывается, когда членом данных, который представляет собой агрегат, является массив. Как и в случае со структурой, данная программа не будет компилироваться
struct A { struct B;
A(int x) : b( x ) {}
int b[1]; };
int main() { int b = 10; A a( b ); }
так как нет преобразования из целочисленного типа в массив.
Однако если заменить параметр на массив, не важно, является он ссылкой или нет, как показано ниже
struct A { struct B;
A(int x[1]) : b( x ) {}
int b[1]; };
int main() { int b[1] = { 10 }; A a( b ); }
или
struct A { struct B;
A(int ( &x )[1]) : b( x ) {}
int b[1]; };
int main() { int b[1] = { 10 }; A a( b ); }
то программа не будет компилироваться, так как в первом случае нет преобразования из указателя в массив, а во втором случае, когда параметр объявлен как ссылка, массивы не имеют конструктора копирования.
Для инициализации члена данных, который является массивом, можно использовать следующую запись
struct A { struct B;
A(int x) : b{ x } {}
int b[1]; };
int main() { int b = 10; A a( b ); }
Данная программа успешно скомпилируется. Однако вы не можете запись с фигурными скобками заключить еще в круглые собкки, как показано ниже
struct A { struct B;
A(int x) : b({ x }) {}
int b[1]; };
int main() { int b = 10; A a( b ); }
Компилятор выдаст сообщение об ошибке, так как, опять-таки, для массивов нет конструктора копирования. Однако для структур такая запись инициализации будет успешно воспринята компилятором, так как структуры, как агрегаты, имеют неявно объявленный компилятором конструктор копирования.
struct A { A(int x) : b({ x }) {}
struct B { int x; } b; };
int main() { int b = 10; A a( b ); }
Данная программа успешно скомпилируется.
Для арифметических типов инициализация с фигурными скобками не разрешает "сужение" значения, то есть использовать в качестве инициализатора значение, которое потенциально не может разместиться в инициализируемом объекте. Поэтому следующая программа не будет компилироваться
struct A { A(int x) : b{ x } {} short b; };
int main() { int b = 10; A a( b ); }
Причиной ошибки будет то, что объект типа short не в состоянии разместить все значения объекта типа int, то есть будет иметь место "сужение" инициализирующего значения.
Однако если заменить фигурные скобки на круглые, то программа успешно скомпилируется
struct A { A(int x) : b( x ) {} short b; };
int main() { int b = 10; A a( b ); }
Когда инициализируемый член класса является определенный пользователем тип, то в дело вступают конструкторы, которые имеют параметр типа std::initializer_list
Например, в приведенной ниже программе, когда нет такого конструктора, можно инициализировать член класса как b( x ), или как b{ x }, или даже как b( { x } )
struct A { A(int x) : b({ x }) {}
struct B { B(int x) { std::cout << "B( int )" << std::endl; } } b; };
int main() { int b = 10; A a(b); }
Однако если в классе присутствует конструктор с параметром типа std::initializer list, то для инициализаций вида b{ x } и b( { x } ) будет вызван именно он. А для инициализации вида b( x ) будет вызван другой конструктор.
Например, для этой программы
struct A { A(int x) : b( x ) {}
struct B { B(int x) { std::cout << "B( int )" << std::endl; } B(std::initializer_list) { std::cout << "B( std::initializer_list )" << std::endl; } } b; };
int main() { int b = 10; A a(b); }
будет выведено сообзение
B( int )
А для этой программы
struct A { A(int x) : b{ x } {}
struct B { B(int x) { std::cout << "B( int )" << std::endl; } B(std::initializer_list) { std::cout << "B( std::initializer_list )" << std::endl; } } b; };
int main() { int b = 10; A a(b); }
будет выведено сообщение
B( std::initializer_list )
Вообще, эта тема достаточно обширная.
О некоторых причудах инициализации я написал на своем сайте в конце темы Шутка - ложь, но в ней намек, добрым молодцам урок.