写在前面：

上一篇文章我们开始学习类内的默认成员函数，

这里是传送门，有兴趣可以去看看：http://t.csdn.cn/iXdpH

这篇文章我们继续来学习类和对象的知识。

目录

写在前面：

1. 拷贝构造

2. 拷贝构造函数为什么需要引用传参？

3. 深拷贝

4. 初识运算符重载

写在最后：

---

1. 拷贝构造

我们在创建一个对象的时候，能不能创建一个跟已经存在的对象一模一样的对象呢？

说人话就是能不能复制一个一模一样的对象？

这个时候我们就需要用到拷贝构造，

拷贝构造实际上就是构造函数的一个重载，

来看代码：

#include <iostream>
using namespace std;

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

	//d2(d1) 拷贝构造
	Date(Date d) {
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

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

int main()
{
	Date d1;
	Date d2(d1);

	return 0;
}

如果我们想要实现拷贝构造的逻辑，就是将我们想要拷贝的对象传过去，

然后在给我们新创建的对象赋值，但是，

我们如果像上面这段代码这样写，编译器会报错，这是为什么呢？

拷贝构造有一条规则：拷贝构造函数的参数有且只有一个，且必须是类类型对象的引用，

如果使用传值的方式，编译器就会直接报错，因为会引发无穷递归。

也就是我们需要这样实现：

#include <iostream>
using namespace std;

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

	//d2(d1) 拷贝构造
	Date(Date& d) {
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

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

int main()
{
	Date d1;
	Date d2(d1);

	return 0;
}

2. 拷贝构造函数为什么需要引用传参？

那这个时候问题来了，为什么不使用引用传参就会出错，

或者说就会出现所谓的无穷递归的情况？

还记得我们曾经学过的函数传参，实际上是需要拷贝一份传给函数作为形参的，

而在C++中，函数传参传递自定义类型的时候，自定义类型的拷贝会自动调用拷贝构造来完成，

这是C++祖师爷规定的，自定义类型的拷贝回自动调用拷贝构造，

这样就会导致，如果实现的拷贝构造是传值传参，在传参的时候自定义类型需要拷贝，

而自定义类型在拷贝的时候会自动调用拷贝构造，而调用拷贝构造的时候需要传一个自定义类型，

自定义类型传参又需要拷贝，而自定义类型的拷贝会自动调用拷贝构造......

这样就会导致程序进入无穷递归。

如果没有理解的话可以多读几遍上面的文字，

其实核心逻辑就只有两个：

1. C++规定自定义类型拷贝的时候会自动调用拷贝构造

2. 自定义类型作为函数参数传值调用的时候需要进行一次拷贝

这里其实又出现了新的疑问，

为什么C++要规定自定义类型拷贝的时候要自动调用拷贝构造呢？

实际上，C++是这样规定的：

1. 对于内置类型会直接拷贝

2. 而对于自定义类型会调用他的拷贝构造

至于为什么一定要调用他的拷贝构造，我们之后会学到深浅拷贝的知识，到时候就明白了。

不过拷贝构造的实现我们一般习惯再加一个const在前面：

#include <iostream>
using namespace std;

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

	//d2(d1) 拷贝构造
	Date(const Date& d) {
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

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

int main()
{
	Date d1;
	Date d2(d1);

	return 0;
}

有一层const保护这个对象，代码的健壮性更强一点。

这里就顺便举个例子吧 ，

来看这段代码：

#include <iostream>
using namespace std;

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

	//d2(d1) 拷贝构造
	Date(Date& d) {
		d._year = _year;
		d._month = _month;
		d._day = _day;

		//_year = d._year;
		//_month = d._month;
		//_day = d._day;
	}

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

int main()
{
	Date d1;
	Date d2(d1);

	return 0;
}

这段代码的逻辑实际上写反了，但是编译器是没有报错的，

如果发现不了，还是会造成不小的问题和麻烦：

 

但是，如果我们加上了const来修饰这个对象：

编译器就会报错提醒，这样代码就不容易出错了。 

所以我们最后的完全体代码就是这样：

#include <iostream>
using namespace std;

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

	//d2(d1) 拷贝构造
	Date(const Date& d) {
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

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

int main()
{
	Date d1;
	Date d2(d1);

	return 0;
}

3. 深拷贝

学习深拷贝之前，我们先来看看编译器给我们默认生成的拷贝构造做了什么：

来看这段代码：

#include <iostream>
using namespace std;

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

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

int main()
{
	Date d1;
	Date d2(d1);

	return 0;
}

我们没有自己实现拷贝构造，

通过调试可以看看，默认生成的拷贝构造做了什么：

走到这一步我们可以看到，d1已经通过构造函数完成了初始化，

 

 我们可以看到，默认生成的拷贝构造完成了拷贝，

而且，我们还能发现，默认生成的拷贝构造好像跟我们实现的功能是一样的，

也就是说以后我们想这个Date类的拷贝构造，我们不用自己实现，

直接用默认生成的就行了，

那如果是这样，我们还学拷贝构造干啥，直接让编译器自动帮我们干不就完了，

那肯定没有这种好事，来看这个例子：

class Stack {
public:
	Stack(int capacity = 4) {
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr) {
			perror("Stack::malloc::fail");
			return;
		}
		
		_capacity = capacity;
		_top = 0;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};

int main()
{
	Stack st1;
	Stack st2(st1);

	return 0;
}

来调试看看编译器默认的拷贝构造干了什么：

这乍一看好像没毛病啊，

默认生成的拷贝构造也帮我们好好拷贝了一份一模一样的数据啊，

先不着急，我们还没给这个栈实现析构函数呢，不然会有内存泄漏的风险的：

#include <iostream>
using namespace std;

class Stack {
public:
	Stack(int capacity = 4) {
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr) {
			perror("Stack::malloc::fail");
			return;
		}
		
		_capacity = capacity;
		_top = 0;
	}

	~Stack() {
		free(_a);
		_a = nullptr;
		_capacity = 0;
		_top = 0;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};

int main()
{
	Stack st1;
	Stack st2(st1);

	return 0;
}

还是这段代码，但是我们添加了析构函数，

这个时候我们先调用第一次析构函数，把st2的空间释放掉：

 当我们再去调用st1的析构函数，刚走到free，啪一下，很快啊

 程序就崩溃了，这是为啥，

仔细想想，刚刚free了哪个指针，如果两个栈对象的_a指针是指向同一块区域，

那么会发生什么？析构函数一次free就把两个栈空间都free了，

而两个栈对象要调用两次析构，同一块空间free两次自然程序就崩溃了，

发现了吗，这个时候编译器自动生成的默认的拷贝构造函数就不能用了。

那该怎么解决呢？

其实就是用所谓的深拷贝解决：

#include <iostream>
#include <cstring>
using namespace std;

class Stack {
public:
	Stack(int capacity = 4) {
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr) {
			perror("Stack::malloc::fail");
			return;
		}
		
		_capacity = capacity;
		_top = 0;
	}

	//深拷贝
	Stack(const Stack& st) {
		_a = (int*)malloc(sizeof(int) * st._capacity);
		if (_a == nullptr) {
			perror("Stack::malloc::fail");
			return;
		}

		memcpy(_a, st._a, sizeof(int) * st._top);
		_top = st._top;
		_capacity = st._capacity;
	}

	~Stack() {
		free(_a);
		_a = nullptr;
		_capacity = 0;
		_top = 0;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};

int main()
{
	Stack st1;
	Stack st2(st1);

	return 0;
}

这个时候我们可以看到，实现了深拷贝之后，

两个_a指向空间的地址就不同了，这也意味着他们是两段不相关的空间了，

这样子程序当然也不会崩溃了。 

所以说如果遇到这样需要开辟空间的情况，就得自己手动实现深拷贝。

4. 初识运算符重载

我们来看这样一个例子：

#include <iostream>
using namespace std;

class A {
public:
	A(int x = 10, int y = 10) {
		_x = x;
		_y = y;
	}

private:
	int _x;
	int _y;
};

int main()
{
	A a1(10, 10);
	A a2(20, 20);

	return 0;
}

假如说我们想让 a1 和 a2 比较看看谁大，

可以直接用 a1 > a2 来进行比较吗？显然不能，

编译器并不知道你这个自定义类型的比较规则，

如果我们想让一个自定义类型做比较，最好就是写一个比较函数：

#include <iostream>
using namespace std;

class A {
public:
	A(int x = 10, int y = 10) {
		_x = x;
		_y = y;
	}

//private:
	int _x;
	int _y;
};

//这段比较逻辑是：如果a1 > a2 就返回true,否则就返回false
bool Compare(A a1, A a2) {
	if (a1._x > a2._x) {
		return true;
	}
	else if (a1._x == a2._x) {
		if (a1._y > a2._y) {
			return true;
		}
		else if (a1._y == a2._y) {
			return false;
		}
		else {
			return false;
		}
	}
	else {
		return false;
	}
}

int main()
{
	A a1(10, 10);
	A a2(20, 20);
	cout << Compare(a1, a2) << endl;

	return 0;
}

如果是这样实现，我们不仅要把private的成员变量放出来，

还得调用函数才能进行比较，感觉很不爽，

C++就设置了操作符重载：

#include <iostream>
using namespace std;

class A {
public:
	A(int x = 10, int y = 10) {
		_x = x;
		_y = y;
	}

//private:
	int _x;
	int _y;
};

//这段比较逻辑是：如果a1 > a2 就返回true,否则就返回false
bool operator>(A a1, A a2) {
	if (a1._x > a2._x) {
		return true;
	}
	else if (a1._x == a2._x) {
		if (a1._y > a2._y) {
			return true;
		}
		else if (a1._y == a2._y) {
			return false;
		}
		else {
			return false;
		}
	}
	else {
		return false;
	}
}

int main()
{
	A a1(10, 10);
	A a2(20, 20);

	//这样就能直接使用 > 来进行比较，而使用 > 其实就是使用了下面那个函数
	cout << (a1 > a2) << endl; 
	cout << operator>(a1, a2) << endl;

	return 0;
}

这样子我们通过C++支持的操作符重载成功实现了直接用 > 进行比较，

但是从private里面放出来的成员变量又该怎么办呢？

我们可以把operator这个函数放进类里面，

那具体应该怎么操作呢？我们下一篇文章再来揭晓。

写在最后：

以上就是本篇文章的内容了，感谢你的阅读。

如果感到有所收获的话可以给博主点一个赞哦。

如果文章内容有遗漏或者错误的地方欢迎私信博主或者在评论区指出~