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

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

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

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

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

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

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

2. эффективность

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

1. инициализация нестатических членов данных const

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

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

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

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

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

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

то же самое с членами const или ссылочными членами, скажем, изначально 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;

1. и затем, наконец, деструктор " типа "вызывается для" 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. конструктор копирования класса "Type" вызывается для инициализации : variable(a). Аргументы в списке инициализаторов используются для прямого копирования конструкции "переменная".
   2. деструктор типа" Type "вызывается для" a", так как он выходит из области видимости.

синтаксис:

  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 и ссылочные переменные в классе

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

1. объекты-члены класса 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)

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

    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.

просто чтобы добавить дополнительную информацию, чтобы продемонстрировать, насколько сильно отличается список инициализации членов может mak. В запросе суммы диапазона leetcode 303-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 МС. На этом простом примере совершенно очевидно, что список инициализации членов более эффективным!--4-->. Все измерения от времени из ЛНР.

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