C++：类和对象（二）

欢迎来到Harper·Lee的学习笔记！
博主主页传送门：Harper·Lee的博客主页
个人语录：他强任他强，清风拂山岗！

一、类的默认成员函数

如果一个类里面什么的成员都没有，我门将其简称为空类。但是空类里面真的什么都没有吗？其实不然，任何一个类包括空类，里面都会自动生成6个默认成员函数。

class Date
{
    //空类，大小为1
};

默认成员函数：用户没有 显示实现 ，编译器会自动生成的成员函数（一旦我们显示地实现了，即使是一个空的函数，编译器也不会再生成了）。一个类在我们不主动实现的情况下，编译器会自动生成6个默认成员函数；如果我们主动写了，那么编译器就不再生成了。

对于默认成员函数，我们主要从两个问题来进行学习：

Q1：程序员不写，编译器默认生成的函数行为是什么，是否满足我们的需求？

Q2：编译器默认生成的函数不满足我们的需求，我们需要自己实现，那么如何自己实现？

二、 构造函数--初始化工作（重点）

2.1 定义

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

例如：下面一个日期类的成员函数Date，就是一个构造函数。

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int year = 2024, int month = 1, int day = 1)//构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

2.2 特性

构造函数的主要任务并不是开空间创建对象（我们经常使用的局部对象是栈桢创建时，空间就开好了），而是在对象进行实例化时初始化对象的 。
说明：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的原生数据类型，

如：int/char/double/指针等，自定义类型就是我们使用class/struct等关键字自己定义的类型。

1. 函数名与类名相同。
2. 无返回值。（不写返回值，也不写void）
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。（就是一个类可以有多个构造函数，也就是有多种初始化方式，编译器会根据程序员所传递的参数去调用对应的构造函数。）
5. 自己实现的无参构造函数、自己实现的全缺省构造函数、我们不写但是编译器默认生成的构造函数，都叫做默认构造函数。 这三个默认构造函数只能存在一个 。

总之：无需传参就可以调用的函数就是默认构造函数。

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

当然你可能会想：既然编译器可以自动生成构造函数，那我们就没必要再去实现构造函数了。起始这种想法是错误的。那么编译器的自动生成还有什么意义呢？请看下面的代码：（没有自己去实现构造函数，编译器自动生成的默认构造不得行啊！）

#include<iostream>
using namespace std;
//（没有初始化）
class Date
{
public:
//没有写Date构造函数
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;//无参没有括号，是对象实例化吗？？
	d1.Print();
    
	return 0;
}

运行结果：

上面的这段代码我没有实现构造函数，那么编译器就需要自动生成。编译器自动生成的构造函数机制：

1. 对于内置类型，编译器自动生成的构造函数对内置类型不做处理，因此它的行为是不确定的；
2. 对于自定义类型，编译器会去调用成员变量自己的默认构造函数。 如果这个成员变量没有默认构造函数，就会保报错，我们要初始化这个成员变量，需要使用初始化列表。

我们不写，编译器默认生成的构造函数：（上面的例子就是我们不写的构造）
（1）对内置类型的成员变量的初始化没有要求，也就是说是是否初始化是不确定的，看编译器；
（2）对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化；
根据上面的代码，我们不写，编译器自动生成的默认构造函数不满足我们的需求！

//实现一个栈的构造函数：不需要传入private里面变量的值，就需要自己主动实现！！！
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)//只需传入一个大小，写全缺省：知道具体大小就传入具体大小，不知道具体大小就用默认缺省值
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
// 两个Stack实现队列------复习------就不需要自己去实现构造函数了
//对于自定义类型的成员变量，要求调用这个成员变量的默认构造函数初始化
class MyQueue
{
public:
	//没有去实现Myqueue的构造函数
	//编译器默认生成Myqueue的构造函数调用了Stack的额构造，完成了两个
private:
	Stack pushst;//这里是使用Stack创建的变量：叫做自定义类型成员变量
	Stack popst;
};
int main()
{
	Stack st;
	MyQueue mq;//这里的构造是编译器自动生成的
			   //会调用自定义类型成员变量pushst、popst的默认构造函数Stack(int n = 4)
	return 0;
}
//C++标准：不是所有编译器都会处理

//如果自定义类型成员变量没有刚才所的默认构造函数，那么就会报error：

做总结：大多数情况下，构造函数都需要我们自己去实现，少数像Myqueue且Stack有默认构造时，Myqueue自动生成就可以用。
（3）如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要用初始化列表才能解决。

2.3 构造函数的种类

#include<iostream>
using namespace std;
class Date
{
public:
	// 1.⽆参构造函数
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	// 2.带参构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 3.全缺省构造函数
	/*Date(int year = 1, int month = 1, int day = 1)
	{
	_year = year;
	_month = month;
	_day = day;
	}*/
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	// 如果留下第⼆个带参构造，第⼀三个注释掉
	// 编译报错：error C2512: "Date": 没有合适的默认构造函数可⽤
	Date d1; // 调⽤默认构造函数
	Date d2(2025, 1, 1); // 调⽤带参的构造函数
	// 注意：如果通过无参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法
	// 区分这⾥是函数声明还是实例化对象
	// warning C4930: "Date d3(void)": 未调⽤原型函数(是否是有意⽤变量定义的?)
	Date d3();
	d1.Print();
	d2.Print();
	return 0;
}

2.3.1 无参构造函数

#include<iostream>
using namespace std;

class Date
{
public:
	Date()//无参构造函数
	{
		_year = 2024;
		_month = 1;
		_day = 1;
	}
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
    Date d1;//注意：无参调用不能加括号，带参的才可以
    d1.Print();
    return 0;
}

运行结果：

2.3.2 带参构造函数

#include<iostream>
using namespace std;

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(2000, 1, 1);
	d1.Print();

	return 0;
}

运行结果：

2.3.3 全缺省构造函数

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int year = 2024, int month = 1, int day = 1)//全缺省
	{
		_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.Print();
	return 0;
}

运行结果：

注意：无参构造函数和全缺省构造函数他们虽然构成函数重载，但是当存在多个默认构造函数时，一旦我们对对象进行实例化，编译器不知道调用哪个构造函数，就会引起歧义。

注意：调用时无参的不能加括号，带参的才可以加括号。

#include<iostream>
using namespace std;

class Date
{
public:
	Date()//无参构造函数
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	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;//无参构造函数调用不加括号。
	d1.Print();

	Date d2(2000, 1, 1);//带参函数调用加括号
	d2.Print();

	return 0;
}

运行结果：

说明：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的原生数据类型，如：int/char/double/指针`等，自定义类型就是我们使用class/struct等关键字自己定义的类型。

我们不写时，编译器默认生成的构造函数，似乎不能满足我们的需求，我们最好还是自己去实现构造函数，而且最好是全缺省的。

三、析构函数--清理工作

3.1 定义

析构函数的功能与构造函数的相反，析构函数不是完成对对象本身的销毁， C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。

构造函数类似于Init，析构类似于Stack中实现的Destroy功能。有资源生成的类才需要写析构函数。 前面的日期类Date就没有资源需要清理，就不需要写析构函数。

3.2 特点

析构函数的特点：析构函数的特点：（在之前就需要写一个Init、Destroy函数）

1. 析构函数名是在类名前加上字符~；
2. 无参数无返回值，也不需要加void；-----不会出现重载的情况！
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数；
4. 对象生命周期结束时，系统会自动调用析构函数；
5. 跟构造函数类似，我们不写 编译器自动生成的析构函数 对内置类型成员不做处理，自定类型成员会调用他的析构函数；
6. 还需要注意的是我们 显示写 析构函数，对于自定义类型成员也会调用他（自定义类型成员）的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数！

从下面的代码中可以发现，编译器是会自动生成Myqueue的析构函数的，如果我们自己写了析构函数~Myqueue，那么编译器是不会去调用这个函数的，而是会调用本身的析构函数！

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	~Stack()//如果不写栈的析构函数，那么就会出现内存泄漏！！！！
	{
		cout << "~Stack()" << endl;
		free(_a);//释放掉 _a ？？？？？
		_a = nullptr;//置空
		_top = _capacity = 0;//变值
	}
private: 
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};

// 两个Stack实现队列
class MyQueue
{
public:
	//编译器默认⽣成MyQueue的析构函数调⽤了Stack的析构，释放的Stack内部的资源
	// 显⽰写析构，也会⾃动调⽤Stack的析构
	~MyQueue()//本来不需要自己写，但是这里又自己添加了一个析构函数名，什么也没有实现
	{
		cout << "~MyQueue()" << endl;
		//调用的时候可以发现：自己显示地写了析构函数，也会自动调用Stack本身的析构，避免内存泄漏
	}
private:
	Stack pushst;//自定义类型pushst、popst会调用自己即Stack的析构
	Stack popst;
};
int main()
{
	Stack st1;
	Stack st2;
	MyQueue mq;//对象空间的开辟 ：编译器编译时系统就开辟好了的
	return 0;
}

运行结果：

7. tips：监视窗口输入this即可看见所有成员变量！！！

8. 有多个对象，析构的原则：后定义的先析构、先定义的后析构。 （根据调试的过程发现调用的函数的先后顺序！）
9. 自定义类型成员的析构不用管，自动生成的析构只管内置类型的；默认生成的析构够用就不用管。

3.3 括号匹配

#include<iostream>
using namespace std;
// ⽤最新加了构造和析构的C++版本Stack实现
bool isValid(const char* s) {
	Stack st;
	while (*s)
	{
		if (*s == '[' || *s == '(' || *s == '{')
		{
			st.Push(*s);
		}
		else
		{
			// 右括号⽐左括号多，数量匹配问题
			if (st.Empty())
			{
				return false;
			}
			// 栈⾥⾯取左括号
			char top = st.Top();
			st.Pop();
			// 顺序不匹配
			if ((*s == ']' && top != '[')
				|| (*s == '}' && top != '{')
				|| (*s == ')' && top != '('))
			{
				return false;
			}
		}
		++s;
	}
	// 栈为空，返回真，说明数量都匹配 左括号多，右括号少匹配问题
	return st.Empty();
}
// ⽤之前C版本Stack实现
bool isValid(const char* s) {
	ST st;
	STInit(&st);
	while (*s)
	{
		// 左括号⼊栈
		if (*s == '(' || *s == '[' || *s == '{')
		{
			STPush(&st, *s);
		}
		else // 右括号取栈顶左括号尝试匹配
		{
			if (STEmpty(&st))
			{
				STDestroy(&st);
				return false;
			}
			char top = STTop(&st);
			STPop(&st);
			// 不匹配
			if ((top == '(' && *s != ')')
				|| (top == '{' && *s != '}')
				|| (top == '[' && *s != ']'))
			{
				STDestroy(&st);
				return false;
			}
		}
		++s;
	}
	// 栈不为空，说明左括号⽐右括号多，数量不匹配
	bool ret = STEmpty(&st);
	STDestroy(&st);
	return ret;
}
int main()
{
	cout << isValid("[()][]") << endl;
	cout << isValid("[(])[]") << endl;
	return 0;
}

四、拷贝构造函数

4.1 定义

如果一个构造函数的的是自身类类型的引用，且任何额外的参数都有默认值，则此构造函数也叫做拷贝构造函数，也就是说拷贝构造函数是一个特殊的构造函数。

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)//构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)//这里的拷贝构造函数的写法：函数名和类名相同；如果还有参数，就必须有默认/缺省值
	{				   //第一个参数是类类型对象的引用
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{ 
	Date d1(2024, 1, 1);
	d1.Print();

	Date d2(d1);//拷贝一个对象来初始化对象d2，尽量用const来限定，避免传入的参数被修改！！！
	d2.Print();

	return 0;
}

4.2 特点

• 拷贝构造函数是构造函数的一个重载形式。
• 拷贝构造函数的参数第一个参数必须是类类型对象的引用，且任何额外的参数都有默认值（缺省值），使用传值方式编译器直接报错，因为语法逻辑上会引发无穷递归调用。
• C++规定：传值传参要调用拷贝构造。

4.3 传值传参VS引用传参

4.3.1 传值传参调用有引用&的拷贝构造函数

拷贝构造函数的第一个参数如果假如 使用传值传参方式编译器就会直接报错，因为语法逻辑上会引发无穷递归调用（调试可以看见）。

//拷贝构造的第一个参数是自身类类型对象的引用
#include<iostream>
using namespace std;

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)//带参构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
    //const可以保护d，避免：像if(d._year == _year)写成：if(d._year = _year)
    //拷贝构造的写法：函数名和类名相同；如果还有参数，就必须有默认/缺省值
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month; 
		_day = d._day;
	}
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

void Func1(Date d)//这里不是拷贝构造函数，无&只有一个参数d，调用时就是传值传参！！！！！
{
	cout << &d << endl;
	d.Print();
}

int main()
{ 
	Date d1(2024, 1, 1);
	d1.Print();
	
	//C++规定:传值传参要调用拷贝构造
	Func1(d1);//这里调用Func1函数会形成拷贝构造（传值传参：d1作为传入的值传给Func1中的d来接收）

	 // error C3867 : "Date::Func1" : 非标准语法；请使用 "&" 来创建指向成员的指针
	return 0;
}

• 分析过程（C语言和C++的区别）：根据调试发现，按F11首先进入的函数是拷贝构造函数，而不是进入函数Func1，得到的结果进入Func1函数，完成的是传参过程；再按F11，完成Func1函数调用，这里是正常的调用。
• 分析原因：正常调用是因为拷贝构造函数Date使用了引用&，因此Func1函数调用没有形成无穷递归，而是正常调用。

• 建议：对于自定义类型，这个Func1函数不建议传值传参。因为它需要调用拷贝构造函数，因此建议自定义类型传引用。内置类型影响不大。（更多内容看const引用）

void Func1(const Date& d)//这里不是拷贝构造函数，无&只有一个参数d，调用时就是传值传参！！！！！
{
	cout << &d << endl;
	//d.Print();但是加入const时，这里编译不通过
}

4.3.2 直接调用无引用的拷贝构造函数

下面改进的代码就相当于d是d1的别名，直接就将d1作为参数传入，而不会形成新的拷贝构造函数，正常调用该函数。代码如下:

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(Date d)//第一个参数并不是自身类类型的引用（无引用）
	{
		_year = d._year;
		_month = d._month; 
		_day = d._day;
	}
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{ 
	Date d1(2024, 1, 1);
    
	Date d2(d1);//这里就是正常（直接）调用拷贝构造函数
    d2.Print();
	
	return 0;
}

• 分析代码过程：调用拷贝构造函数需要传值传参，而C++规定，传值传参生成临时对象时，就需要为它调用拷贝构造函数，形成新的临时拷贝构造函数，如图中的Date d(d1);调用它又需要传参d1，就又会形成新的拷贝构造函数，一直循环往复......整个函数调用的过程分析图如下：

• 分析原因：造成无穷递归主要就是因为下面这两个函数：

Date d2(d1);
Date d(d1);//这个函数就是新形成的拷贝构造函数！

• 提出疑问：图中的Date d(d1);是什么意思？

• 提出假设：如果没有传值，而是引用，就不会生成拷贝构造，就是正常的调用。相当于： **Date d2(d1);**就变成： **d就是d1，this就是d2**。

4.3.3 直接调用有引用的拷贝构造函数

代码如下：

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)//第一个参数是自身类类型的引用，这是正确的拷贝调用函数！
	{
		_year = d._year;
		_month = d._month; 
		_day = d._day;
	}
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{ 
	Date d1(2024, 1, 1);
    
	Date d2(d1);//这里就是正常（直接）调用拷贝构造函数
    d2.Print();
	
	return 0;
}

分析：在这段代码里面，相当于d是d1的别名，并没有形成新的拷贝构造，正常就结束调用了。拷贝构造函数的第一个参数是自身类类型对象的引用，这才是正确的拷贝构造函数！
---注意注意注意---

• 传引用的时候，最好加入const，避免传入参数被修改。
• C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成。（传值传参是为了生成的临时对象调用的拷贝构造函数）

4.4 未显示定义拷贝构造函数

• 若未显式定义拷贝构造，编译器会生成自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造。（拷贝构造函数对内置类型不做处理，例如日期类但是这里不一样了）

内置类型有拷贝构造，自定义类型也有拷贝构造。但是：

4.4.1 无资源的不需要显示实现拷贝构造

有些自动生成的拷贝构造够用了，不需要我们显示实现。像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的拷贝构造就可以完成需要的拷贝，所以不需要我们显示实现拷贝构造。

4.4.2 某些自动生成的拷贝构造不满足

有些自动生成的拷贝构造就不满足需求，无论还内置类型还是自定义类型。

1. 内置类型分析：像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器自动生成的拷贝构造完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝 (对指向的资源也进行拷贝，对指针有所处理)。

#include<iostream>
using namespace std;
typedef int STDataType;

class Stack
{
public:
	Stack(int n = 4)//构造
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
    加入这一部分后，才是深拷贝，st1和st2空间得出地址就不是一样的了
	st2(st1):这里参数对应：st1就是st，st2就是this指针
	//Stack(const Stack& st)//拷贝构造函数：不写，就会进行浅拷贝/值拷贝
	//{
	//	// 需要对_a指向资源创建同样⼤的资源再拷⻉值
	//	_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
	//	if (nullptr == _a)
	//	{
	//		perror("malloc申请空间失败!!!");
	//		return;
	//	}
	//	memcpy(_a, st._a, sizeof(STDataType) * st._top);
	//	_top = st._top;
	//	_capacity = st._capacity;
	//}
    void Push(STDataType x)
    {
        if (_top == _capacity)
        {
            int newcapacity = _capacity * 2;
            STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
                sizeof(STDataType));
            if (tmp == NULL)
            {
                perror("realloc fail");
                return;
            }
            _a = tmp;
            _capacity = newcapacity;
        }
        _a[_top++] = x;
    }
    ~Stack()//析构
    {
        cout << "~Stack()" << endl;
        free(_a);
        _a = nullptr;
        _top = _capacity = 0;
    }
private://内置类型
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(2);
	
	Stack st2(st1);
	//Stack不显示实现拷贝构造函数，而是用自动生成的拷贝构造函数完成了浅拷贝
	//调试发现，程序崩溃：因为st1和st2⾥⾯的_a指针指向同一块资源同一块空间，而且析构函数运行了两次，即同一块空间被析构了两次。

	return 0;
}

调试发现：st1和st2⾥⾯的_a指针指向同一块资源同一块空间，而且析构函数运行了两次，即同一块空间被析构了两次（调试过程得出），程序崩溃。因此，我们不显示实现，编译器自动生成的拷贝构造函数完成浅拷贝/值拷贝的过程并不一定满足需求，需要我们自己显示实现完成深拷贝。

加入拷贝构造函数后，深拷贝结果如下：

2. 自定义类型分析 ：像MyQueue（指的是两个栈实现队列中的MyQueue）这样的类型内部主要是自定义类型Stack成员，编译器自动生成的拷贝构造会调用Stack的拷贝构造，也不需要我们显示实现MyQueue的拷贝构造。调试发现，使用的是深拷贝。

//两个栈实现队列中的MyQueue
#include<iostream>
using namespace std;
typedef int STDataType;

class Stack
{
public:
	Stack(int n = 4)//构造
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}

	//st2(st1):这里参数对应：st1就是st，sh2就是this指针
	Stack(const Stack& st)//拷贝构造函数：不写，就会进行浅拷贝/值拷贝
	{
		// 需要对_a指向资源创建同样⼤的资源再拷⻉值
		_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		memcpy(_a, st._a, sizeof(STDataType) * st._top);
		_top = st._top;
		_capacity = st._capacity;
	}

	void Push(STDataType x)
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
				sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			_a = tmp;
			_capacity = newcapacity;
		}
		_a[_top++] = x;
	}
	~Stack()//析构
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}

private://成员都是内置类型
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
// 两个Stack实现队列
class MyQueue
{
public:
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(2);

	// Stack不显⽰实现拷⻉构造，⽤⾃动⽣成的拷⻉构造完成浅拷⻉
	// 会导致st1和st2⾥⾯的_a指针指向同⼀块资源，析构时会析构两次，程序崩溃
	Stack st2(st1);//Stack st2 = st1;也可以这样写

	MyQueue mq1;
	// MyQueue⾃动⽣成的拷⻉构造，会⾃动调⽤Stack拷⻉构造完成pushst/popst
	// 的拷⻉，只要Stack拷⻉构造⾃⼰实现了深拷⻉，他就没问题
	MyQueue mq2(mq1);

	return 0;
}

4.4.3 小tip

这里有一个小技巧，如果一个类显示实现了析构并释放资源，那么他就需要我们显示写拷贝构造，否则就不需要。

4.5 C++规定传值传参调用拷贝构造的原因

• 这其实是为了补足C语言的缺陷：

在C语言中，直接进行传值传参，原本形参的改变并不影响实参，但是若放在类似于有资源生成的栈结构体种，形参的改变会影响实参。例如下面的代码若从C语言的角度来看，func函数中，st1传值传参给st，本应st1的改变不会引起st的改变，但实际上，st1改变会影响st；st1进行销毁时，但st也会被销毁，因此C++在这里规定调用拷贝构造，实际上是补足C语言的缺陷，调用拷贝构造，进行深拷贝

#include<iostream>
using namespace std;
typedef int STDataType;

class Stack
{
public:
	Stack(int n = 4)//构造
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}

	//st2(st1):这里参数对应：st1就是st，sh2就是this指针
	Stack(const Stack& st)//拷贝构造函数：不写，就会进行浅拷贝/值拷贝
	{
		// 需要对_a指向资源创建同样⼤的资源再拷⻉值
		_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		memcpy(_a, st._a, sizeof(STDataType) * st._top);
		_top = st._top;
		_capacity = st._capacity;
	}

	void Push(STDataType x)
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
				sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			_a = tmp;
			_capacity = newcapacity;
		}
		_a[_top++] = x;
	}
	~Stack()//析构
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}

private://成员都是内置类型
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
void func(Stack st)
{

}
int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(2);
    
	func(st1);
	
	return 0;
}

• 在上面的代码中，其实还有一处缺陷：

在这里，传值传参调用拷贝构造的代驾会很大，比如：在数据非常大的情况下，需要开辟一块相同得到很大的空间，存放拷贝得到的数据。因此最好使用引用，st变成st1的别名。

void func(const Stack& st)
{
    //......
}

4.6 浅拷贝/值拷贝和深拷贝

• 浅拷贝/值拷贝：实际上就是将d1的内容完完全全地复制了一份拷贝给d2。（浅拷贝容易出现很多问题）

Date d2(d1);//用已存在的对象d1创建对象d2

• 深拷贝 ：像栈（Stack）这样的类，编译器自动生成的拷贝构造函数就不能满足我们的需求了，例如下面这两句代码，我们本来是想用已存在的对象st1创建对象st2，但是编译器自动生成的拷贝是浅拷贝，拷贝出来的对象st2不能满足我们的需求。

Stack st1;
Stack s2(s1);//用已存在的对象st1创建对象st2
//后来调试发现st1和st2的地址相同

因此，在我们创建出拷贝构造函数后，就可以用已存在的对象来创建另一个新的对象。

int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(2);
	
	Stack st2(st1);//用st1创建st2

	return 0;
}

4.7 传值返回和传引用返回

• 传值返回：传值返回会产生一个临时对象调用拷贝构造。
• 传值引用返回：返回的是返回对象的别名（引用），没有产生拷贝。
• 如果返回对象是一个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回是有问题的，这是的引用相当于一个野引用，类似于野指针。
• 传引用返回可以减少拷贝，但是一定要确保返回对象，在当前函数结束后还在，才能用引用返回。

五、赋值运算符重载

5.1 运算符重载

· 当运算符被用于类类型的对象时，C++允许我们通过运算符重载的形式指定新的含义（也就是我们自己定义规则）。· C++规定类类型对象使用运算符时，必须 转换成调用对对应运算符重载，若没有对应的运算符重载，编译器就会编译报错。
· 运算符重载是一个具有特殊名字的函数，它的名字是由operator关键字和后面要定义的运算符共同构。和其他函数一样，它也有函数体、返回类型、参数列表。运算符重载的格式及运用：

返回值 operator要定义的运算符 (参数列表)
{
    //函数体：自己定义规则
}  
//运用：
bool operator==(Date d1, Date d2)//最好加一个引用
{
	//比较大小：bool类型
}
int main()
{
    Date d1(2024,1,1);
    Date d2(1900,1,1);
	operator == (x1, x2);//左侧的传给第一个参数，右侧的穿个第二个参数

    return 0;
}

• 重载运算符的参数个数和该运算符作用的运算对象数量一样多。有些运算符有两重含义，比如： *（乘法或者解引用）；一元运算符有一个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第一个参数，右侧运算对象传给第二个参数。
• 如果一个重载运算符函数是成员函数，则它的第一个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少⼀个。
• 运算符重载以后，其优先级和结合性与对应的内置类型运算符保持一致。
• 不能通过连接语法中没有的符号来创建新的运算符：比如operator@。
• 不能重载的运算符：sizeof、::（域作用限定符）、? :（三目运算符）、对象 . 成员、. *（常用于成员函数的回调）。
• 重载操作符至少有一个类类型参数，不能通过运算符重载改变内置类型对象的含义。如：int operator+(int x,int y)。 （即：不能operator的运算符是+，结果内部用的是 . 运算符）
• 一个类重载出的运算符必须要有意义。比如Date类重载operator-就有意义，但是重载operator+就没有意义。
• 重载++运算符时，有前置++和后置++，运算符重载函数名都`operator++，无法很好的区分。C++规定，后置++重载时，增加一个int形参，跟前置++构成函数重载，方便区分。
• 重载 **<<**和 **>>**时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第一个形参位置，第一个形参位置是左侧运算对象，调用时就变成了 **对象<<cout**，不符合使用习惯和可读性。重载为全局函数把 **ostream/istream**放到第一个形参位置就可以了，第二个形参位置当类类型对象。

5.1.1 成员函数的回调.*运算符

成员函数回调不常用，之前在学习C语言中的qsort时使用过，理解一下即可。下面的代码主要是为了认识一下.*运算符。

#include <iostream>
using namespace std;

class A
{
public:
	void func()
	{
		cout << "A::func()" << endl;
	}
};

typedef void(A::* PF)();//成员函数指针类型，就相当于typedef void (*)() PF 函数指针。
//这里是成员函数，需要使用::域作用限定符
//这里就是定义了一个函数指针变量，并且typedef为PF

int main()
{
	//void(A:: * PF)() = nullptr;//定义成员函数指针变量的方法示范：定义了一个函数指针，且是空指针
	PF pf = nullptr;//

	pf = &A::func;
	//1.func函数是类域里面的，使用时需要指定类域
	//2.C++规定普通函数的函数名就是函数指针
	//3.成员函数指定类域时，需要加一个&才能取到函数指针

    
	//（普通函数）回调的方法：(*pf)();//先解引用，再加一个()。
	//但是现在在成员函数中不行。
	//那进一步改成这样：(*pf)(&aa); 
	//也不行：this指针在形参实参中都不能显示。

	A aa;//用类定义一个类对象aa
	(aa.*pf)();//正常回调，在这里就用到了 .* 操作符，它一般用于成员函数的回调
    //不能直接用类名A，即不能：(A.*pf)();
    
	return 0;
}

5.1.2 重载为全局的面临对象访问私有成员变量的问题

代码如下：

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}

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

bool operator==(Date d1, Date d2)
{
	return d1._year == d2._year
		&& d1._month == d2._month
		&& d1._day == d2._day;//没有访问权限：error C2248: "Date::_day": 无法访问 private 成员(在"Date"类中声明)
							  //法1：注释private
							  //法2：类里面定义：int GetYear(){}
}
int main()
{
	Date x1(2024, 1, 1);
	Date x2(2024, 1, 1);
	
	operator == (x1, x2);//显示调用：左侧的传给第一个参数，右侧的穿个第二个参数

	return 0;
}

运行结果：

上面的代码报错：error C2248: "Date::_day": 无法访问 private 成员(在"Date"类中声明)

1. 方法一：注释掉private，将私有转化成公有。但是这样是可以在类外面直接修改它们的内容的；数据可以随便修改，就是不可控的！

//注释掉private
#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}

//private:方法一
	int _year;
	int _month;
	int _day;
};

bool operator==(Date d1, Date d2)
{
	return d1._year == d2._year
		&& d1._month == d2._month
		&& d1._day == d2._day;//没有访问权限：error C2248: "Date::_day": 无法访问 private 成员(在"Date"类中声明)
}
int main()
{
	Date x1(2024, 1, 1);
	Date x2(2024, 7, 1);
	
	operator == (x1, x2);//显示调用：左侧的传给第一个参数，右侧的穿个第二个参数
    x1 == x2;
    return 0;
}

2. 方法二：将operator放在类里面，重载成成员函数（最推荐！！）。但是重载成成员函数的时候：

• 如果一个重载运算符函数时成员函数，那么它的第一个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少一个！此时调用方式发生变化！
• 如果这个函数的全局、成员函数都存在：优先调用成员函数。

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
    //重载成成员函数
	bool operator==(Date d2)  //=======有一个隐含的this指针=======
	{
        //如果全局函数和成员函数的这个函数都存在：优先调用成员函数
		//比较大小：bool类型
		return _year == d2._year
			&& _month == d2._month
			&& _day == d2._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date x1(2024, 1, 1);
	Date x2(2024, 1, 1);

    //??????????调用方式
    
    //这种调用方式是显示调用，如果写了成员的和全局的，这里会调用全局的函数
    operator==(x1,x2);

    //运算符重载函数可以显示调用
	//x1.operator==(x2);
    
    //这种调用方式：编译器会转换成x1.operator==(x2);
	x1 == x2;//

	return 0;
}

3. 方法三：类的里面定义：int GetYear(){ }（提供get函数）//???

int GetYear()
{
    return _year;
}
int GetMonth()
{
    return _month;
}
int GetDay()
{
    return _day;
}

4. 方法四：使用友元函数

总结：类里面可以访问，类外面不可以访问：

• 法一：注释掉private：私有改为公有，在类外面就可以访问成员变量了，不安全！
• 法二：提供get函数间接访问；
• 法三：运算符的那个函数放在了在类外面不行，就放在类里面重载成成员函数；
• 法四：友元函数。

5.1.3 运算符重载和函数重载的区别

二者之间没有区别。

• 函数重载：函数名相同、参数不同的两个及以上函数构成函数重载。
• 运算符重载：对运算符定义新的意义。

5.2 赋值运算符重载

5.2.1 拷贝构造和赋值运算符重载的区别

赋值运算符重载：是一个默认成员函数，用于完成两个已经存在的对象直接的拷贝赋值。
区别拷贝构造：拷贝构造用于一个对象拷贝初始化给另一个要创建的对象。

int main()
{
	Date d1(2024, 1, 1);//这里是用三个值来初始化
	Date d2(2024, 1, 2);

	//赋值重载/赋值重载拷贝---是运算符重载
	d1 = d2;//两个已经存在的对象

	//拷贝构造---完成新的对象的初始化，而非创建出这个新的对象。这里没有创建！
    //它的初始化使用同类型的对象进行的，这一步叫做：拷贝构造
	Date d3(d2);//这里是用同类型对象来初始化
	Date d4 = d2;//
    //它相当于：先是一种从类型开始的初始化，再是一种拷贝

	return 0;
}

5.2.2 赋值运算符重载的特点

1. 赋值运算符重载是一个运算符重载，规定必须重载为成员函数（而不是全局函数）。 赋值运算重载的参数建议写成const+当前类类型引用，否则传值传参会有拷贝（避免无穷递归）。

//d1 = d2:d2赋值拷贝给d1
//1. 可以用传值传参，但是容易无穷递归，这里没有发生无穷递归
void operator=(Date d)// = :表示赋值。赋值重载
{
    //建议: 写成类类型的引用
}
//2. 使用const+引用
void operator=(const Date& d)
{
    //关系：d就是d2（的别名），this就是d1
    _year = d._year;
    _month = d._month;
    _day = d._day;
}

2. 有返回值，且建议写成当前类类型引用，引用返回可以提高效率，有返回值目的是为了支持连续赋值场景。

//d4 = d3 = d1
	//让连续赋值正常的方法：-------
	//d3 = d1，在这里返回的是d3，返回类型是d3的类型。又因为：d1传给d（d是d1的别名），d3传给this指针解引用，this是d3的地址
	Date& operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;

		//在这里就用上了this
		return *this;
		//但是：传值返回也会生成一个拷贝，该函数结束，浪费资源生成了一个拷贝，所以建议使用引用返回，加一个&
	}
	//引用返回是为了提高效率
	//=====指针和引用功能相似，但不能用指针替代引用，因为引起的改变很多、很繁琐、代码很复杂，可读性变差
    //会让原本的拷贝构造Date d3(d2);变成Date d3(&d2);，已经变成一个普通的构造了（因为没有自身类类型引用了）

3. 没有显式实现时，编译器会自动生成一个默认赋值运算符重载，默认赋值运算符重载行为跟默认拷贝构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的赋值重载。

和前面的拷贝构造类似，这里自动生成的默认赋值运算符重载不一定适合各个类型，分析如下：

5.2.3 是否需要显示实现赋值运算符重载

• 内置类型且无资源--不需要： 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的赋值运算符重载就可以完成需要的拷贝，所以不需要我们显示实现赋值运算符重载。
• 内置类型--需要： 像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器自动生成的赋值运算符重载完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝(对指向的资源也进行拷贝)。
• 自定义类型成员--不需要： 像MyQueue这样的类型内部主要是自定义类型Stack成员，编译器自动生成的赋值运算符重载会调用Stack的赋值运算符重载，也不需要我们显示实现MyQueue的赋值运算符重载。
• 小tips： 这里还有一个小技巧，如果一个类显示实现了析构并释放资源，那么他就需要显示写赋值运算符重载，否则就不需要。

---

文末结语：感谢uu支持，愿各位读者事业有成、学业进步！