成员初始化列表细说

一：何时必须使用初始化列表

#include <iostream>
using namespace std;

class Base
{
public:
    Base(int i)
    {
        cout<<"调用了Base(int i)"<<endl;
    }
    ~Base()
    {
        cout<<"调用了~Base()"<<endl;
    }
};

class X
{
public:
    X(int i)
    {
        cout<<"调用了X(int i)"<<endl;     
    }
    ~X()
    {
        cout<<"调用了~X()"<<endl;
    }
};

class A:public Base
{
public:
    const int m_i;
    int &b; 
    X x;
public:
    A(int i=0):m_i(i),b(i),Base(i),x(10) //必须用初始化列表的方式初始化这4中类型
    {
        cout<<"调用了 A(int i=0):m_i(i),b(i),Base(i),x(10)"<<endl; 
    }
    ~A()
    {
        cout<<"调用了 ~A()"<<endl; 
    }
};


int main(void)
{
    A obj(10);
    return 0;
}
//总结：必须用初始化列表的4种情形
/*
 a:成员有引用
 b:成员是const类型
 c:类中的成员变量有类类型，并且这个类类型没有默认构造函数(也就是它的构造函数是带有参数的)
 d:类继承了某个类，并且这个类(父类)的构造函数是带参数的
 */

二：使用初始化列表的优势

除了上述的必须使用初始化列表的情形的化，其它情况下使用初始化列表的方式主要是为了提高程序的运行效率，，通过一个例子来看看使用初始化列表和不使用初始化列表的情况吧。

#include <iostream>
#include<stdio.h>
using namespace std;

class X
{
public:
    X(int i=0):m_i(i)
    {
        printf("this = %p",this);
        cout<<"调用了X(int i=0):m_i(i)"<<endl;
    }
    ~X()
    {
        printf("this = %p",this);
        cout<<"调用了 ~X()"<<endl;
    }

    X(const X& p)
    {
        printf("this = %p",this); 
        cout<<"调用了  X(const X& p)"<<endl;
    }

    X& operator=(const X&)
    {
        printf("this = %p",this); 
        cout<<"调用了X& operator=(const X&)"<<endl;
    }
public:
    int m_i;
};

class T
{
public:
    X obj;
    int m_i;
public:
    T(int tmpobj)
    {
        obj=100;
        m_i=10;
        cout<<"调用了T(int tmpobj)"<<endl;  
    }

    ~T()
    {
      cout<<"调用了 ~T()"<<endl;  
    }
};

int main(void)
{
    T(90);
    return 0;
}

执行结果：

再来看：

#include <iostream>
#include<stdio.h>
using namespace std;

class X
{
public:
    X(int i=0):m_i(i)
    {
        printf("this = %p",this);
        cout<<"调用了X(int i=0):m_i(i)"<<endl;
    }
    ~X()
    {
        printf("this = %p",this);
        cout<<"调用了 ~X()"<<endl;
    }

    X(const X& p)
    {
        printf("this = %p",this); 
        cout<<"调用了  X(const X& p)"<<endl;
    }

    X& operator=(const X&)
    {
        printf("this = %p",this); 
        cout<<"调用了X& operator=(const X&)"<<endl;
    }
public:
    int m_i;
};

class T
{
public:
    X obj;
    int m_i;
public:
    T(int tmpobj):obj(tmpobj)
    {
       // obj=100;
        m_i=10;
        cout<<"调用了T(int tmpobj)"<<endl;  
    }

    ~T()
    {
      cout<<"调用了 ~T()"<<endl;  
    }
};

int main(void)
{
    T(90);
    return 0;
}

发现少了一些步骤了吧？

由于在不使用初始化列表的情况下，编译器执行程序时，还会生成临时对象，，，，所以来说还是使用初始化列表有优势。

但是这种优势对于一般的内置类型，比如int等等就不太明显，对于类类型来说，明显可就大了。

三：成员初始化列表细节探秘