为什么要使用成员初始化列表?

为了 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(3)
{
}

这只会打电话 一 的 A(int) 而不是它的默认构造函数。在这个例子中,差异是可以忽略的,但是想象一下如果你愿意的话 一 的默认构造函数做了更多的工作,例如分配内存或打开文件。你不想不必要地那样做。

此外,如果类没有默认构造函数,或者 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;
};

除了上面提到的性能原因之外,如果类存储对作为构造函数参数传递的对象的引用,或者类具有常量变量,那么除了使用初始值设定项列表之外,您没有任何选择。

1. 基类的初始化

使用构造函数初始值设定项列表的一个重要原因是基类的初始化。

按照构造顺序,应该在子类之前构造基类。没有构造函数初始值设定项列表,如果您的基类具有默认构造函数,则可以在进入子类的构造函数之前调用该默认构造函数。

但是,如果您的基类只有参数化的构造函数,那么您必须使用构造函数初始值设定项列表来确保您的基类在子类之前被初始化。

2. 仅具有参数化构造函数的子对象的初始化

3. 效率

使用构造函数初始值设定项列表,可以将数据成员初始化为代码中所需的精确状态,而不是首先将其初始化为默认状态,然后将其状态更改为代码中所需的状态。

4. 初始化非静态常量数据成员

如果类中的非静态const数据成员具有默认构造函数,而您不使用构造函数初始值设定项列表,则无法将它们初始化为预期状态,因为它们将被初始化为默认状态。

5. 引用数据成员的初始化

当编译器输入构造函数时,必须初始化引用数据成员,因为引用不能稍后声明和初始化。这只能通过构造函数初始值设定项列表实现。

除了性能问题,还有另一个非常重要的问题,我称之为代码可维护性和可扩展性。

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

如果代码不是由“代码猴子”编写的,而是由一名工程师基于对他正在做的事情的深入考虑做出决定,那么维护就容易得多,也不容易出错,这不是一个秘密。

在运行构造函数主体之前,将调用其父类的所有构造函数,然后调用其字段的所有构造函数。默认情况下,将调用无参数构造函数。初始化列表允许您选择调用哪个构造函数以及构造函数接收哪些参数。

如果您有一个引用或常量字段,或者使用的某个类没有默认的构造函数,则必须使用初始化列表。

// 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.第2条。_156;type_157;的赋值运算符在myClass()构造函数的主体内调用以赋值

variable = a;

3. 最后,型的析构函数被称为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_157;类的复制构造函数来初始化:变量(A)。初始值设定项列表中的参数用于直接复制构造变量。
   2. _类型_157;的析构函数被称为__A_157;,因为它超出了范围。

Syntax:

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

在上述程序中,当执行class_s构造函数时, 萨姆克斯 和 萨姆西 被创建。然后在构造函数体中,定义这些成员数据变量。

用例:

1. 类中的常量和引用变量

在C中,变量 必须 在创建期间定义。同样的方式,在C++中,我们必须使用初始化列表在对象创建过程中初始化const和参考变量。如果我们在对象创建之后(在构造函数体内部)进行初始化,就会得到编译时错误。

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. 类构造函数的参数名与类的数据成员相同:

    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.

只需添加一些附加信息来演示成员初始化列表可以产生多大的差异 . 在leetcode 303范围和查询中-不可变, https://leetcode.com/problems/range-sum-query-immutable/ ,需要构造一个具有特定大小的向量并将其初始化为零。下面是两种不同的实现和速度比较。

没有成员初始化 清单,我花了大约 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];
}
};

现在 使用成员初始化列表 是时候换气了 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];
}
};