类和对象：拷贝构造函数

如果⼀个构造函数的第⼀个参数是⾃⾝类类型的引⽤（只要求是第一个），且任何额外的参数都有默认值（缺省值），则此构造函数也叫做拷⻉构造函数，也就是说拷⻉构造是⼀个特殊的构造函数

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 , int x = 0)//其他的一定要是默认值/缺省值，但一般不用
	//Date(const Date)//使用传值方式编译器会报错
	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, 7, 16);
	d1.Print();
	//用d1拷贝d2
	//调用的就是拷贝构造
	Date d2(d1);
	d2.Print();
	return 0;
}

2. 拷⻉构造函数的第一个参数必须是类类型对象的引⽤（因为要完成当前对象的拷贝），使⽤传值⽅式编译器直接报错，因为语法逻辑上会引发⽆穷递归调⽤；
3. C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥⾃定义类型传值传参和传值返回都会调⽤拷⻉构造完成；
探究本质：

#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;
};
//为什么必须是引用？
void Func1(Date d)
{
	cout << &d << endl;
	d.Print();
}
 
int main()
{
	Date d1(2024, 7, 16);
	d1.Print();
	//C++规定传值传参要调用拷贝构造函数,C语言传直接按字节拷贝过去了
	Func1(d1);//调试发现，按F11并没有跳到Func1函数中，而是跳到了拷贝构造函数中，再跳到Func，本质是调用了两个函数
}

调试图像演示：

因为传参会构成一个新的拷贝构造，这也就是为什么拷贝构造函数不可以以传值方式构造，而是要用引用 ：因为用传值方式构造会导致无限递归。

图解：

用引用的话，d是d1的别名，所以传参的时候不会形成新的拷贝构造 

4. 若未显式定义拷⻉构造，编译器会⽣成⾃动⽣成拷⻉构造函数。⾃动⽣成的拷⻉构造对内置类型（构造函数：(初始化不确定)和析构函数：(不处理)对内置类型是不做处理的）成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的拷⻉构造；（内置类型拷贝构造也管）

#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, 7, 17);
	d1.Print();
	Date d2(d1);
	d2.Print();
	//2024 / 7 / 17
	//2024 / 7 / 17
	return 0;
}

5. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷⻉构造就可以完成需要的拷⻉，所以不需要我们显⽰实现拷⻉构造。像Stack这样的类，虽然也都是内置类型， 但是_a指向了资源，编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)（也就是深拷贝） 。像MyQueue这样的类型内部主要是⾃定义类型Stack成员，编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造，也不需要我们显⽰实现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;
	}
	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不显⽰实现拷⻉构造，⽤⾃动⽣成的拷⻉构造完成浅拷⻉
	// 会导致st1和st2⾥⾯的_a指针指向同⼀块资源，析构时会析构两次，程序崩溃
	Stack st2(st1);
    //Stack st3 = st1;//拷贝构造也可以这么写
	return 0;
}

通过调试：

发现问题：

解决问题：

在public下，自己写一个拷贝构造：

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;
}

引用的好处：（体现）：
 

#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(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);//这样是不行的，这时候st是st1的深拷贝，st的改变不会影响st1，另一个层度警示我们：自定义类型用传值传参不好，尽可能用引用，不改变时用const引用
	// Stack不显⽰实现拷⻉构造，⽤⾃动⽣成的拷⻉构造完成浅拷⻉
	// 会导致st1和st2⾥⾯的_a指针指向同⼀块资源，析构时会析构两次，程序崩溃
	//Stack st2(st1);
	return 0;
}

6. 传值返回会产⽣⼀个临时对象调⽤拷⻉构造，传值引⽤返回，返回的是返回对象的别名(引⽤)，没有产⽣拷⻉。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使⽤引⽤返回是有问题的，这时的引⽤相当于⼀个野引⽤，类似⼀个野指针⼀样。传引⽤返回可以减少拷⻉，但是⼀定要确保返回对象，在当前函数结束后还在，才能⽤引⽤返回；
传值返回：

传引用返回：

从栈帧上理解:

确保出了作用域，st还在：传引用返回还减少了拷贝

Stack& func2()
{
	static Stack st;//这时候是静态对象，全局对象了
	return st;
}
int main()
{
	Stack ret = func2();
	return 0;
}

还可以：

Stack func2(Stack& st)
{
	st.Push(1);
	st.Push(1);
	st.Push(1);
	return st;
}
int main()
{
	Stack st1;
	func2(st1);
	return 0;
}

 可以在拷贝构造函数中添加一行代码，进行更好的观察：没有调用拷贝构造：

cout << "Stack(const Stack& st)" << endl;//检验是否调用拷贝构造