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

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

Используете ли вы списки инициализации членов в ваших конструкторах? Если так, то почему? Если нет, то почему нет?

Для учеников POD это не имеет значения, это просто вопрос стиля. Для членов класса, которые являются классами, тогда он избегает ненужного вызова конструктора по умолчанию. Рассматривать:

class A
{
public:
    A() { x = 0; }
    A(int x_) { x = x_; }
    int x;
};

class B
{
public:
    B()
    {
        a.x = 3;
    }
private:
    A a;
};

В этом случае конструктор для Bвызовет конструктор по умолчанию для A, а затем инициализируется a.xдо 3. Лучшим способом было бы для Bконструктора напрямую вызвать Aконструктор в списке инициализатора:

B()
  : a(3)
{
}

Это будет вызывать только A«s A(int)конструктор , а не его конструктор по умолчанию. В этом примере разница незначительна, но представьте, что Aконструктор по умолчанию сделал больше, например, выделил память или открыл файлы. Вы не хотели бы делать это без необходимости.

Кроме того, если у класса нет конструктора по умолчанию или у вас есть constпеременная-член, вы должны использовать список инициализаторов:

class A
{
public:
    A(int x_) { x = x_; }
    int x;
};

class B
{
public:
    B() : a(3), y(2)  // 'a' and 'y' MUST be initialized in an initializer list;
    {                 // it is an error not to do so
    }
private:
    A a;
    const int y;
};

Помимо упомянутых выше причин производительности, если ваш класс хранит ссылки на объекты, переданные в качестве параметров конструктора, или у вашего класса есть переменные 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. Конструктор типа сначала вызывается для «a».
2. Оператор присваивания «Type» вызывается внутри тела конструктора 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. Деструктор «Типа» называется «а», так как он выходит из области видимости.

Просто добавьте некоторую дополнительную информацию, чтобы продемонстрировать, какую разницу может составить список инициализации члена . В leetcode 303 Range Sum Query - Immutable, 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];
}
};

Синтаксис:

  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 = i} как локальная переменная в конструкторе Sample3 (), а переменная-член класса (i) получила переопределение. Чтобы избежать, мы должны использовать либо

  1. Initialization list 
  2. this operator.

Как объясняется в C ++ Core Guidelines C.49: предпочитайте инициализацию присваиванию в конструкторах, это предотвращает ненужные вызовы конструкторов по умолчанию.