用日期计算器通杀运算符重载

一、运算符重载规则
1、不能创建新的操作符
2、必须有一个自定义类型参数（不能全是内置类型）
3、不能改变内置类型运算符的含义
4、成员函数第一个参数为隐藏的this
5、不能重载的五个运算符：     .*     ：：     sizeof     ？：     .

二、赋值重载
· 运算符重载函数：已经存在的两个对象之间复制拷贝
· 拷贝构造函数：用一个已经存在的对象初始化，另一个对象
出了作用域*this（解引用）还在，所以可以用引用返回

#include"Date.h"
int main()
{
	Date d1(2023, 7, 21);
	Date d2 = d1;  //已经存在的两个对象互相拷贝：运算符重载函数
	Date d3(d1);   //用一个已经存在的对象初始化另一个对象：拷贝构造函数
}

· 对象的传值要调用拷贝构造，指针传递不需要，因为指针全部都是内置类型

· 赋值运算符只能重载成类的成员函数，不能重载成全局函数（否则冲突）（就像亲儿子只能在家吃饭）（也可以在类里面给声明，类外面给定义）
默认成员函数也不能重载成全局函数

· 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝，相当于拷贝构造。
Date和MyQueue不需要我们自己实现赋值重载，Date是内置类型成员，Myqueue是自定义类型成员。内置类型直接转换成对应的指令，自定义类型调函数。
Stack需要我们自己实现深拷贝，因为默认生成的是浅拷贝。

三、流插入与流提取
· 流插入（从左往右执行）
cout是ostream类型的对象
自动识别类型实际上是运算符重载
可以直接支持内置类型是库里面实现了
可以直接支持自定识别类型是因为函数重载
· 问题出现：流插入不能写成成员函数，因为date对象默认占用第一个参数就是做了左操作数，写出来不符合使用习惯

// 写出来就一定是下面这样子，不符合使用习惯
	//d1 << cout; // d1.operator<<(cout); 
void operator<<(ostream& out);

解决方案：
成员可以访问私有，全局访问不了私有
法1：写一个公有的成员函数getyear（只可获取，不可修改）
法2：友元函数声明friend

· 流提取（流插入流提取得优先级比大于小于高）
cin是istream类型的对象（流提取和流插入一样，不能用const修饰）
· 成员函数后面加const以后，普通和const对象都可以调用（如+   -）
问：能不能所有成员函数都加这个const？
答：不是，要修改对象成员变量的函数不能加。（如+=   -=）
总结：只要成员函数内部不修改成员变量，都应该加const，这样const对象和普通对象都可以调用。

日期计算器代码如下：

拓展知识： 友元函数，友元类
· 友元函数可访问类的私有和保护成员，但不是类的成员函数。
· 友元函数不能用cons修饰。(因为没有this指针）
· 友元函数可以在类定义的任何地方声明，不受类访问限制。
· 一个函数可以是多个类的友元函数。
· 友元函数的调用与普通函数的调用原理相同。
· 内部类是外部类的天生友元。（但外部类不能访问内部类的私有成员）（所以外部类定义私有，内外皆可访问）
· 成员变量，成员函数，内部类会收到访问限定符的限制。

//Date.h

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;

class Date
{
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);//友元函数
public:
	Date(int year = 1, int month = 1, int day = 1);
	void Print() const
	{
		/*cout << Getyear() << "-" << Getmonth() << "-" << Getday() << endl;*/
		cout << _year << "-" << _month << "-" << _day << endl;
	}

	//int Getyear()const
	//{
	//	return _year;
	//}

	//int Getmonth()const
	//{
	//	return _month;
	//}

	//int Getday()const
	//{
	//	return _day;
	//}

	bool operator<(const Date& x) const;
	bool operator==(const Date& x) const;
	bool operator<=(const Date& x) const;
	bool operator>(const Date& x) const;
	bool operator>=(const Date& x) const;
	bool operator!=(const Date& x) const;

	int Getmonthday(int year, int month);

	Date& operator+=(int day);
	Date& operator-=(int day);
	Date operator+(int day) const;
	Date operator-(int day) const;

	Date& operator++();
	Date operator++(int);

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

	int operator-(Date& d) const;


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

//Date.cpp

#include"Date.h"

using namespace std;

Date::Date(int year , int month , int day )
{
	if (month > 0 && month < 13
		&& day>0 && day <= Getmonthday(year, month))
	{
		_year = year;
		_month = month;
		_day = day;
	}
	else
	{
		cout << "非法日期" << endl;
		assert(false);
	}
}
bool Date::operator<(const Date& x) const
{
	if (_year < x._year)
	{
		return true;
	}
	else if (_year == x._year && _month < x._month)
	{
		return true;
	}
	else if (_year == x._year && _month == x._month && _day < x._day)
	{
		return true;
	}
	else
	{
		return false;
	}
}


bool Date::operator==(const Date& x) const
{
	return _year == x._year
		&& _month == x._month
		&& _day == x._day;
}


bool Date::operator<=(const Date& x) const
{
	return *this < x || *this == x;
}

bool Date::operator>(const Date& x) const
{
	return !(*this <= x);
}

bool Date::operator>=(const Date& x) const
{
	return !(*this < x);
}

bool Date::operator!=(const Date& x) const
{
	return (*this == x);
}

int Date::Getmonthday(int year, int month)
{
	static int daysArr[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 daysArr[month];
	}
}

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) const
{
	Date tmp(*this);
	tmp += day;
	return tmp;
}

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-(int day) const
{
	Date tmp(*this);
	tmp -= day;
	return tmp;
}

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

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

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

//日期相减
int Date::operator-(Date& d) const
{
	Date max = *this;
	Date min = d;
	int flag = 1;
	if (*this < d)
	{
		max = d;
		min = *this;
		flag = -1;
	}
	int n = 0;
	while (max != min)
	{
		min++;
		n++;
	}
	return n * flag;
}

ostream& operator<<(ostream& out,const Date&d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
	return out;
}

istream& operator>>(istream& in, Date& d)
{
	int year, month, day;
	in >> year >> month >> day ;

	if (month > 0 && month < 13
		&& day > 0 && day <= d.Getmonthday(year, month))
	{
		d._year = year;
		d._month = month;
		d._day = day;
	}
	else
	{
		cout << "非法日期" << endl;
		assert(false);
	}

	return in;
}