C++类的默认成员函数 —— 赋值重载

一、概念

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

函数名字为：关键字operator后面接需要重载的运算符符号。

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

注意：

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

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

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

4、 .*   ::   sizeof   ?:   .    注意以上5个运算符不能重。

二、赋值运算符重载格式

参数类型：const T&，传递引用可以提高传参效率

返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值检测是否自己给自己赋值

返回*this ：要复合连续赋值的含义 

三、 赋值运算符只能重载成类的成员函数不能重载成全局函数

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

四、 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

下面写一个完整的日期类来实现赋值运算符的重载：

Date.h 文件 

#pragma once
#include <assert.h>

#include <iostream>
using namespace std;

class Date
{

	// 友元函数 ==> 这个函数内部可以使用 Date 对象访问私有保护成员
	//friend void operator<<(ostream& out, const Date& d); // 只能输出一个 cout << d1 不支持连续输出 cout << d1 << d2;
	friend ostream& operator<<(ostream& out, const Date& d); // 只能输出一个 cout << d1 不支持连续输出 cout << d1 << d2;
	friend istream& operator>>(istream& out, Date& d); 

public:
	// 构造函数频繁调用，所以直接放在类里面定义作为 inline
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;

		if (!CheckDate())
		{
			Print();
			cout << "初始日期错误" << endl;
		}
	}

	bool operator == (const Date& d) const;
	bool operator > (const Date& d) const;
	bool operator < (const Date& d) const;
	bool operator >= (const Date& d) const;
	bool operator <= (const Date& d) const;
	bool operator != (const Date& d) const;
	
	int GetMonthDay(int year, int month)
	{
		// 加 static 为了防止多次频繁调用函数之后多次频繁创建数组，加 static 数组在静态区上创建 每次访问都是这一个
		static int Month_Day[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
		if (month == 2 
			&& ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
		{
			return 29;
		}
		else
		{
			return Month_Day[month];
		}
	}

	// 检查最开始就把日期写错
	bool CheckDate()
	{
		if (_year >= 1
			&& _month >= 1 && _month <= 12
			&& _day >= 1 && _day <= GetMonthDay(_year, _month))
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	//void Print();
	void Print() const;

	// d1 + day
	Date operator + (int day) const;
	Date& operator += (int day);

	// d1++ 后置++,返回++之后的
	// ++d1 前置++,返回++之前的
	// 直接按特性重载，无法区分
	// 特殊处理，使用重载区分 后置 ++ 重载增加一个 int 参数跟前置构成函数重载进行区分
	// Date operator++(); // 这样的话没办法区分写的是前置还是后置

	Date& operator++(); // 前置
 	Date operator++(int); // 后置 加不加形参接收不接收都可以 但是规定类型是 int


	// d1 - day
	Date operator - (int day) const;
	Date& operator -= (int day);

	Date& operator--();
	Date operator--(int);

	// d2 - d1 ==> 日期 - 日期 = 天数
	int operator - (Date& d) const;

	// 输出流 << 操作符 <==> 操作符可以接收内置类型的 无法接受自定义类型
	// void operator<<(ostream& out); // 默认第一个参数是 this （放这里不太合适）

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

// 流插入重载
// 
// void operator<<(ostream& out, const Date& d); // 放在类外面 将参数的位置可以改变
// 会被频繁调用 输出多行 应该加上 inline 
// ostream& operator<<(ostream& out, const Date& d); // 放在类外面 将参数的位置可以改变
// 加上 inline 又链接不上，内联 不进 符号表 链接找不到 ===> 所以 定义 和 声明 不要分离
inline ostream& operator<<(ostream& out, const Date& d)
{
	// 因为函数在类外面定义的 所以无法访问 private 的成员
	// 解决办法 1. 用 get_year get_month get_day  2. 把 private 的成员放开 public (不建议)  3. 友元函数
	out << d._year << "-" << d._month << "-" << d._day << endl;
	return out;
}

// 流提取重载
inline istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	
	assert(d.CheckDate());

	return in;
	
}

Date.cpp 文件

#define _CRT_SECURE_NO_WARNINGS 1

#include "Date.h"

// 任何一个类要重载运算符只需要写一个 >和== 或者 <和== 重载, 剩下比较运算符复用即可

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

// d1 > d2
bool Date::operator > (const Date& d) const
{
	if ((_year > d._year)
		|| (_year == d._year && _month > d._month)
		|| (_year == d._year && _month == d._month && _day > d._day))
	{
		return true;
	}
	else
	{
		return false;
	}
}

// d1 < d2
bool Date::operator < (const Date& d) const// Date* const this, const Date
{
	return !(*this >= d);
}

// d1 >= d2
bool Date::operator >= (const Date& d) const
{
	return (*this > d) || (*this == d);
}

// d1 <= d2
bool Date::operator <= (const Date& d) const
{
	return !(*this > d);
}

// d1 != d2
bool Date::operator != (const Date& d) const
{ 
	return !(*this == d); // 逻辑取反
}


// 先写 += 再复用到 + （调用两次拷贝）
// d1 + day
Date Date::operator + (int day) const // 不加引用;因为 ret 出了 Date 作用域就销毁了
{
	Date ret(*this); // 拷贝构造

	ret += day;

	return ret; // 返回 ret 然后会拷贝构造
}

// d1 += day
Date& Date::operator += (int day)
{
	if (day < 0)
	{
		return *this -= -day;
	}

	_day += day;
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		_month++;
		if (_month == 13)
		{
			_year++;
			_month = 1;
		}
	}
	return *this;
}

// 如果先写 + 再复用到 += （会调用多次拷贝效率低）
//Date Date::operator + (int day) // 不加引用;因为 ret 出了 Date 作用域就销毁了
//{
//	Date ret(*this); // 拷贝构造
//
//	ret._day += day;
//	while (ret._day > GetMonthDay(ret._year, ret._month))
//	{
//		ret._day -= GetMonthDay(ret._year, ret._month);
//		ret._month++;
//		if (ret._month == 13)
//		{
//			ret._year++;
//			ret._month = 1;
//		}
//	}
//
//	return ret; // 返回 ret 然后会拷贝构造
//}
//
 d1 += day
//Date& Date::operator += (int day)
//{
//	*this = *this + day;
//
//	return *this;
//}

Date& Date::operator++() // 前置
{
	//*this += 1;
	//return *this;

	return *this += 1; // 返回值没有销毁 用引用返回
}

Date Date::operator++(int) // 后置
{
	Date temp(*this);
	*this += 1;

	return temp;
}

Date Date::operator-(int day) const
{
	Date temp(
		*this);
	temp -= day;
	return temp;
}

Date& Date::operator-=(int day)
{
	if (day < 0)
	{
		return *this += -day;
	}

	_day -= day;
	while (_day <= 0)
	{
		--_month;
		if (_month == 0)
		{
			_year--;
			_month = 12;
		}

		_day += GetMonthDay(_year, _month);
	}

	return *this;
}

Date& Date::operator--()
{
	return *this -= 1;
}

Date Date::operator--(int)
{
	Date temp(*this);
	*this -= 1;
	return temp;
}

// d2 - d1 ==> 日期 - 日期 = 天数
int Date::operator - (Date& d) const
{
	int flag = 1;
	Date max = *this;
	Date min = d;

	if (max < min)
	{
		max = d;
		min = *this;
		flag = -1;
	}

	int n = 0;
	while (min != max)
	{
		min++;
		n++;
	}

	return n * flag;
}

 流操作符 << 
//void Date::operator<<(ostream& out)  // 写在类里面的
//{
//	out << _year << "-" << _month << "-" << _day << endl;
//}
//void operator<<(ostream& out, const Date& d) // 放在类外面 将参数的位置可以改变
//ostream& operator<<(ostream& out, const Date& d) 
//{
//	// 因为函数在类外面定义的 所以无法访问 private 的成员
//	// 解决办法 1. 用 get_year get_month get_day  2. 把 private 的成员放开 public (不建议)  3. 友元函数
//	out << d._year << "-" << d._month << "-" << d._day << endl;
//	return out;
//}

//void Date::Print() // const Date* const this  
void Date::Print() const // const Date*
{
	cout << _year << "-" << _month << "-" << _day << endl;
}

TestDate.cpp 文件

//void TestDate1()
//{
//	Date d1(2022, 11, 8);
//
//	(d1 + 4).Print();   // 跨天
//	(d1 + 40).Print();  // 跨月
//	(d1 + 400).Print(); // 跨年
//	(d1 + 4000).Print();// 跨闰年
//
//	Date ret1 = ++d1; // d1.operator++(&d1)
//	Date ret2 = d1++; // d1.operator++(&d1, 0) 整数传什么都可以 只是为了构成重载进行区分
//}

void TestDate2()
{
	Date d1(2022, 11, 14);

	//(d1 - 4).Print();   // 跨天
	//(d1 - 40).Print();  // 跨月
	//(d1 - 400).Print(); // 跨年
	//(d1 - 4000).Print();// 跨闰年

	//Date ret1 = ++d1; // d1.operator++(&d1)
	//Date ret2 = d1++; // d1.operator++(&d1, 0) 整数传什么都可以 只是为了构成重载进行区分

	Date d2(2000, 5, 1);
	Date d3(2022, 11, 14);

	cout << d3 - d2 << endl;
	cout << d2 - d3 << endl;

}	

void TestDate3()
{
	// 初始日期错误
	Date d1(2022, 11, 32);
	Date d2(2022, 2, 29);
}

void TestDate4()
{
	Date d1(2022, 11, 20);

	// cout << d1; // 因为函数写在类里面 默认第一个参数是 this(d1) 所以应该是 d1 << cout 
	// d1.operator<<(cout);
	// d1 << cout; // 但是这样写的话有与 cout << 不合适 ; 所以函数可以写在类外面将参数位置改变

	cout << d1;
	Date d2(2000, 5, 1);
	Date d3(2022, 11, 14);
	cout << d1 << d2 << d3;

	cin >> d1 >> d2 >> d3;
	cout << d1 << d2 << d3;

}

void menu()
{
	cout << "***************************" << endl;
	cout << "*****  1. 日期加/减天数 *****" << endl;
	cout << "*****  2. 日期减日期    *****" << endl;
	cout << "*****  3. 日期->周几    *****" << endl;
	cout << "*****    -1. 退出      *****" << endl;
	cout << "***************************" << endl;
}

void TestDate5()
{
	const char* WeekDayToStr[] = { "周一", "周二", "周三", "周四", "周五", "周六", "周天" };

	Date d1, d2;
	int day = 0;
	int input = 0;

	do
	{
		menu();

		cout << "请选择:";
		cin >> input;

		if (input == 1)
		{
			cout << "请输入日期及天数(减天数输入负数):";
			cin >> d1 >> day;
			cout << "日期加减天数后的日期为:" << d1 + day << endl;
		}
		else if (input == 2)
		{
			cout << "请依次输入两个日期:";
			cin >> d1 >> d2;
			cout << "相差的天数:" << d1 - d2 << endl;
		}
		else if (input == 3)
		{
			cout << "请输入日期:";
			cin >> d1;
			Date start(1, 1, 1);
			int n = d1 - start;
			int WeekDay = 0; // 初始周一  初始周几存在不确定
			//int WeekDay = 5; // 1 1 1 就是周六 但是中间删了 10 天
			WeekDay += n;
			//cout << "周" << WeekDay % 7 + 1 << endl; //
			cout << WeekDayToStr[WeekDay % 7] << endl; //


		}
		else
		{
			cout << "输入错误，请重新输入:" << endl;
		}

	} while (input != -1);


}

void TestDate6()
{
	// 只有 指针 和 引用 存在权限的放大和缩小

	Date d1(2022, 11, 23);
	const Date d2(2022, 11, 24);

	d1.Print(); // &d1  Date*
	//d2.Print(); // 权限放大,出错 &d2  const Date*
	d2.Print();


	// Date::operator <    Date* const this, const Date
	d1 < d2; // Date* < const Date*
	//d2 < d1; // const Date* < Date*  出错,权限放大 所以要加const ==> Date::operator < const

}


int main() 
{
	//TestDate1U
	//TestDate2();
	//TestDate3();
	//TestDate4();
	//TestDate5();
	TestDate6();

	return 0;
}