C++类成员的列表初始化的必要性及效率提升

在使用C++编程的过程当中，常常需要对类成员进行初始化，通常的方法有两种：

第一种方法：

CMYClass::CSomeClass()
{
    x=0;
    y=1;
}

第二种方法：

CSomeClass::CSomeClass() : x(0), y(1)
{
}

本文将要探讨这两种方法的异同以及如何使用这两种方法。

    从技术上说，第二种方法比较好，但是在大多数情况下，两者实际上没有什么区别。第二种语法被称为成员初始化列表，之所以要使用这种语法有两个原因：一个原因是必须这么做，另一个原因是出于效率考虑。

    让我们先看一下第一个原因——必要性。设想你有一个类成员，它本身是一个类或者结构，而且只有一个带一个参数的构造函数。

class CMember {
public:
    CMember(int x) { ... }
};

    因为CMember有一个显式声明的构造函数，编译器不产生一个缺省构造函数（不带参数），所以没有一个整数就无法创建CMember的一个实例。

CMember* pm = new CMember;        // 出错!!
CMember* pm = new CMember(2);     // OK

    如果CMember是另一个类的成员，你怎样初始化它呢？答案是你必须使用成员初始化列表。

class CMyClass {
    CMember m_member;
public:
    CMyClass();
};
// 必须使用初始化列表来初始化成员 m_member
CMyClass::CMyClass() : m_member(2)

{
•••
}

    没有其它办法将参数传递给m_member，如果成员是一个常量对象或者引用也是一样。根据C++的规则，常量对象和引用不能被赋值，它们只能被初始化。

    使用初始化列表的第二个原因是出于效率考虑，当成员类具有一个缺省的构造函数和一个赋值操作符时。MFC的CString提供了一个完美的例子。假定你有一个类CMyClass具有一个CString类型的成员m_str，你想把它初始化为"Hi,how are you."。你有两种选择：

CMyClass::CMyClass() {
// 使用赋值操作符
// CString::operator=(LPCTSTR);
m_str = _T("Hi,how are you.");
}

// 使用初始化列表
// 和构造函数 CString::CString(LPCTSTR)
CMyClass::CMyClass() : m_str(_T("Hi,how are you."))
{
}

    在它们之间有什么不同吗？是的。编译器总是确保所有成员对象在构造函数体执行之前被初始化，因此在第一个例子中编译的代码将调用CString::Cstring来初始化m_str，这在控制到达赋值语句前完成。在第二个例子中编译器产生一个对CString:: CString(LPCTSTR)的调用并将"Hi,how are you."传递给这个函数。结果是在第一个例子中调用了两个CString函数（构造函数和赋值操作符），而在第二个例子中只调用了一个函数。

    在CString的例子里这是无所谓的，因为缺省构造函数是内联的，CString只是在需要时为字符串分配内存（即，当你实际赋值时）。但是，一般而言，重复的函数调用是浪费资源的，尤其是当构造函数和赋值操作符分配内存的时候。在一些大的类里面，你可能拥有一个构造函数和一个赋值操作符都要调用同一个负责分配大量内存空间的Init函数。在这种情况下，你必须使用初始化列表，以避免不要的分配两次内存。

    在内建类型如ints或者longs或者其它没有构造函数的类型下，在初始化列表和在构造函数体内赋值这两种方法没有性能上的差别。不管用那一种方法，都只会有一次赋值发生。有些程序员说你应该总是用初始化列表以保持良好习惯，但我从没有发现根据需要在这两种方法之间转换有什么困难。在编程风格上，我倾向于在主体中使用赋值，因为有更多的空间用来格式化和添加注释，你可以写出这样的语句：

x=y=z=0;

或者

memset(this,0,sizeof(this));

注意第二个片断绝对是非面向对象的。

    当我考虑初始化列表的问题时，有一个奇怪的特性我应该警告你，它是关于C++初始化类成员的，它们是按照声明的顺序初始化的，而不是按照出现在初始化列表中的顺序。

class CMyClass {
    CMyClass(int x, int y);
    int m_x;
    int m_y;
};
CMyClass::CMyClass(int i) : m_y(i), m_x(m_y)
{
}

    你可能以为上面的代码将会首先做m_y=i，然后做m_x=m_y，最后它们有相同的值。但是编译器先初始化m_x，然后是m_y,，因为它们是按这样的顺序声明的。结果是m_x将有一个不可预测的值。这个例子是故意这样设计来说明这一点的，然而这种bug会很自然地出现。有两种方法避免它，一个是总是按照你希望它们被初始化的顺序来声明成员，第二个是，如果你决定使用初始化列表，总是按照它们声明的顺序罗列这些成员。这将有助于消除混淆。

 

类对象的构造顺序是这样的：
1.分配内存，调用构造函数时，隐式／显示的初始化各数据成员
2.进入构造函数后在构造函数中执行一般计算

使用初始化列表有两个原因：

1.必须这样做：

   《C++ Primer》中提到在以下三种情况下需要使用初始化成员列表：

一、需要初始化的数据成员是对象的情况；
二、需要初始化const修饰的类成员；
三、需要初始化引用成员数据；

        如果我们有一个类成员，它本身是一个类或者是一个结构，而且这个成员它只有一个带参数的构造函数，而没有默认构造函数，这时要对这个类成员进行初始化，就必须调用这个类成员的带参数的构造函数，如果没有初始化列表，那么他将无法完成第一步，就会报错。
 

class ABC
...{
public:
         ABC(int x,int y,int z);
private:
         int a;
         int b;
         int c;
};
class MyClass
...{
public:
        MyClass():abc(1,2,3)...{}
private:
        ABC abc;
};

        因为ABC有了显示的带参数的构造函数，那么他是无法依靠编译器生成无参构造函数的，所以没有三个int型数据，就无法创建ABC的对象。
        ABC类对象是MyClass的成员，想要初始化这个对象abc，那就只能用成员初始化列表，没有其他办法将参数传递给ABC类构造函数。
        另一种情况是这样的：当类成员中含有一个const对象时，或者是一个引用时，他们也必须要通过成员初始化列表进行初始化，因为这两种对象要在声明后马上初始化，而在构造函数中，做的是对他们的赋值，这样是不被允许的。

2.效率要求这样做：
       类对象的构造顺序显示，进入构造函数体后，进行的是计算，是对他们的赋值操作，显然，赋值和初始化是不同的，这样就体现出了效率差异，如果不用成员初始化类表，那么类对自己的类成员分别进行的是一次隐式的默认构造函数的调用，和一次复制操作符的调用，如果是类对象，这样做效率就得不到保障。

注意：构造函数需要初始化的数据成员，不论是否显示的出现在构造函数的成员初始化列表中，都会在该处完成初始化，并且初始化的顺序和其在声明时的顺序是一致的，与列表的先后顺序无关，所以要特别注意，保证两者顺序一致才能真正保证其效率。

为了说明清楚，假设有这样一个类：

class foo{
   private :
    int a, b;
};

1、foo(){}和foo(int i = 0){}都被认为是默认构造函数，因为后者是默认参数。两者不能同时出现。
2、构造函数列表的初始化方式不是按照列表的的顺序，而是按照变量声明的顺序。比如foo里面，a在b之前，那么会先构造a再构造b。所以无论 foo():a(b + 1), b(2){}还是foo():b(2),a(b+1){}都不会让a得到期望的值。如果先声明b再声明a则会更好。
3、构造函数列表能够对const成员初始化。比如foo里面有一个int const c;则foo(int x) : c(x){}可以让c值赋成x。不过需要注意的是，c必须在每个构造函数（如果有多个）都有值。
4、在继承里面，只有初始化列表可以构造父类的private成员。比如说
class child : public foo{
}
foo里面的构造函数是这样写的:foo (int x) { a = x; }.
而在child里面写child(int x){ foo(x); }是通过不了编译的。只有把父类初始化改为foo(int x) : a(x){}而子类构造写作child (int x) : foo(x){}才可以。

另一篇关于初始化列表的文章：

C++初始化类的成员，不但可以用构造函数（constructor）完成，而且可以用初始化类成员列表来完成。MFC大量用到此方法。例如有些初学者可能不大理解如下代码：

class A
{
public:
    int member_var; //成员变量
    A();            //构造函数
}
A::A():member_var(0)
{
}

他们觉得这个构造函数的定义应该只能这样写：

A::A()
{
   member_var=1;
}

其实两种方法都可。但是有些情况下，只能用第一种，而且通常情况下用第一种也会效率高些。

其实，第一种方法是真正的初始化(initialization),而在构造函数内实现的“=”操作其实是赋值(assign)。这两种方法的一切区别从这儿开始。区别大概如下：

我们知道普通变量编译器都会默认的替你初始化。他们既能初始化，也能被赋值的，而常量(const)按照其意思只能被初始化，不能赋值。否则与变量就无区别了。所以常量成员(const member)只能用成员初始化列表来完成他们的“初始化”，而不能在构造函数内为他们“赋值”。 
我们知道类的对象的初始化其实就是调用他的构造函数完成，如果没有写构造函数，编译器会为你默认生成一个。如果你自定义了带参数的构造函数，那么编译器将不生成默认构造函数。这样这个类的对象的初始化必须有参数。如果这样的类的对象来做另外某个类的成员，那么为了初始化这个成员，你必须为这个类的对象的构造函数传递一个参数。同样，如果你在包含它的这个类的构造函数里用“=”，其实是为这个对象“赋值”而非“初始化”它。所以一个类里的所有构造函数都是有参数的，那么这样的类如果做为别的类的成员变量，你必须显式的初始化它，你也是只能通过成员初始化列表来完成初始化。例如： 

class B
{
......
}

class A
{
public:
B member_b;
A();
}
A::A():B(...) //你必须显式初始化它，因为他的所有构造函数
              //都是有参数的，之后才能被赋值。
{
B=...； //因为如上所写，已经初始化了，才能被赋值，否则错误。
}

 

——————————————————————————————————————

初始化顺序：

class test 
{

       const int a;

       std:string str;

       object o;

       test():str(“df”),o(null),a(0)

{

}    

};

 

黄色的既是初始化列表，他们会在构造函数正式调用前被调用，且他们的初始化顺序并不是根据 初始化列表中出现的顺序，而是他们声明的顺序来初始化。如上：

初始化顺序是：a, str, o;

一般用于初始化 常量类型，静态类型的数据，或者不能独立存在的数据