Constructors and member initializer lists

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

Синтаксис

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

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

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

• В объявлении friend , выражение-идентификатор является квалифицированным идентификатором , который именует конструктор .
• В противном случае, в объявлении члена, принадлежащем спецификации членов класса или шаблона класса:

• Для классов выражение-идентификатор представляет собой injected-class-name непосредственно охватывающего класса.
• Для шаблонов классов выражение-идентификатор представляет собой имя класса, которое обозначает current instantiation (до C++20) injected-class-name (начиная с C++20) непосредственно охватывающего шаблона класса.

• В противном случае, идентификаторное выражение является квалифицированным идентификатором, терминальный неквалифицированный идентификатор которого представляет собой injected-class-name своего контекста поиска .

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

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

struct S
{
    int n;
    S(int);       // объявление конструктора
    S() : n(7) {} // определение конструктора:
                  // ": n(7)" - это список инициализации
                  // ": n(7) {}" - это тело функции
};
S::S(int x) : n{x} {} // определение конструктора: ": n{x}" - это список инициализации
int main()
{
    S s;      // вызывает S::S()
    S s2(10); // вызывает S::S(int)
}

Объяснение

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

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

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

Имена, которые появляются в initializer , вычисляются в области видимости конструктора:

class X
{
    int a, b, i, j;
public:
    const int& r;
    X(int i)
      : r(a) // инициализирует X::r для ссылки на X::a
      , b{i} // инициализирует X::b значением параметра i
      , i(i) // инициализирует X::i значением параметра i
      , j(this->i) // инициализирует X::j значением 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) {} // Ошибка
    const int& v;
};

Примечание: то же самое относится к default member initializer .

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

Функции-члены (включая виртуальные функции-члены ) могут быть вызваны для объекта в процессе конструирования или разрушения. Аналогично, объект в процессе конструирования или разрушения может быть операндом 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}, // инициализация базового класса
        x(x),     // x (член) инициализируется значением x (параметр)
        y{0},     // y инициализируется значением 0
        f{"test.cc", std::ios::app}, // это происходит после инициализации m и lg
        s(__func__), // __func__ доступен, так как список инициализации является частью конструктора
        lg(m),    // lg использует m, который уже инициализирован
        m{}       // m инициализируется до lg, даже если он указан последним здесь
    {}            // пустой составной оператор
    Class(double a) : y(a + 1),
        x(y), // x будет инициализирован до y, его значение здесь неопределено
        lg(m)
    {} // инициализатор базового класса отсутствует в списке, он
       // инициализируется по умолчанию (не то же самое, что если бы использовался Base(), что является value-init)
    Class()
    try // блок function try начинается до тела функции, которое включает список инициализации
      : Class(0.0) // делегирующий конструктор
    {
        // ...
    }
    catch (...)
    {
        // исключение произошло при инициализации
    }
};
int main()
{
    Class c;
    Class c1(1);
    Class c2(0.1);
}

Отчеты о дефектах

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

Ссылки

Смотрите также

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