Конструкторы и списки инициализации членов

Конструктор — это специальная нестатическая член-функция класса, используемая для инициализации объектов типа этого класса.

В определении конструктора класса список инициализации членов определяет инициализаторы для прямых и виртуальных базовых классов и нестатических данных членов. (Не следует путать с std::initializer_list. )

Синтаксис

Конструкторы объявляются с использованием деклараторов член-функций следующего вида:

Где имя-класса должно называть текущий класс (или текущую инстанциацию шаблона класса) или, при объявлении на уровне пространства имён или в объявлении друга, должно быть квалифицированным именем класса.

Единственными спецификаторами, разрешенными в последовательность-спецификаторов-объявления объявления конструктора, являются friend, inline, constexpr(с C++11), consteval(с C++20), и explicit (в частности, тип возврата не допускается). Обратите внимание, что квалификаторы cv и ref также не допускаются: семантика const и volatile объекта во время его создания не включается, пока не завершится конструктор самого производного класса.

Тело определения функции любого конструктора, перед открывающей фигурной скобкой составного оператора, может включать список инициализации членов, синтаксис которого — двоеточие :, за которым следует перечисленные через запятую один или несколько инициализаторов-членов, каждый из которых имеет следующий синтаксис:

struct S
{
    int n;
 
    S(int);       // constructor declaration
 
    S() : n(7) {} // constructor definition:
                  // ": n(7)" is the initializer list
                  // ": n(7) {}" is the function body
};
 
S::S(int x) : n{x} {} // constructor definition: ": n{x}" is the initializer list
 
int main()
{
    S s;      // calls S::S()
    S s2(10); // calls S::S(int)
}

Объяснение

Конструкторы не имеют имен и не могут вызываться напрямую. Они вызываются при инициализации и выбираются в соответствии с правилами инициализации. Конструкторы без explicit спецификатора являются преобразующими конструкторами. Конструкторы со спецификатором constexpr делают их тип LiteralType. Конструкторы, которые могут быть вызваны без аргументов, являются конструкторами по умолчанию. Конструкторы, принимающие другой объект того же типа в качестве аргумента, являются копирующими конструкторами и перемещающими конструкторами.

Перед началом выполнения составного оператора, образующего тело функции конструктора, завершается инициализация всех прямых базовых классов, виртуальных базовых классов и нестатических членов данных. Список инициализации членов — это место, где можно указать инициализацию под-объектов, отличную от инициализации по умолчанию. Для базовых классов, которые не могут быть инициализированы по умолчанию, и для нестатических членов данных, которые не могут быть инициализированы по умолчанию или их инициализатором по умолчанию, если он есть(с C++11), таких как члены ссылочного и const-квалифицированного типов, инициализаторы членов должны быть указаны. (Обратите внимание, что инициализаторы членов по умолчанию для нестатических членов данных инстанциаций шаблонов классов могут быть недействительными, если тип члена или инициализатор зависит от шаблона)(с C++11) Инициализация не выполняется для анонимных объединений или членов варианта, которые не имеют инициализатора члена или инициализатора члена по умолчанию(с C++11).

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

Имена, которые появляются в список-выражений или список-инициализации, вычисляются в области видимости конструктора:

class X
{
    int a, b, i, j;
public:
    const int& r;
    X(int i)
      : r(a) // initializes X::r to refer to X::a
      , b{i} // initializes X::b to the value of the parameter i
      , i(i) // initializes X::i to the value of the parameter i
      , j(this->i) // initializes X::j to the value of X::i
    {}
};

Исключения, которые генерируются инициализаторами членов, могут обрабатываться с помощью блока обработки исключений функции.

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

Для виртуальных вызовов (если прямые базовые классы инициализированы на этом этапе), применяются те же правила, что и для виртуальных вызовов из конструкторов и деструкторов: виртуальные члены функций ведут себя так, как будто динамический тип *this является статическим типом класса, который создается (динамическая диспетчеризация не распространяется по иерархии наследования), и виртуальные вызовы (но не статические вызовы) чистым виртуальным членам функций являются неопределённым поведением.

struct S
{
    int n = 42;   // default member initializer
    S() : n(7) {} // will set n to 7, not 42
};

Члены ссылок не могут быть связаны со временными объектами в списке инициализаторов членов:

struct A
{
    A() : v(42) {} // Error
    const int& v;
};

Примечание: то же самое относится к инициализатору члена по умолчанию.

class Foo
{
public: 
    Foo(char x, int y) {}
    Foo(int y) : Foo('a', y) {} // Foo(int) delegates to Foo(char, int)
};

Порядок инициализации

Порядок инициализаторов членов в списке не имеет значения: фактический порядок инициализации следующий:

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

Примечания

Пример

#include <fstream>
#include <string>
#include <mutex>
 
struct Base
{
    int n;
};   
 
struct Class : public Base
{
    unsigned char x;
    unsigned char y;
    std::mutex m;
    std::lock_guard<std::mutex> lg;
    std::fstream f;
    std::string s;
 
    Class(int x) : Base{123}, // initialize base class
        x(x),     // x (member) is initialized with x (parameter)
        y{0},     // y initialized to 0
        f{"test.cc", std::ios::app}, // this takes place after m and lg are initialized
        s(__func__), // __func__ is available because init-list is a part of constructor
        lg(m),    // lg uses m, which is already initialized
        m{}       // m is initialized before lg even though it appears last here
    {}            // empty compound statement
 
    Class(double a) : y(a + 1),
        x(y), // x will be initialized before y, its value here is indeterminate
        lg(m)
    {} // base class initializer does not appear in the list, it is
       // default-initialized (not the same as if Base() were used, which is value-init)
 
    Class()
    try // function-try block begins before the function body, which includes init list
      : Class(0.0) // delegate constructor
    {
        // ...
    }
    catch (...)
    {
        // exception occurred on initialization
    }
};
 
int main()
{
    Class c;
    Class c1(1);
    Class c2(0.1);
}

Отчеты об ошибках

Следующие отчеты об ошибках, изменяющие поведение, были применены ретроактивно к ранее опубликованным стандартам C++.

Ссылки

• Стандарт C++23 (ISO/IEC 14882:2023):
• 11.4.5 Конструкторы [class.ctor]
• 11.9.3 Инициализация базовых классов и членов [class.base.init]
• Стандарт C++20 (ISO/IEC 14882:2020):
• 11.4.4 Конструкторы [class.ctor]
• 11.10.2 Инициализация базовых классов и членов [class.base.init]
• Стандарт C++17 (ISO/IEC 14882:2017):
• 15.1 Конструкторы [class.ctor]
• 15.6.2 Инициализация базовых классов и членов [class.base.init]
• Стандарт C++14 (ISO/IEC 14882:2014):
• 12.1 Конструкторы [class.ctor]
• 12.6.2 Инициализация базовых классов и членов [class.base.init]
• Стандарт C++11 (ISO/IEC 14882:2011):
• 12.1 Конструкторы [class.ctor]
• 12.6.2 Инициализация базовых классов и членов [class.base.init]
• Стандарт C++98 (ISO/IEC 14882:1998):
• 12.1 Конструкторы [class.ctor]
• 12.6.2 Инициализация базовых классов и членов [class.base.init]

См. также

• исключение копирования
• конвертирующий конструктор
• копирующее присваивание
• копирующий конструктор
• конструктор по умолчанию
• деструктор
• explicit
• инициализация
  • инициализация агрегатов
  • инициализация констант
  • копирующая инициализация
  • инициализация по умолчанию
  • прямая инициализация
  • инициализация списком
  • инициализация ссылок
  • инициализация значением
  • инициализация нулём
• перемещающее присваивание
• перемещающий конструктор
• new