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

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

Синтаксис

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

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

Идентификаторное выражение class-name должно иметь одну из следующих форм:

• В объявлении друга идентификаторное выражение является квалифицированным идентификатором, который обозначает конструктор.
• В противном случае, в объявлении члена, принадлежащем спецификации членов класса или шаблона класса:
• Для классов идентификаторное выражение является внедрённым именем класса непосредственно охватывающего класса.
• Для шаблонов классов идентификаторное выражение является именем класса, обозначающим текущую специализацию(до C++20)внедрённым именем класса(начиная с C++20) непосредственно охватывающего шаблона класса.
• В противном случае идентификаторное выражение является квалифицированным идентификатором, конечный неквалифицированный идентификатор которого представляет собой внедрённое имя класса в контексте его поиска.

Список инициализации членов

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

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 делают свой тип литеральным типом. Конструкторы, которые можно вызвать без аргументов, являются конструкторами по умолчанию. Конструкторы, принимающие в качестве аргумента другой объект того же типа, являются конструкторами копирования и конструкторами перемещения.

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

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

Имена, встречающиеся в expression-list или braced-init-list, вычисляются в области видимости конструктора:

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

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

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

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

Операции во время конструирования и разрушения

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

Однако если эти операции выполняются при любом из следующих вычислений, поведение не определено:

• вычисление списка инициализации членов до завершения обработки всех элементов member-initializer для базовых классов

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:2024):
• 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