这里写目录标题

类的6个默认成员函数
- 构造函数
- - 特征
- 析构函数
- - 概念
  - 特性
- 拷贝构造
- - 特征
  - 拷贝构造如何自定义
- 运算符重载
- - 赋值运算符重载
  - 赋值运算符重载
  - 前置++和后置++重载
- 取地址及const取地址操作符重载

类的6个默认成员函数

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

class A1{};

空类中真的什么都没有吗？
并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
在这里插入图片描述
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数

功能介绍：

构造函数：主要完成初始化工作
析构函数：主要完成清理工作
拷贝构造：是实用同类对象初始化创建对象
赋值重载：吧一个对象赋值给另一个对象
普通对象和const对象取地址重载：为普通对象和const对象取地址（但这两个极少需要自己实现）

构造函数

先看以下类，及使用

class car
{
public:
	void print()
	{
		cout << "车名：" << _name << " 价格：" << _price << endl;
	}
	void Init(const char* name , const char* price)
	{
		strcpy(_name , name);//写入数据
		strcpy(_price , price);//写入数据
	}
private:
	char _name[20];//车名
	char _price[20];//价格
};
void test8()
{
	car Byd_q;//定义出对象Byd_q
	Byd_q.Init("比亚迪 秦", "99800");
	Byd_q.print();
}

对于car类，可以通过 Init 公有方法给对象填入数据，但如果每次创建对象时都调用该方法设置
信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

答案是可以的，需要自己创建一个构造函数，并按照自己的想法来初始化对象中的数据

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

特征

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

函数名与类名相同。
无返回值，函数名前不用写返回值类型（void也不用）
对象实例化时编译器自动调用对应的构造函数。
构造函数可以重载。这意味着你可以有多种初始化对象的方式，编译器会根据你所传递的参数去调用对应的构造函数。

class car
{
public:
	car()//无参构造函数
	{
	
	}

	car(const char* name, const char* price)//带参构造函数
	{
		strcpy(_name, name);//写入数据
		strcpy(_price, price);//写入数据
	}
	void print()
	{
		cout << "车名：" << _name << " 价格：" << _price << endl;
	}
	void Init(const char* name , const char* price)
	{
		strcpy(_name , name);//写入数据
		strcpy(_price , price);//写入数据
	}
private:
	char _name[20];//车名
	char _price[20];//价格
};
void test9()
{
	car Byd_q;//调用无参构造函数
	car Byd_s("比亚迪 宋", "154800");//调用对应带参构造函数
	Byd_s.print();
	
	// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
	//car Byd_t();
	//会报错warning C4930: 未调用原型函数(是否是有意用变量定义的?)
}

注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明

运行后得到结果：
在这里插入图片描述

无参的构造函数、全缺省的构造函数以及我们不写编译器自动生成的构造函数都称为默认构造函数，并且默认构造函数只能有一个
初学C++时，你可能认为只有当我们不写，编译器自动生成的构造函数才被称为默认构造函数。其实并不是这样的，以下3种都叫做默认构造函数：
1、我们不写，编译器自动生成的构造函数。
2、我们自己写的无参的构造函数。
3、我们自己写的全缺省的构造函数。
总而言之，无需传参就可以调用的构造函数就是默认构造函数。
如果类中没有显示定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，若用户显示定义了，则编译器就不再生成

说到这里，你可能会想：既然在我们不写的情况下，编译器会自动生成一个构造函数，那我们就没有必要自己写构造函数了。这种想法是不对的。

比如下面的情况：

class car
{
public:
	void print()
	{
		cout << "车名：" << _name << " 价格：" << _price << endl;
	}
	void Init(const char* name , const char* price)
	{
		strcpy(_name , name);//写入数据
		strcpy(_price , price);//写入数据
	}
private:
	char _name[20];//车名
	char _price[20];//价格
};
void test9()
{
	car Byd_s;//调用默认构造函数
	Byd_s.print();
}

上面的由于car类中没有自定义的构造函数，所以 Byd_s 对像用的是默认构造，但并没有对数据进行初始化运行结果为
在这里插入图片描述
编译器自动生成的构造函数机制：
1、编译器自动生成的构造函数对内置类型不做处理。
2、对于自定义类型，编译器会再去调用它们自己的默认构造函数。

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

class car
{
public:
	void print()
	{
		cout << "车名：" << _name << " 价格：" << _price << endl;
	}
	void Init(const char* name , const char* price)
	{
		strcpy(_name , name);//写入数据
		strcpy(_price , price);//写入数据
	}
private:
	char _name[20] = "比亚迪 秦";//车名
	char _price[20] = "99800";//价格
};
void test9()
{
	car Byd_s;//调用默认构造函数
	Byd_s.print();
}

内置类型成员变量在类中声明时可以给默认值，使用类的默认构造是定义对象时成员变量的值会是默认值
在这里插入图片描述

总结一下：虽然在我们不写的情况下，编译器会自动生成构造函数，但是编译器自动生成的构造函数可能达不到我们想要的效果，所以大多数情况下都需要我们自己写构造函数。

析构函数

概念

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

特性

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

class A
{
	public:
		A()
		{
			int* cur = (int*)malloc(sizeof(int) * 2);//申请内存
			assert(cur);
			pp = cur;
			cout << "申请内存\n";
		}
		~A()
		{
			free(pp);//释放内存
			cout << "释放内存\n";
		}
private:
		int* pp;
};
void main()
{
	A d1;
}

运行结果如下,由于是局部变量d1的作用域结束后会自动调用析构函数。
在这里插入图片描述
5. 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器
生成的默认析构函数，对自定类型成员调用它的析构函数。

class A
{
	public:
		A()
		{
			int* cur = (int*)malloc(sizeof(int) * 2);//申请内存
			assert(cur);
			pp = cur;
			cout << "申请内存\n";
		}
		~A()
		{
			free(pp);//释放内存
			cout << "释放内存\n";
		}
private:
		int* pp;
};
class B
{
public:

	A S1;
};
int main()
{
	B d1;
	return 0;
}

运行如下
在这里插入图片描述
内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；
而上图B中有A类对象，所以B销毁时其析构函数会调用其该类中自定义类型的析构函数；

总结：如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，而如上图A类；有资源申请时，一定要写析构函数并释放对应内存，否则会造成资源泄漏

拷贝构造

在某一情况下我们可能需要拷贝出一个一模一样的对象来使用，以免破坏原有对象的数据。

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

特征

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

为什么拷贝构造函数参数为传值传值方式会引发无穷递归？
因为传值传参，形参是是实参的拷贝，对象要拷贝就需要调用拷贝构造，但拷贝构造的参数是传值传参时自己也许调用拷贝构造，所以会无限递归调用自己！
若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
如下图：

拷贝构造如何自定义

注意：
1：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。
2：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝

错误示范：
在这里插入图片描述
错误原因：
1：默认拷贝构造是按字节拷贝，所以c2的_number指向c1的_number的同一地址
2：这就会导致析构时同一地址析构两次，从而报错
3：在使用时还会出现两者数据相互覆盖，删除等，因为两个不同的对象在操作同一个地址

当有内存申请时应该，自定义拷贝构造函数将数据进行深拷贝，并如下图一样重新申请空间，并把数据复制进新空间
在这里插入图片描述
拷贝构造函数典型调用场景：
1：使用已存在对象创建新对象
2：函数参数类型为类类型对象
3：函数返回值类型为类类型对象

注意：类属于自定义类型一般对象都比较大所以为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用。

运算符重载

赋值运算符重载

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

如以下为 “==" 的重载：

  bool operator==(Date& d1){
        if (d1._year = _year && d1._mouth == _mouth && d1._day == _day){
            return true;
        }
        return false;
    }

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

注意：
1：不能通过连接其他符号来创建新的操作符：比如operator@重载操作符必须有一个类类型参数
2：用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
3：作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
4：【 .* 】【 :: 】【 sizeof 】【 ? : 】【 . 】注意以上5个运算符不能重载。

赋值运算符重载

一：赋值运算符重载格式
1：参数类型：const T&，传递引用可以提高传参效率
2：返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
3：检测是否自己给自己赋值
4：返回*this ：要复合连续赋值的含义
代码如下：

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

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

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

三：用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。
注意：
1：内置类型成员变量是直接赋值的
2：如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现深拷贝。

前置++和后置++重载

// 前置++：返回+1之后的结果
// 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
Date& operator++()
{
_day += 1;
return *this;
}
// 后置++：
// 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
// C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this+1
// 而temp是临时对象，因此只能以值的方式返回，不能返回引用
Date operator++(int)
{
Date temp(*this);
_day += 1;
return temp;
}

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

class Date
{
public :
	Date* operator&()
	{
		return this;
	}
	const Date* operator&()const
	{
		return this;
	}
private :
	int _year ; // 年
	int _month ; // 月
	int _day ; // 日
};