类与对象（中篇）

        1、类的6个默认成员函数

        如果一个类中什么成员都没有，简称为空类。

        空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

        默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

         2、构造函数---初始化

        2、1概念

        对于以下Date类：

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Init(2022, 7, 5);
	d1.Print();
	Date d2;
	d2.Init(2022, 7, 6);
	d2.Print();
	return 0;
}

        对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦/或者说容易忘记初始化，那能否在对象创建时，就将信息设置进去呢？

        构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，类似于Init，并且在对象整个生命周期内只调用一次。

        2、2特性

        构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

        2、2、1. 函数名与类名相同。

        2、2、2. 无返回值。（不是void，就是不需要写）

        2、2、3. 对象实例化时编译器自动调用对应的构造函数。如果没有对应的构造函数，会报错。即必须得有构造函数。

        2、2、4. 构造函数可以重载。

        2、2、5、可以无参，也可以带参。如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明。

class Date
{
public:
    // 1.无参构造函数
    Date()
    {
        _year = 2024;
        _month = 2;
        _day = 24;
    }

    // 2.带参构造函数，同时也构成重载
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};

void TestDate()
{
    Date d1; // 调用无参构造函数
    Date d2(2015, 1, 1); // 调用带参的构造函数

    // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
    
    // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
    // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
    Date d3();
}

        上面这个构造函数不太好看，我们可以使用全缺省，来达到比较正规的构造函数。

class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};

void TestDate()
{
    Date d1;
    Date d2(2015, 3, 4); 
}

        注意，一般不将全缺省和无参的构造函数一起出现，否则调用的时候都是Date d1;会构成歧义，不知道在调用什么。

         2、2、6注意：如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义构造函数编译器将不再生成。

class Date
{
public:
    /*
    // 如果用户显式定义了构造函数，编译器将不再生成
    Date(int year, int month, int day)
    {
    _year = year;
    _month = month;
    _day = day;
    }
    */

    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    // 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数
    // 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成
    // 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
    Date d1;
    return 0;
}

        其实，如果我们没有写构造函数，实例化对象的时候，是没有初始化成员变量的！

        虽然是有默认构造函数的，但是祖师爷可能当时喝了点小酒，并没有初始化。

        这里需要讲到一点东西：

        内置类型/基本类型 ： int char double 指针等等

        自定义类型：struct  class  union ....

        2、2、7C++规定，默认生成的构造函数，内置类型不做处理，只对自定义类型作处理，自定义类型去调用它自己的构造函数。

class A
{
public:
    A()
    {
        cout << "A()" << endl;
    }
private:
    int _a;
};
class Date
{
public:
    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

private:
    int _year ;
    int _month ;
    int _day ;
    A _aa;
};
int main()
{
    Date d1;
    return 0;
}

        这里会调用A的构造函数，输出"A()" 。

       2、2、8 C++11委员会对这种情况打了个补丁，在声明的位置给缺省值。

private:
    //这里也是声明，并不是定义，只是给了缺省值
    int _year = 1;
    int _month = 1;
    int _day = 1;
};

        如果不写构造函数，那么内置类型的成员变量就是缺省值。如果给了构造函数，还是调用构造函数。 

        所以，一般我们都自己写构造函数，不要依赖编译器，绝大多数场景下面都需要自己实现构造函数。

        2、2、9真正的默认构造函数

        .无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。 注意：无参构造函数、全缺省构造函数、我们没写