C++ 构造函数，析构函数

构造函数

构造函数是初始化C++对象的函数。构造函数名与类名相同。构造函数可以有参数，但不会返回值。

class Date {
    public:
        Date(int y, int m, int d) {
            year = y;
            month = m;
            day = d;
        }
    private:
        int year, month, day;
};

实例化

根据类来创建对象的过程叫做实例化，实例化会调用类的构造函数。声明类的对象，就像声明其他C++基本数据类型一样。当没有默认构造函数时，需要明确给出构造函数的参数。

Date birthday(2200, 1, 1);

默认构造函数

默认构造函数，即没有传入参数的构造函数。

当没有明确给出构造函数的参数时，实例化对象会调用类的默认构造函数。当声明一个对象数组时，由于没有给出参数，因此也会调用默认构造函数。若没有定义默认构造函数，上述操作则会引起编译错误no default constructor exists for class "XXXX"。

因此，我们通常都会给类定义一个默认构造函数。

class Date {
    public:
        Date() {  // Default constructor
            year = 1900;
            month = 1;
            day = 1;
        }
        Date(int y, int m, int d) {
            year = y;
            month = m;
            day = d;
        }
    private:
        int year, month, day;
};

当定义了一个所有参数都设置了默认值（缺省值）的构造函数时，可以看作是定义了一个默认构造函数。这时，不需要再单独定义默认构造函数。（推荐）

class Date {
    public:
        Date(int y=1900, int m=1, int d=1) {
            year = y;
            month = m;
            day = d;
        }
    private:
        int year, month, day;
};

以下语句会调用默认构造函数。

Date christmas;
Date dates[365];

错误的用法：

Date a();

这相当于是声明了一个没有传入参数，返回Date对象的函数a。

析构函数

析构函数是在对象被删除时调用的函数。若没有定义析构函数，编译器会自动合成一个析构函数。

当我们使用new或malloc在堆中为数据成员申请了一块内存时，则应该为类定义析构函数，保证在对象被删除时这些内存也随之释放（对应的delete和free）。

用~对象名表示析构函数。

class Date {
    public:
        Date(int y=1900, int m=1, int d=1) {
            year = new int(y);
            month = new int(m);
            day = new int(d);
        }
        ~Date() {  // Free heap's memery
            delete year;
            delete month;
            delete day;
        }
    private:
        int* year;
        int* month;
        int* day;
};

复制构造函数

复制构造函数是复制同类对象的函数。复制构造允许我们根据已有的对象创建新的对象。

以“值传递”的方式向函数传递对象时，就调用了它的复制构造函数，在函数作用域内创造了一个对象的拷贝。函数返回对象时，在函数作用域外复制构造出对象的拷贝，而函数作用域内的对象则被销毁。

没有定义复制构造函数时，编译器会自动合成一个复制构造函数，把源对象的数据成员值简单赋值给新对象。

当我们使用new或malloc在堆中为数据成员申请了一块内存，并且定义了释放这些内存的析构函数时，则应该为类定义复制构造函数，让对象的拷贝（以下简称“拷贝”）的数据成员指向这块内存的指针指向nullptr，使得拷贝被销毁时不会释放掉这块内存，从而保证原对象对这块内存的访问，保证这块内存只在原对象实例化（销毁）时被申请（释放）。

class Date {
    public:
        Date(int y=1900, int m=1, int d=1) {
            year = new int(y);
            month = new int(m);
            day = new int(d);
        }
        Date(const Date& origin) {  // Copy constructor
            year = nullptr;
            month = nullptr;
            day = nullptr;
        }
        ~Date() {  // Free heap's memery
            delete year;
            delete month;
            delete day;
        }
    private:
        int* year;
        int* month;
        int* day;
};

在上面的例子中，如果需要在拷贝中访问*year，*month和*day，可以在复制构造函数中另外开辟一块内存存放。

class Date {
    public:
        Date(int y=1900, int m=1, int d=1) {
            year = new int(y);
            month = new int(m);
            day = new int(d);
        }
        Date(const Date& origin) {  // Copy constructor
            year = new int(*(origin.year));
            month = new int(*(origin.month));
            day = new int(*(origin.day));
        }
        ~Date() {  // Free heap's memery
            delete year;
            delete month;
            delete day;
        }
    private:
        int* year;
        int* month;
        int* day;
};