Почему я предпочитаю использовать список инициализации членов?

Помимо упомянутых выше причин производительности, если ваш класс хранит ссылки на объекты, переданные в качестве параметров конструктора, или у вашего класса есть переменные const, у вас нет выбора, кроме как использовать списки инициализатора.

1. Инициализация базового класса

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

Согласно порядку построения, базовый класс должен быть создан до дочернего класса. Без списка инициализатора конструктора это возможно, если в вашем базовом классе есть конструктор по умолчанию, который будет вызываться непосредственно перед входом в конструктор дочернего класса.

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

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

3. КПД

Используя список инициализатора конструктора, вы инициализируете элементы данных в точном состоянии, которое вам нужно в вашем коде, а не инициализируете их в состояние по умолчанию. & затем измените их состояние на то, что вам нужно в вашем коде.

4. Инициализация нестатических элементов данных const

Если в вашем классе не статические члены-данные const, есть конструкторы по умолчанию & вы не используете список инициализатора конструктора, вы не сможете инициализировать их в заданное состояние, так как они будут инициализированы в состояние по умолчанию.

5. Инициализация элементов справочных данных

Члены ссылочных данных должны быть инициализированы, когда компилятор входит в конструктор, поскольку ссылки не могут быть просто объявлены & инициализируется позже. Это возможно только со списком инициализатора конструктора.

Помимо проблем с производительностью, есть еще одна очень важная, которую я бы назвал ремонтопригодностью и расширяемостью кода.

Если T является POD, и вы начинаете отдавать предпочтение списку инициализации, то, если один раз T изменится на тип не POD, вам не нужно будет ничего менять вокруг инициализации, чтобы избежать ненужных вызовов конструктора, потому что он уже оптимизирован.

Если тип T имеет конструктор по умолчанию и один или несколько определяемых пользователем конструкторов и один раз вы решаете удалить или скрыть конструктор по умолчанию, то, если использовался список инициализации, вам не нужно обновлять код, если ваши определяемые пользователем конструкторы, потому что они уже правильно реализованы.

То же самое с константными членами или ссылочными членами, скажем, изначально T определяется следующим образом:

struct T
{
T() { a = 5; }
private:
int a;
};

Затем вы решаете квалифицировать a как const, если вы будете использовать список инициализации с самого начала, тогда это было изменение одной строкой, но, имея T, как указано выше, также необходимо выкопать определение конструктора для удаления присваивания:

struct T
{
T() : a(5) {} // 2. that requires changes here too
private:
const int a; // 1. one line change
};

Не секрет, что обслуживание намного проще и менее подвержено ошибкам, если код был написан не «обезьяной кода», а инженером, который принимает решения, основываясь на более глубоком рассмотрении того, что он делает.

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

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

// Without Initializer List
class MyClass {
Type variable;
public:
MyClass(Type a) {  // Assume that Type is an already
// declared class and it has appropriate
// constructors and operators
variable = a;
}
};

Здесь компилятор выполняет следующие шаги для создания объекта типа MyClass
1. Конструктор типа сначала вызывается как «а».
2. Оператор присваивания «Тип» вызывается внутри тела конструктора MyClass () для назначения

variable = a;

3. И, наконец, деструктор типа «Type» вызывается как «a», поскольку он выходит из области видимости.

   Теперь рассмотрим тот же код с конструктором MyClass () со списком инициализаторов

   // With Initializer List
   class MyClass {
   Type variable;
   public:
   MyClass(Type a):variable(a) {   // Assume that Type is an already
   // declared class and it has appropriate
   // constructors and operators
   }
   };
   

   Со списком инициализатора, следующие шаги выполняются компилятором:

   1. Конструктор копирования класса «Тип» вызывается для инициализации: переменная (а). Аргументы в списке инициализатора используются для непосредственного копирования конструкции «переменная».
   2. Деструктор «Типа» называется «а», так как он выходит из области видимости.

Синтаксис:

  class Sample
{
public:
int Sam_x;
int Sam_y;

Sample(): Sam_x(1), Sam_y(2)     /* Classname: Initialization List */
{
// Constructor body
}
};

Нужен список инициализации:

 class Sample
{
public:
int Sam_x;
int Sam_y;

Sample()     */* Object and variables are created - i.e.:declaration of variables */*
{ // Constructor body starts

Sam_x = 1;      */* Defining a value to the variable */*
Sam_y = 2;

} // Constructor body ends
};

в приведенной выше программе, когда конструктор класса выполняется, Sam_x а также Sam_y созданы. Затем в теле конструктора определяются эти переменные данных-членов.

Случаи применения:

1. Переменные Const и Reference в классе

В C переменные должен быть определенным при создании. так же, как в C ++, мы должны инициализировать переменные Const и Reference во время создания объекта с помощью списка инициализации. если мы сделаем инициализацию после создания объекта (внутри тела конструктора), мы получим ошибку времени компиляции.

2. Объекты-члены класса Sample1 (base), которые не имеют конструктора по умолчанию

    class Sample1
   {
   int i;
   public:
   Sample1 (int temp)
   {
   i = temp;
   }
   };
   
   // Class Sample2 contains object of Sample1
   class Sample2
   {
   Sample1  a;
   public:
   Sample2 (int x): a(x)      /* Initializer list must be used */
   {
   
   }
   };
   

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

 1. Default constructor of Sample1 class
2. Initialization list in Sample2 class which will call the parametric constructor of Sample1 class (as per above program)

3. Имя параметра конструктора класса и член Data класса одинаковы:

    class Sample3 {
   int i;         /* Member variable name : i */
   public:
   Sample3 (int i)    /* Local variable name : i */
   {
   i = i;
   print(i);   /* Local variable: Prints the correct value which we passed in constructor */
   }
   int getI() const
   {
   print(i);    /*global variable: Garbage value is assigned to i. the expected value should be which we passed in constructor*/
   return i;
   }
   };
   

Как мы все знаем, локальная переменная имеет наивысший приоритет, чем глобальная переменная, если обе переменные имеют одинаковое имя. В этом случае программа учитывает значение «i» {как левую, так и правую переменную. i.e: i = i} как локальная переменная в конструкторе Sample3 (), а переменная-член класса (i) получила переопределение. Чтобы избежать, мы должны использовать либо

  1. Initialization list
2. this operator.

Просто добавьте некоторую дополнительную информацию, чтобы продемонстрировать, какую разницу может составить список инициализации члена. В leetcode 303 Range Sum Query — неизменный, https://leetcode.com/problems/range-sum-query-immutable/, где вам нужно построить и инициализировать, чтобы обнулить вектор с определенным размером. Вот две разные реализации и сравнение скорости.

Без инициализации члена список, чтобы получить AC это стоило мне около 212 мс.

class NumArray {
public:
vector<int> preSum;
NumArray(vector<int> nums) {
preSum = vector<int>(nums.size()+1, 0);
int ps = 0;
for (int i = 0; i < nums.size(); i++)
{
ps += nums[i];
preSum[i+1] = ps;
}
}

int sumRange(int i, int j) {
return preSum[j+1] - preSum[i];
}
};

Сейчас используя список инициализации члена, время, чтобы получить AC составляет около 108 мс. На этом простом примере совершенно очевидно, что список инициализации членов намного эффективнее. Все измерения от времени выполнения от LC.

class NumArray {
public:
vector<int> preSum;
NumArray(vector<int> nums) : preSum(nums.size()+1, 0) {
int ps = 0;
for (int i = 0; i < nums.size(); i++)
{
ps += nums[i];
preSum[i+1] = ps;
}
}

int sumRange(int i, int j) {
return preSum[j+1] - preSum[i];
}
};