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

#cpp #классы #конструктор #инициализация #объявление

Подскажите пожалуйста, а есть ли разница между использованием круглых и фигурных
скобок при инициализации конструктора внутри класса. Оба варианта работают корректно.

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

    

Ответы

Ответ 1

Начнем с того, что имеются случаи, когда нельзя применять инициализацию одного из
видов к членам данных класса.

Например, если у вас имеется член класса, который является агрегатом (структурой
или массивом), то возможные виды инициализации ограничены.

Рассмотрим несколько примеров.

В данном примере внутри структуры 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 )


Вообще, эта тема достаточно обширная.

О некоторых причудах инициализации я написал на своем сайте в конце темы Шутка -
ложь, но в ней намек, добрым молодцам урок.


Ответ 2

Ну, например, напишите

int main(int argc, const char * argv[])
{
    A a(300);
    A b{300};
}


Вам сразу сообщат, что второе объявление не годится - поскольку 300 в char не поместится.
Инициализация с фигурными скобками не разрешает сужающее преобразование.

Есть и другие отличия - например, при фигурных скобках компилятор будет искать конструктор
от initializer_list. Например, если в вашем классе будет такое:

class A {
    vector v;
...
A(int x):v{x} {}
A(int x):v(x) {}


то последние две строчки означают совершенно разные вещи - первая - вектор с элементом
x, а вторая - вектор с x элементами...