1.拷贝构造函数的特性：

1.拷贝构造函数用来构造一个与已存在对象一摸一样的对象
它只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。
2.拷贝构造函数是构造函数的一种重载形式。
3.形参只有一个（不包括隐含的this指针），且必须是类类型对象的引用，否则会发生无限递归。

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)
	//错误写法：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,2,6);
	Date d2(d1);
	d1.Print();
	d2.Print();
}

错误写法会引发无限递归：

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

#include<iostream>
using namespace std;
class Time
{
public:
	Time(int hour=1,int minute=1,int second=1)
	{
		_hour = hour;
		_minute = minute;
		_second = second;
		cout << "Time()" << endl;
	}
	Time(const Time& d)
	{
		_hour = d._hour;
		_minute = d._minute;
		_second = d._second;
		cout << "Time(const Time& d)" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};
int main()
{
	Date d1;
	Date d2(d1);
}

从运行结果可以看出：：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的

5.深拷贝
看下面一段代码：

#include<iostream>
using namespace std;
class Stack
{
public:
	Stack(size_t capacity=5)
	{
		_arry = (int*)malloc(sizeof(int) * capacity);
		_capacity = capacity;
		_size = 0;
	}
	void Push(int data)
	{
		_arry[_size] = data;
		_size++;
	}
	~Stack()
	{
		if (_arry)
		{
			free(_arry);
			_arry = nullptr;
			_size = 0;
			_capacity = 0;
		}
	}
private:
	int _size;
	int _capacity;
	int* _arry;
};
int main()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);
	s1.Push(3);
	s1.Push(4);
	Stack s2(s1);
	return 0;
}

程序崩溃的原因：s2是s1的拷贝，s1的_arry和s2的_arry指向同一块空间，根据析构函数调用的顺序可知，s2的_arry空间先被释放，也就是两者共同指向的空间被释放了，此时s1成为野指针。s2的析构函数调用完以后，s1的析构函数接着被调用，一块空的空间又被释放了一次，所以此时程序崩溃。


用深拷贝改写正确：

class Stack
{
public:
	Stack(size_t capacity = 5)
			{
				_arry = (int*)malloc(sizeof(int) * capacity);
				_capacity = capacity;
				_size = 0;
			}
	Stack(const Stack&s)
	{
	//重新开辟一块空间：
		int* tmp = (int*)malloc(sizeof(int) * s._capacity);
		if (tmp == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		memcpy(tmp, s._arry, sizeof(int) * s._size);
		_arry = tmp;
		_size = s._size;
		_capacity = s._capacity;
	}
	void Push(int data)
	{
		_arry[_size] = data;
		_size++;
	}
	~Stack()
	{
		if (_arry)
		{
			free(_arry);
			_arry = nullptr;
			_size = _capacity = 0;
		}
	}
private:
	int _size;
	int _capacity;
	int* _arry;
};
int main()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);
	s1.Push(3);
	s1.Push(4);
	Stack s2(s1);
	return 0;

}

这是用两个编译器测试的结果，可以看出两个编译器调用析构函数的顺序不同。下面一张图对代码进行了调整，来测试三次调用拷贝构造函数中是否包括：对d拷贝时调用的构造函数，或返回tmp时构造临时变量而调用的构造函数。

这张图的代码中，我们省去了拷贝d所需要调用构造函数的步骤，也由此可见，上一张图中第二次调用拷贝构造函数是为了拷贝d1为形参d开空间。

对于以上运行测试结果的解释，可以参考下面的图