类和对象-3

拷贝构造函数

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

特点：

1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

话不多说，先上代码：

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& dsrc)
	{
		_year = dsrc._year;
		_month = dsrc._month;
		_day = dsrc._day;
	}
	void Print()
	{
		cout << _year << '/' << _month << '/' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2024, 3, 14);
	d1.Print();
	Date d2(d1);
	d2.Print();
	return 0;
}

根据代码的运行结果可以知道，d2拷贝了d1的成员变量。实际上这就是拷贝构造函数的作用。
此外，我们还要注意以下细节：

• 由于拷贝构造实质上是构造函数的重载形式，所以一般写拷贝构造前都要写一个构造函数。这是因为写了拷贝构造函数，编译器就会判定有构造函数所以不会自动生成构造函数。这样我们就没有默认构造函数，在某些对象实例化时可能会报错。
  实际上我们还可以强制编译器生成默认的构造函数来解决这个问题：

class Date
{
public:
	Date() = default;//强制生成默认构造函数
	Date(const Date&dsrc)
	{
	
	}
}

• 形参只能是引用而不是传值调用。因为传值调用的时候编译器会自动调用形参的拷贝构造,如果我们拷贝构造的函数是传值调用，那么形参就会调用它本身的拷贝构造也就是我们正在写的拷贝构造函数，然后又继续调用形参的拷贝构造函数…就形成了无穷递归调用。事实上这也告诉我们，形参为类的时候最好引用调用，这样能够减少拷贝构造的开销。
• 形参要用const修饰，正如上面所说，形参为类的时候最好是引用调用。引用调用多了，有时难免不小心修改了dsrc的值，所以为了安全起见，最好就是const修饰。而且由于常引用的一些特性，const修饰的形参能接受更多权限类型的实参，比如表达式（表达式的值为临时变量，临时变量具有常性）。

另外我们再来看一段代码：

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << '/' << _month << '/' << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2024, 3, 14);
	d1.Print();
	Date d2(d1);
	d2.Print();
	return 0;
}

上述代码我们将拷贝构造函数删除了，结果还是和有拷贝构造函数时一样。
这说明编译器会自动生成一个拷贝构造函数，并且这个默认生成的拷贝构造函数具有以下性质：

• 对于内置类型，会直接进行值拷贝
• 对于自定义类型，会调用其自带的拷贝构造函数

单看这个默认拷贝构造函数的性质，好像已经实现了我们想要实现的功能了，那我们是不是没必要手码拷贝构造函数呢？
别急先欣赏以下代码：

class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		_size = 0;
		_capacity = capacity;
	}
	~Stack()
	{
		free(_a);
	}
private:
	int* _a;
	int _size;
	int _capacity;
};
int main()
{
	Stack st1;
	Stack st2(st1);
	return 0;
}

结果代码报错了。这时怎么个事呢？
原来我们这个默认拷贝构造函数是浅拷贝，也就是st2.a和st1.a指向同一块空间，又因为程序结束时会自动调用析构函数。所以这一块a的空间被free了两次。那么解决方法也很简单，就是我们自行写一个拷贝函数来进行深拷贝。
如下：

	Stack(Stack& st)
	{
		this->_a = (int*)malloc(sizeof(int) * st._capacity);
		this->_capacity = st._capacity;
		this->_size = st._size;
	}

这样以后，运行时编译器就不会报错了。
总结：诚然很多时候拷贝构造函数是默认的就已经够用了，但如果遇到数组之类的需要深拷贝的变量就需要我们手动写拷贝构造函数了。

赋值运算符重载

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

注意：

• 不能通过连接其他符号来创建新的操作符：比如operator@
• 重载操作符必须有一个类类型参数
• 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
• 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
• “.”、“.*”、 “::” 、 “sizeof” 、“?:” 注意以上5个运算符不能重载。

例如前面我们所写的日期类就可以写一个函数来比较类的大小：

bool DateCompare(const Date& d1, const Date& d2)
{
	if (d1._year < d2._year)
	{
		return true;
	}
	else if (d1._year == d2._year)
	{
		if (d1._month < d2._month)
			return true;
		else if (d1._month == d2._month)
		{
			if (d1._day < d2._day)
				return true;
		}
	}
	return false;
}

当然这样具有一定局限性，比如我不知道小于的单词怎么拼写，所以就写了个比较，这大大降低了代码的可读性。
如果用运算符重载来写，那么可读性就会上升很多：

bool operator<(const Date& d1, const Date& d2)
{
	{
	if (d1._year < d2._year)
	{
		return true;
	}
	else if (d1._year == d2._year)
	{
		if (d1._month < d2._month)
			return true;
		else if (d1._month == d2._month)
		{
			if (d1._day < d2._day)
				return true;
		}
	}
	return false;
}
}
int main()
{
	Date d1(2024, 3, 14);
	Date d2(2024, 4, 28);
	cout << operator<(d1, d2) << endl;
	cout << (d1<d2) << endl;//<的优先级低于<<
	return 0;
}

这样我们就漂亮地实现了日期比小。当然上述实现方式还是有缺陷的，因为类的属性默认是private的，上面代码之所以能运行是因为我改成了public。所以最好的实现方式是将运算符重载写成类的成员函数。

bool operator<(const Date& d2)
{
	{
		if (this->_year < d2._year)
		{
			return true;
		}
		else if (this->_year == d2._year)
		{
			if (this->_month < d2._month)
				return true;
			else if (this->_month == d2._month)
			{
				if (this->_day < d2._day)
					return true;
			}
		}
		return false;
	}
}
int main()
{
	Date d1(2024, 3, 14);
	Date d2(2024, 4, 28);
	cout << d1.operator<(d2) << endl;
	cout << (d1<d2) << endl;
	return 0;
}

需要注意的是，成员函数默认有一个this指针的参数，所以运算符重载就需要少写一个参数。

赋值运算符重载

有了上述的运算符重载的知识，我们就可以实现赋值运算符的重载，赋值运算符重载具有以下特点：

• 参数类型：const class&，传递引用可以提高传参效率
• 返回值类型：class&，返回引用可以提高返回的效率，有返回值目的是为了持连续赋值
• 检测是否自己给自己赋值
• 返回*this ：要复合连续赋值的含义

class Date
{
public:
Date& operator=(const Date&d)
{
	_year=d._year;
	_month=d.month;
	_day=d._day;
	return *this;
}
private:
int _year;
int _month;
int _day;
};

首先为了提高效率我们传参是引用传参这点毋庸置疑。
然后为了符合赋值运算符可以连续赋值：

int i=5,j=10;
i=j=20;

那么，我们重载的赋值运算符就必须返回该类或者该类的引用，为了提高效率我们还是返回类的引用。
当然，如果你不想返回的类被修改可以在返回值上加const。
但是，cpp定义的赋值后结果是可以修改的哦：

int main()
{
	int i=5,j=10;
	(i=j)=20;
	cout<<i<<' '<<j<<endl;
	return 0;
}

由代码的运行结果可知，（i=j）返回的就是i本身，并且没有被const修饰。
此外，赋值运算符重载也是默认成员函数之一，当我们没有手码赋值运算符重载的时候，编译器就会生成一个赋值运算符重载函数，他的功能也是和默认的拷贝构造函数一致，对内置类型浅拷贝，自定义类型则调用它本身的赋值运算符重载。

• 根据赋值运算符重载是一个默认成员函数，我们可以从中看到它和其余运算符重载不同的地方：赋值运算符重载不能写成全局函数，因为会和编译器默认生成的赋值运算符重载函数冲突。
• 此外，当类的初始化写成如下形式：
  Date d2(d1);
  Date d3=d1;
  他们调用的都是拷贝构造函数，而非赋值运算符重载函数。