252

我偏爱在我的构造函数中使用成员初始化列表......但我早就忘记了这背后的原因......

您在构造函数中使用成员初始化列表吗？如果是这样，为什么？如果不是，为什么不呢？

4

9 回答 9

302

对于POD类成员来说，这没有什么区别，只是风格问题。对于作为类的类成员，它避免了对默认构造函数的不必要调用。考虑：

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

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

在这种情况下， for 的构造函数B会调用 的默认构造函数A，然后初始化a.x为 3。更好的方法是让B的构造函数直接A在初始化列表中调用 的构造函数：

B()
  : a(3)
{
}

这只会调用A' 的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;
};
于 2009-05-29T16:03:53.937 回答
46

除了上面提到的性能原因之外，如果您的类存储对作为构造函数参数传递的对象的引用，或者您的类具有 const 变量，那么除了使用初始化列表之外，您别无选择。

于 2009-05-29T16:05:15.107 回答
26
  1. 基类的初始化

使用此处答案中未提及的构造函数初始化器列表的一个重要原因是基类的初始化。

按照构建顺序，基类应该在子类之前构建。如果没有构造函数初始化程序列表，如果您的基类具有默认构造函数，它将在进入子类的构造函数之前被调用，则这是可能的。

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

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

  2. 效率

使用构造函数初始化器列表，您可以将数据成员初始化为代码中所需的确切状态，而不是首先将它们初始化为默认状态，然后将它们的状态更改为代码中所需的状态。

  1. 初始化非静态 const 数据成员

如果您的类中的非静态 const 数据成员具有默认构造函数并且您不使用构造函数初始化程序列表，则您将无法将它们初始化为预期状态，因为它们将被初始化为其默认状态。

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

当编译器进入构造函数时，引用数据成员必须初始化，因为引用不能在以后声明和初始化。这只有在构造函数初始化列表中才有可能。

于 2016-12-02T02:51:02.690 回答
11

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

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

如果代码不是由“代码猴子”编写，而是由工程师根据对自己正在做的事情进行更深入的考虑做出决定，那么维护会容易得多且不易出错，这已经不是什么秘密了。

于 2009-08-21T11:15:58.370 回答
5

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

如果您有引用或 const 字段，或者使用的类之一没有默认构造函数，则必须使用初始化列表。

于 2011-06-10T06:41:01.377 回答
4 
// 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. Type的构造函数首先为“<code>a”调用。
  2. “<code>Type”的赋值运算符在构造函数体内被调用MyClass()进行赋值。
variable = a;
  1. 最后“<code>Type”的析构函数被“<code>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. 调用“<code>Type”类的复制构造函数来初始化 : variable(a)。初始化列表中的参数用于直接复制构造“<code>variable”。

  2. 为“<code>a”调用“<code>Type”的析构函数，因为它超出了范围。

于 2015-11-25T02:49:57.617 回答
1

句法：

  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. 类中的常量和引用变量

在 C 中，必须在创建期间定义变量。与 C++ 中的相同方式，我们必须在对象创建期间使用初始化列表来初始化 Const 和 Reference 变量。如果我们在对象创建后进行初始化（在构造函数体内部），我们将得到编译时错误。

  1. 没有默认构造函数的 Sample1（基）类的成员对象

     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.
于 2017-07-28T12:39:24.853 回答
1

只是为了添加一些额外的信息来演示成员初始化列表可以产生多大的差异。在 leetcode 303 Range Sum Query - Immutable, https://leetcode.com/problems/range-sum-query-immutable/中，您需要构造一个具有一定大小的向量并将其初始化为零。这是两种不同的实现和速度比较。

如果没有成员初始化列表，要获得 AC，我花了大约212 ms。

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 ms。通过这个简单的例子，很明显，成员初始化列表更有效。所有测量均来自 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];
}
};
于 2018-09-03T19:17:13.953 回答
1

正如 C++ 核心指南C.49：在构造函数中优先初始化而不是赋值中所解释的那样， 它可以防止对默认构造函数的不必要调用。

于 2020-06-12T13:15:05.980 回答