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

	//// 编译报错：error C2652: “Date”: ⾮法的复制构造函数: 第⼀个参数不应是“Date”
	//Date(Date d)//必须是引用

	Date(const Date& d)//如果还有其他参数，必须写在后面并且给缺省值，比如Date(const Date& d，int x=0)
	{
		_year = d._year;
		_month = d._month;//this->_month=d._month;
		_day = d._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;
};

void Func1(Date d)//自定义类型也建议传引用，以避免传参时调用拷贝构造函数不必要的消耗
{
	cout << &d << endl;
	d.Print();
}
// Date Func2()
Date& Func2()
{
	Date tmp(2024, 7, 5);
	tmp.Print();
	return tmp;
}

int main()
{
	Date d1(2024, 7, 5);
	// C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥传值传参要调⽤拷⻉构造
	// 所以这⾥的d1传值传参给d要调⽤拷⻉构造完成拷⻉，传引⽤传参可以较少这⾥的拷⻉
	Func1(d1);
	cout << &d1 << endl;

	// 这⾥可以完成拷⻉，但是不是拷⻉构造，只是⼀个普通的构造
	Date d2(&d1);
	d1.Print();
	d2.Print();

	//这样写才是拷⻉构造，通过同类型的对象初始化构造，⽽不是指针
	Date d3(d1);
	d2.Print();
	// 也可以这样写，这⾥也是拷⻉构造
	Date d4 = d1;//这里特别注意一下，与后面的赋值区分等d4=d3（d4原本就存在）
	d2.Print();

	// Func2返回了⼀个局部对象tmp的引⽤作为返回值
	// Func2函数结束，tmp对象就销毁了，相当于了⼀个野引⽤
	Date ret = Func2();
	ret.Print();
	return 0;

	Date d1(2024, 7, 5);
	Func1(d1);
}

Stack func()
{
	Stack st;//调用了两次拷贝构造第一次是st拷贝给临时对象第二次是临时对象拷贝给ret（没有任何编译器优化的情况下）
	return st;//返回⼀个临时对象，临时对象不受func函数销毁的影响
}
Stack& func1()
{
	Stack st;
    //static Stack st;ok，出了函数作用域后，st还存在
	return st;//返回st的别名，但st被销毁了，拷贝失败
}//编译器报警告：返回局部变量或临时变量的地址（引用的底层是指针） st
int main()
{
	Stack ret = func();
	return 0;
}
//所以使用传引用返回要注意虽然能够减少拷贝，但是一定要确保在当前函数结束后还在，没有销毁才能返回
//在这个程序中可以用static修饰

直接常见的QA：

为什么传值传参会无限递归：每次调用拷贝构造函数要先传值传参，传值传参是一种拷贝，又要形成新的拷贝构造函数，要调用拷贝构造就要先传值传参......从而就形成了无穷递归。

为什么加了&之后就不会无穷递归：引用传参的意思是形参时实参的别名，没有形成新的拷贝构造。

为什么类对象的引用要加const修饰：

1.防止意外修改源对象：如“==”写成了“=”，const 确保拷贝构造函数不会意外修改被拷贝的源对象。拷贝操作应该是"只读"的，不应该改变原始对象的状态。

2.允许拷贝临时对象和被声明为const对象。

为什么不能完全使用编译器⾃动⽣成的拷⻉构造：

在Stack这样的类中，_a指向了一块数组，用编译器所自动生成的拷贝构造（值拷⻉/浅拷⻉）拷贝出来的_a会指向源对象的数组，最后析构函数调用时，一块空间被析构两次，从而导致程序崩溃。不仅会导致程序崩溃，还会导致Push覆盖等等一系列问题。解决方法：用自己写的深拷贝(新对象_a先malloc源对象_a大小的空间，再把空间里的值拷贝过来，继续拷贝内置类型的成员，下面代码有进行演示)

//深拷贝操作Stack st2(st1);
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;
}

为什么自定义类型不建议使用传值传参：

1.性能开销：不必要的拷贝和析构

拷贝构造函数调用：传值会触发拷贝构造，如果对象包含大量数据（如动态数组、复杂嵌套结构），深拷贝可能导致显著性能损失。

析构开销：函数结束时，副本的析构函数会被调用，进一步增加开销。

2.资源管理的复杂性

深拷贝问题：如果类管理资源（如动态内存、文件句柄），错误的拷贝实现可能导致双重释放或内存泄漏。

不可拷贝类型：某些类禁用拷贝（如 std::unique_ptr），传值会导致编译错误。这个以后会了解到。

3.可能引发对象切割（Slicing Problem）

仅针对继承体系：如果参数是基类类型，而传递派生类对象，传值会导致派生类独有的部分被丢弃。（同样这个以后会详细了解）

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)
	{
		cout << " Date(const Date& d)" << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	// 传引⽤返回减少拷⻉
	// d1 = d2;返回d1。
	//为什么返回引⽤，因为传值返回要拷贝对象，而出了operator=函数后，d1（this）还在，为了减少拷贝，所以返回引⽤
	Date& operator=(const Date& d)
	{
		// 不要检查⾃⼰给⾃⼰赋值的情况
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		// d1 = d2表达式的返回对象应该为d1，也就是*this
		return *this;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2024, 7, 5);
	Date d2(d1);
	Date d3(2024, 7, 6);
	d1 = d3;

	// 需要注意这⾥是拷⻉构造，不是赋值重载
	// 请牢牢记住赋值重载完成两个已经存在的对象直接的拷⻉赋值
	// ⽽拷⻉构造⽤于⼀个对象拷⻉初始化给另⼀个要创建的对象
	Date d4 = d1;

	int i, j, k;
	i= j = k = 10;//连续赋值返回左操作数

	d4= d1 = d2;//连续赋值
	return 0;
}

一句话总结：如果要显示实现析构释放资源，就需要显示实现拷贝构造和赋值重载，反之，就不需要实现拷贝构造和赋值重载。