C++ 拷贝构造函数和运算符重载

一. 拷贝构造函数

1. 引入

2. 拷贝构造的概念

3. 浅拷贝

4. 深拷贝

二. C++运算符重载

1. 概念

2. 注意事项

3.举例

一. 拷贝构造函数

1. 引入

我们在创建对象时，能不能创建一个与原先对象一模一样的新对象呢？为了解决这个问题，C++提出了拷贝构造的概念。

2. 拷贝构造的概念

当我们想把一个对象赋值给另一个对象或者创建一个与已存在对象一某一样的新对象时需要调用它的拷贝函数来进行复制。我们以下面的代码举例：

#include<iostream>
using namespace std;

class Date 
{
public:
	Date(int year = 2024, int month = 3, int day = 14)
	{
		_year = year;
		_month = month;
		_day = day;
	}
    // Date(const Date d)    // 错误写法：编译报错，会引发无穷递归
	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);
//这样写也可以：Date d2 = d1;
	return 0;
}

拷贝构造函数也是特殊的成员函数，其特征如下：

1. 拷贝构造函数是构造函数的一个重载形式。

2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

为什么会引发无穷递归呢？是因为如果我们传值当形参的话那么形参是实参的一份临时拷贝又会拷贝构造函数这样就会无限递归下去。

所以我们在书写构造函数的时候一定要使用传引用当做形参。

3. 浅拷贝

我们知道C语言函数在传递参数时，会将实参的值传递给形参，中间自动存在一个变量的临时拷贝过程，那如果我们不写拷贝构造函数，编译器会发生什么情况呢？

我们发现仍然完成了值拷贝。这是因为拷贝构造函数没有显示定义的化，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。需要注意的是，在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。

4. 深拷贝

编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？我们来看下面的代码：

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (DataType*)malloc(capacity * sizeof(DataType));
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}
		_size = 0;
		_capacity = capacity;
	}
	void Push(const DataType& data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	size_t _size;
	size_t _capacity;
};
int main()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);
	s1.Push(3);
	s1.Push(4);
	Stack s2(s1);
	return 0;
}

这里刚开始创建了一个S1 对象，又创建了一个S2 对象去进行调用拷贝构造函数进行拷贝，而这里只进行了浅拷贝，在 S2 进行拷贝构造的时候只是简单的把值复制过去了所以 S2 和 S1 是指向同一块空间并没有给 S2 去单独开辟一个一模一样的空间。那为什么程序回出现崩溃呢？

S2 和 S1 指向用一块空间而当程序结束的时候 S2 调用它的析构函数去吧 S1 所指向的空间给释放了, 那么当 S1 在释放的时候就重复释放了原来释放的空间导致程序崩溃。一块空间不能被释放两次。

因此我们我们需要进行深拷贝：

#include<iostream>
#include<stdlib.h>
using namespace std;

class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (int*)malloc(capacity * sizeof(int));
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}

		_size = 0;
		_capacity = capacity;
	}
	Stack(const Stack& p1)
	{
		int* tmp = (int*)malloc(sizeof(int) * p1._capacity);
		if (tmp == nullptr)
		{
			perror("file malloc");
			exit(-1);			

		}

		memcpy(tmp, p1._array, sizeof(int) * p1._size);

		_array = tmp;
		_capacity = p1._capacity;
		_size = p1._size;
		
	}
	void Push(const int& data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	int* _array;
	size_t _size;
	size_t _capacity;
};
int main()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);
	s1.Push(3);
	s1.Push(4);
	Stack s2(s1);
	return 0;
}

所以我们需要动态申请空间，显示定义拷贝构造函数，把空间大小和值内容拷贝进去。

因此我们有以下总结：

类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。拷贝构造函数典型调用场景：使用已存在对象创建新对象函数参数类型为类类型对象，函数返回值类型为类类型对象。

二. C++运算符重载

1. 概念

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator操作符(参数列表)

2. 注意事项

不能通过连接其他符号来创建新的操作符：比如operator@

重载操作符必须有一个类类型参数用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义

作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this

以上下个运算符不能重载：

3.举例

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

bool operator==(const Date& d1, const Date& d2)
{
	return d1._year == d2._year
		&& d1._month == d2._month
		&& d1._day == d2._day;
}

int main()
{
	Date d1(2024, 3, 14);
	Date d2(2024, 3, 15);
	cout << (d1 == d2) << endl;
	return 0;
}