构造函数中的初始化列表，以及构造函数和析构函数的调用顺序

新学到了C++里新的初始化方法，初始化列表。因此来整理一下。若有错漏，还望指摘。

构造函数

首先介绍一下构造函数，构造函数可分为普通构造函数和拷贝构造函数。

1. 普通构造函数

   构造函数就是在类实例化时，用来生成类的函数。若未定义，则系统自动生成。比如：

   class test{};
   test A;
   

   在生成对象A的时候就会调用普通构造函数。
   形式为函数名与类名相同，没有也不能声明任何类型的返回值。

2. 拷贝构造函数

   拷贝构造函数是在对类进行拷贝时，自动调用来根据已经实例化的对象来实例化一个新的对象的函数。若未定义则系统自动生成。
   比如：

   class test{};
   test A, B(A), C=A;
   

   在B和C构造的时候都会调用拷贝构造函数。
   此时值得注意的是，像实例C这样在最开始的声明中使用了赋值运算符进行拷贝的情况，虽然使用了赋值符号，但实际上调用的是拷贝构造函数，而不是重载的赋值运算符，而如下面的这种情况才会调用重载的赋值运算符：

   test A,C;
   C = A;
   

   （实际上也很好理解，第一种情况其实是在构造对象，第二种情况是构造好了之后的赋值，而赋值运算符并不是构造函数，所以在构造的时候虽然写的是赋值符号，但实际调用的是拷贝构造函数。）
   拷贝函数的形式是，函数名是类名，参数必须只有一个，是该类的引用或者指针，一般为该类的const引用，同样没有也不能声明任何类型的返回值。

初始化列表

构造过程其实分为初始化阶段与计算阶段。
对于类，可以用初始化列表来实现构造函数在初始化阶段直接赋初值。

class A{
public:
    A(int _x, int _y) : x(_x), y(_y) {}		//带初始化列表的普通构造函数
    A(const A& a) : x(a.x), y(a.y) {}		//拷贝构造函数
private:
    const int x, y;
};

初始化列表以冒号开始，形式为 变量名（初值），多个变量之间以逗号分隔。
初始化列表的用处在于，它可以对const修饰的常量进行初始化。而若写在大括号中，是在计算阶段赋值，而常量是不能在计算阶段进行赋值的。
初始化列表只能用于构造函数中，无论是普通构造函数还是拷贝构造函数。
成员变量中含有常量时，只能用初始化列表进行初始化。

析构函数

析构函数是在销毁对象时，系统会自动调用的函数。如果未定义，系统会自动生成。
形式为波浪线~加上类名，同样没有也不能声明任何类型的返回值。比如：

classs test{
    ~test(){}
};

调用顺序：

如下的代码：

#include <iostream>

static int n = 0;

// 父类
class base_class
{
public:
    base_class()
    {
        std::cout << "Base class" << std::endl;
    }
    virtual ~base_class()
    {
        std::cout << "Destruct base class" << std::endl;
    }

private:
    class base_mem_class
    {
    public:
        base_mem_class() : id_(++n)
        {
            std::cout << "Base member class" << id_ << std::endl;
        }
        ~base_mem_class()
        {
            std::cout << "Destruct base member class" << id_ << std::endl;
        }
    private:
        int id_;
    };
	// 两个成员变量
    base_mem_class a;
    base_mem_class b;
};

// 子类
class derived_class : public base_class
{
public:
    derived_class()
    {
        std::cout << "Derived class" << std::endl;
    }
    virtual ~derived_class()
    {
        std::cout << "Destruct derived class" << std::endl;
    }

private:
    class derived_mem_class
    {
    public:
        derived_mem_class() : id_(++n)
        {
            std::cout << "Derived member class" << id_ << std::endl;
        }
        ~derived_mem_class()
        {
            std::cout << "Destruct derived member class" << id_ << std::endl;
        }
    private:
        int id_;
    };
    // 两个成员变量
    derived_mem_class c;
    derived_mem_class d;
};

int main()
{
    derived_class* ptr = new derived_class;
    delete ptr;
    return 0;
}

执行结果如图：

可以看到，构造函数调用的原则：

• 先构造父类，再构造子类；
• 先构造成员变量，再构造自身；
• 构造成员变量时，按顺序构造。

而析构函数的调用顺序则和构造函数完全相反。

注：构造函数和析构函数只有用C++的new和delete才会被调用，如果用malloc和free，不会自动调用这两个函数