C++ 为什么我更喜欢使用成员初始化列表？

Question

提问by paxos1977

I'm partial to using member initialization lists with my constructors... but I've long since forgotten the reasons behind this...

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

Do you use member initialization lists in your constructors? If so, why? If not, why not?

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

Answer 1

回答by Adam Rosenfield

For PODclass members, it makes no difference, it's just a matter of style. For class members which are classes, then it avoids an unnecessary call to a default constructor. Consider:

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

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

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

In this case, the constructor for Bwill call the default constructor for A, and then initialize a.xto 3. A better way would be for B's constructor to directly call A's constructor in the initializer list:

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

B()
  : a(3)
{
}

This would only call A's A(int)constructor and not its default constructor. In this example, the difference is negligible, but imagine if you will that A's default constructor did more, such as allocating memory or opening files. You wouldn't want to do that unnecessarily.

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

Furthermore, if a class doesn't have a default constructor, or you have a constmember variable, you mustuse an initializer list:

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

Answer 2

回答by Naveen

Apart from the performance reasons mentioned above, if your class stores references to objects passed as constructor parameters or your class has const variables then you don't have any choice except using initializer lists.

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

Answer 3

回答by yuvi

Initialization of base class

基类的初始化

One important reason for using constructor initializer list which is not mentioned in answers here is initialization of base class.

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

As per the order of construction, base class should be constructed before child class. Without constructor initializer list, this is possible if your base class has default constructor which will be called just before entering the constructor of child class.

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

But, if your base class has only parameterized constructor, then you must use constructor initializer list to ensure that your base class is initialized before child class.

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

Initialization of Subobjects which only have parameterized constructors
Efficiency

初始化只有参数化构造函数的子对象
效率

Using constructor initializer list, you initialize your data members to exact state which you need in your code rather than first initializing them to their default state & then changing their state to the one you need in your code.

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

Initializing non-static const data members

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

If non-static const data members in your class have default constructors & you don't use constructor initializer list, you won't be able to initialize them to intended state as they will be initialized to their default state.

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

Initialization of reference data members

引用数据成员的初始化

Reference data members must be intialized when compiler enters constructor as references can't be just declared & initialized later. This is possible only with constructor initializer list.

当编译器进入构造函数时，必须初始化引用数据成员，因为引用不能稍后声明和初始化。这仅适用于构造函数初始值设定项列表。

Answer 4

回答by mloskot

Next to the performance issues, there is another one very important which I'd call code maintainability and extendibility.

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

If a T is POD and you start preferring initialization list, then if one time T will change to a non-POD type, you won't need to change anything around initialization to avoid unnecessary constructor calls because it is already optimised.

如果 T 是 POD 并且您开始更喜欢初始化列表，那么如果一次 T 将更改为非 POD 类型，则您无需更改初始化周围的任何内容以避免不必要的构造函数调用，因为它已经优化。

If type T does have default constructor and one or more user-defined constructors and one time you decide to remove or hide the default one, then if initialization list was used, you don't need to update code if your user-defined constructors because they are already correctly implemented.

如果类型 T 确实有默认构造函数和一个或多个用户定义的构造函数，并且有一次您决定删除或隐藏默认的构造函数，那么如果使用了初始化列表，那么您不需要更新用户定义的构造函数的代码，因为它们已经正确实施。

Same with const members or reference members, let's say initially T is defined as follows:

与 const 成员或引用成员相同，假设最初 T 定义如下：

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

Next, you decide to qualify a as const, if you would use initialization list from the beginning, then this was a single line change, but having the T defined as above, it also requires to dig the constructor definition to remove assignment:

接下来，您决定将 a 限定为 const，如果您从一开始就使用初始化列表，那么这是单行更改，但是具有如上定义的 T，它还需要挖掘构造函数定义以删除赋值：

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

It's not a secret that maintenance is far easier and less error-prone if code was written not by a "code monkey" but by an engineer who makes decisions based on deeper consideration about what he is doing.

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

Answer 5

回答by Jamal Zafar

Before the body of the constructor is run, all of the constructors for its parent class and then for its fields are invoked. By default, the no-argument constructors are invoked. Initialization lists allow you to choose which constructor is called and what arguments that constructor receives.

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

If you have a reference or a const field, or if one of the classes used does not have a default constructor, you must use an initialization list.

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

Answer 6

回答by Rahul Singh

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

Here compiler follows following steps to create an object of type MyClass
1. Type's constructor is called first for “a”.
2. The assignment operator of “Type” is called inside body of MyClass() constructor to assign

这里编译器按照以下步骤创建一个类型为 MyClass
1的对象。首先为“a”调用类型的构造函数。
2. Type 的赋值运算符在 MyClass() 构造函数体内调用来赋值

variable = a;

And then finally destructor of “Type” is called for “a” since it goes out of scope.
Now consider the same code with MyClass() constructor with Initializer List
```
// 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
}
};
```
With the Initializer List, following steps are followed by compiler:
1. Copy constructor of “Type” class is called to initialize : variable(a). The arguments in initializer list are used to copy construct “variable” directly.
2. Destructor of “Type” is called for “a” since it goes out of scope.

然后最后“类型”的析构函数被称为“a”，因为它超出了范围。
现在考虑使用 MyClass() 构造函数和 Initializer List 相同的代码
```
// 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
}
};
```
使用 Initializer List，编译器遵循以下步骤：
1. 调用“Type”类的复制构造函数来初始化：variable(a)。初始化列表中的参数用于直接复制构造“变量”。
2. “类型”的析构函数被称为“a”，因为它超出了范围。

Answer 7

回答by Yi Wang

Just to add some additional info to demonstrate how much difference the member initialization list can mak. In the leetcode 303 Range Sum Query - Immutable, https://leetcode.com/problems/range-sum-query-immutable/, where you need to construct and initialize to zero a vector with certain size. Here is two different implementation and speed comparison.

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

Without member initializationlist, to get AC it cost me about 212 ms.

没有成员初始化列表，要获得 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];
}
};

Now using member initialization list, the time to get AC is about 108 ms. With this simple example, it is quite obvious that, member initialization list is way more efficient. All the measurement is from the running time from LC.

现在使用成员初始化列表，获取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];
}
};

Answer 8

回答by Eswaran Pandi

Syntax:

句法：

  class Sample
  {
     public:
         int Sam_x;
         int Sam_y;

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

Need of Initialization list:

需要初始化列表：

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

in the above program, When the class's constructor is executed, Sam_xand Sam_yare created. Then in constructor body, those member data variables are defined.

在上面的程序中，当执行类的构造函数时，会创建Sam_x和Sam_y。然后在构造函数体中，定义那些成员数据变量。

Use cases:

用例：

Const and Reference variables in a Class

类中的常量和引用变量

In C, variables mustbe defined during creation. the same way in C++, we must initialize the Const and Reference variable during object creation by using Initialization list. if we do initialization after object creation (Inside constructor body), we will get compile time error.

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

Member objects of Sample1 (base) class which do not have default constructor

 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 */
  {

  }
 };

没有默认构造函数的 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 */
  {

  }
 };

While creating object for derived class which will internally calls derived class constructor and calls base class constructor (default). if base class does not have default constructor, user will get compile time error. To avoid, we must have either

在为派生类创建对象时，它将在内部调用派生类构造函数并调用基类构造函数（默认）。如果基类没有默认构造函数，用户将收到编译时错误。为了避免，我们必须有

 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)

Class constructor's parameter name and Data member of a Class are same:

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

类构造函数的参数名和类的数据成员相同：

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

As we all know, local variable having highest priority then global variable if both variables are having same name. In this case, the program consider "i" value {both left and right side variable. i.e: i = i} as local variable in Sample3() constructor and Class member variable(i) got override. To avoid, we must use either

众所周知，如果两个变量具有相同的名称，则局部变量的优先级高于全局变量。在这种情况下，程序会考虑“i”值{左右两侧变量。即： i = i} 作为 Sample3() 构造函数中的局部变量，并且类成员变量 (i) 被覆盖。为了避免，我们必须使用

  1. Initialization list 
  2. this operator.

C++ 为什么我更喜欢使用成员初始化列表？

提问by paxos1977

回答by Adam Rosenfield

回答by Naveen

回答by yuvi

回答by mloskot

回答by Jamal Zafar

回答by Rahul Singh

回答by Yi Wang

回答by Eswaran Pandi

相关推荐

最近更新

标签

C++ 为什么我更喜欢使用成员初始化列表？

提问by paxos1977

回答by Adam Rosenfield

回答by Naveen

回答by yuvi

回答by mloskot

回答by Jamal Zafar

回答by Rahul Singh

回答by Yi Wang

回答by Eswaran Pandi

相关推荐

C++ printf 和 %llu 与 OS X 上的 %lu

C++ __cxa_pure_virtual 的目的是什么？

如何在 C++ 中编写自定义输入流

如何使用 C/C++ 可视化字节

相关推荐

最近更新

标签