在前面我们已经初步认识了C++类和对象，我们接下来继续了解了解类的六个默认成员函数

类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。
空类中真的什么都没有吗？
并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数，(我们不写，编译器会自己生产，我们写了，编译器就会自动生成；主要意思就是有些类，我们可以直接使用其默认成员函数，但是有些类我们需要自己去写)

构造函数

在之前我们创建类：

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(2002, 12, 11);
	d1.Print();
	Date d2;
	d2.Init(2002, 10, 21);
	d2.Print();
	return 0;
}

之前的Date类，我们通过Init函数调用来初始化对象，但是我们每次创建都需要调用去初始化，难免有些麻烦，我们试想能不能在创建的时候就直接初始化？

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

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

1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

我们来看看使用构造函数后的Date类：

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 d1(2002, 12, 11);
	d1.Print();
	Date d2(2002, 10, 21);
	d2.Print();
	return 0;
}

支持重载：

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

class Date
{
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d;
	d.Print();
	return 0;
}

运行结果：

很奇怪的打印了一堆数字，这是为什么？我们看第6点：

6. 关于编译器生成的默认成员函数，很多童鞋会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？
   解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char…，自定义类型就是我们使用class/struct/union等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认构造函数。
   
   整体意思就是：

比如：

（构造函数是否需要我们自己写：在于我们是否需要按照我们自己的意愿初始化，不能只看成员变量是内置类型还是自定义类型，如果系统自己生成的就够用那就不需要）

注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。

7. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。（不传参数的构造函数就叫默认构造）
   注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

上面两个构造函数我们随意选一个都能正常运行

析构函数

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。(与我们之前写的Destroy功能类似)

特性：

1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		//...
	}
	void Push(DataType data)
	{
		//...
	}
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};

（一般情况下，有资源需要释放比如malloc的变量等，需要我们自己写析构函数）

5. 编译器生成的默认析构函数，对自定义类型成员调用它的析构函数
6. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类

关于不同类的对象与对象析构函数释放顺序问题：

拷贝构造函数

在现实世界，可能存在一个跟自己差不多的人，我们称之为双胞胎

那在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

特征：
拷贝构造函数也是特殊的成员函数，其特征如下：

1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

为什么会无穷递归调用？


传值调用会产生形参，而产生的形参会调用这个形参的拷贝构造函数，然后拷贝构造函数又会产生形参

我们通过两个小函数来了解为什么形参会调用拷贝构造函数：

我们能够使用指针，但是指针不好，而且使用指针只能算构造函数不能算拷贝构造

3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

class Date
{
private:
	int _year = 1970;
	int _month = 1;
	int _day = 1;
};
int main()
{
	Date d1;
	Date d2(d1);
	return 0;
}

注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。

4. 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(DataType data)
	{
		_array[_size] = data;
		_size++;
	}
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};
int main()
{
	Stack st1;
	Stack st2(st1);
	return 0;
}

Stack类需要申请资源比如malloc等，如果直接使用默认的拷贝构造函数会发生什么呢？

我们发现这种浅拷贝申请资源的地方，地址是一样的，相当于不同的名字指向同一块地址。这种方式继续执行会发生：
所以这种需要申请资源的情况我们需要自己去定义一个拷贝构造函数：

Stack(const Stack& st)
 {
	_array = (int*)malloc(sizeof(int)*st._capacity);
	if (_array == nullptr)
	{
		perror("malloc fail");
		exit(-1);
	}
	memcpy(_array, st._array, sizeof(int)*st._size);
	_size = st._size;
	_capacity = st._capacity;
 }

需要写析构函数的类，都需要写深拷贝的拷贝构造函数 （Stack）
不需要写析构函数的类，默认生成的浅拷贝的拷贝构造函数就可以直接用 （Date/MyQueue）

5. 拷贝构造函数典型调用场景：

• 使用已存在对象创建新对象
• 函数参数类型为类类型对象
• 函数返回值类型为类类型对象

class Date
{
public:
	Date(int year, int minute, int day)
	{
		cout << "Date(int,int,int):" << this << endl;
	}
	Date(const Date& d)
	{
		cout << "Date(const Date& d):" << this << endl;
	}
	~Date()
	{
		cout << "~Date():" << this << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
Date Test(Date d) 
{
	Date temp(d);
	return temp;
}
int main()
{
	Date d1(2022, 1, 13);
	Test(d1);
	return 0;
}

运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其
返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字 operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)

• 不能通过连接其他符号来创建新的操作符：比如operator@
• 重载操作符必须有一个类类型参数
• 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
• 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
• "_.* _ :: _ sizeof _ ?: _ . _ " 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

我们来了解一下为什么要有运算符重载？
如果是内置类型比如int、double这种，我们比较它们的大小就可以直接使用±直接比较，但如果我们要比较一个类的大小呢？比如日期类：
我们观察一下运算符重载该如何使用：




下面是一些关于日期类运算符重载的代码：

bool operator==(const Date& d)
	{
		return _year == d._year
			&& _month == d._month
			&& _day == d._day;
	}
bool operator>(const Date& d)
	{
		if (_year > d._year)
		{
			return true;
		}
		else if (_year == d._year && _month > d._month)
		{
				return true;
		}
		else if (_year == d._year && _month == d._month && _day > d._day)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
bool operator>=(const Date& d)
	{
		return *this > d || *this == d;
	}
int Getmonthday(int year, int month)
	{
		static int data[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
		if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
		{
			return 29;
		}
		else
		{
			return data[month];
		}
	}
Date operator+(int day)
	{
		Date ret(*this);
		ret += day;
		return ret;
	}
Date operator+=(int day)
	{
		_day += day;
		while (_day > Getmonthday(_year,_month))
		{
			_day -= Getmonthday(_year, _month);
			_month++;
			if (_month == 13)
			{
				_year++;
				_month = 1;
			}
		}
		return *this;
	}

赋值运算符重载

我们想要一个对象与另外一个对象互相直接操作，为了更加方便理解，就有赋值运算符重载

赋值运算符重载格式：

1. 参数类型：const T&，传递引用可以提高传参效率
2. 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
3. 检测是否自己给自己赋值
4. 返回*this ：要复合连续赋值的含义

Date& operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		return *this;
	}

那么编译器默认生成的赋值运算符重载能用么？

对于内置类型，赋值运算符重载直接会将其拷贝过去，自定义类型会调用其自身的成员函数。
当然，赋值运算符重载不可能面面俱到，我们来试试Stack类：

(默认生成的是浅拷贝，如果有资源的申请比如malloc等那么就需要深拷贝)
参考赋值运算符重载函数：

Stack& operator=(const Stack& st)
{
	if (this != &st)//防止自己赋值给自己
	{
		free(_array);
		_array = (int*)malloc(sizeof(int) * st._capacity);
		if (_array == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		memcpy(_array, st._array, sizeof(int) * st._size);
		_size = st._size;
		_capacity = st._capacity;
	}
	return *this;
}

小问题：可能有小伙伴在写这个函数的时候想，能不能在得到目标空间后，对原空间使用realloc来扩容，然后将目标空间的数据拷贝过去，如果是目标空间比原空间大的话可以这样使用，但是如果原空间比目标空间大的话这样是不是就不太方便呢？所以我们直接将原空间释放，然后按照目标空间重新开辟空间，这样能更加便捷

赋值运算符只能重载成类的成员函数不能重载成全局函数

前置++和后置++重载

<< 与 >> 的重载
我们常用的cout与cin函数能够自动识别各种类型的变量，底层也是重载实现的：

我们想对对象直接进行输出：
我们需要自己实现重载：


对于运算符的重载我们一般都将其定义为成员函数，但是对于流插入‘<<’我们发现这样不太行，我们需要将其定义为全局函数。

const成员

这里为什么不能执行print函数，原因就是涉及到了权限的放大：

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数
隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

解决办法就是在成员函数后面加上const

总结:凡是内部不改变成员变量，其实也就是*this对象数据的，这些成员函数都应该加const

取地址及const取地址操作符重载

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需
要重载，比如想让别人获取到指定的内容！

下面是一种情况：