日期类的实现

---

头文件 （Date.h）

#pragma once

#include <iostream>
#include <assert.h>
#include <stdbool.h>
using std::cout;
using std::cin;
using std::endl;

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1);

	void Print();

	Date& operator+=(int days);

	Date operator+(int days);
	
	Date& operator-=(int days);
	Date operator-(int days);

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


	//两个日期相减
	int operator-(const Date& oneday);


	//前置++   ++d  ->   d.operator(&d);
	Date& operator++();
	//后置++   d++  ->d.operator(&d,int)
	//   int参数不许要给实参，只是为了和前置++构成重载
	Date operator++(int);


	//前置--
	Date& operator--();
	//后置--
	Date operator--(int);



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

源文件（Date.cpp）

#include "Date.h"

//判断闰年
bool is_leapyear(int year)
{
	if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
	{
		return true;
	}
	return false;
}


//准备好每个月的天数
inline int GetMonthDay(int year, int month)
{
	static int dayArray[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	int day = dayArray[month];

	if (month==2 && (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
	{
		day = 29;
	}

	return day;
}

构造函数

Date::Date(int year, int month, int day)
{
	//注意年月日的合法性
	//闰年
	assert(year >= 0);
	assert(month >= 1 && month <= 12);
	assert(day >= 1 && day <= GetMonthDay(year, month));
	_year = year;
	_month = month;
	_day = day;
}


void Date::Print()
{
	cout << _year <<"年" << _month << "月" << _day << "日" << endl;
}

日期+=天数

//日期加等天数
Date& Date::operator+=(int days)
{
	if (days < 0)//注意days是负数的情况，可复用 -=(-days)
	{
		*this -= (-days);
	}

	else
	{
		_day += days;
		//判断合法性
		while (_day > GetMonthDay(_year, _month))
		{
			_day -= GetMonthDay(_year, _month);
			_month++;
			if (_month > 12)
			{
				_year++;
				_month = 1;
			}
		}
	}
	
	return *this;
}

日期相加

Date Date::operator+(int days)
{
	//实现加号，是不会对this本身产生影响的
	//所以要新建对象
	Date tmp(*this);//拷贝构造


	//方法一，老老实实再把+=再写一遍，不过这里对象是tmp
	//tmp._day += days;
	//while (tmp._day > GetMonthDay(tmp._year, tmp._month))
	//{
	//	tmp._day -= GetMonthDay(tmp._year, tmp._month);
	//	tmp._month++;
	//	if (tmp._month > 12)
	//	{
	//		tmp._year++;
	//		tmp._month = 1;
	//	}
	//}

	//方法二，复用+= 我焯
	tmp += days;

	return tmp;
}

日期-=天数

// -= this的对象还在，可以返回引用
Date& Date::operator-=(int days)
{
	if (days < 0)//注意days是负数的情况，可复用+=(-days)
	{
		*this += (-days);
	}
	else
	{
		_day -= days;
		while (_day <= 0)
		{
			if (_month == 1)
			{
				_year--;
				_month = 12;
			}
			else
			{
				_month--;
			}

			_day += GetMonthDay(_year, _month);
		}
	}

	return *this;
}

日期的相减

//只是减的话不能对原有对象进行改变，要用临时变量传回值
Date Date::operator-(int days)
{
	Date tmp(*this);//拷贝构造

	//直接用上复用
	tmp -= days;//tmp.operator-=(days);

	return tmp;
}

日期的前后比较

//日期的比较
bool Date::operator==(const Date& oneday)
{
	return _year == oneday._year && _month == oneday._month && _day == oneday._day;
}

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

bool Date::operator>(const Date& oneday)//d1.operator(&d1,d2)
{
	//year比较
	if (_year > oneday._year)
	{
		return true;
	}
	else if (_year == oneday._year)
	{
		if (_month > oneday._month)
		{
			return true;
		}
		else if (_month == oneday._month)
		{
			if (_day > oneday._day)
			{
				return true;
			}
		}
	}
	return false;
}

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

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

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

两个日期的相减

// 日期-日期
int Date::operator-(const Date& oneday)
{
	int t_day = 0;//初始化返回值——日数

	Date max_date = *this;
	Date min_date = oneday;
	int k = 1;
	if (min_date > max_date)//复用重载符 >
	{
		min_date = *this;
		max_date = oneday;
		k = -1;
	}

	//小年离年终 剩余日
	int min_rest = GetMonthDay(min_date._year,min_date._month)-min_date._day;
	min_date._month++;
	while (min_date._month <= 12)
	{
		min_rest += GetMonthDay(min_date._year, min_date._month);
		min_date._month++;
	}
	min_date._year++;//

	//大年离年初 度过日
	int max_rest = max_date._day;
	max_date._month--;
	while (max_date._month >= 1)
	{
		max_rest += GetMonthDay(max_date._year, max_date._month);
		max_date._month--;
	}

	t_day = min_rest + max_rest;

	if (min_date._year > max_date._year )//同一年的日期
	{
		t_day -= (is_leapyear(min_date._year) ? 366 : 365);
		return t_day*k;
	}
	else
	{
		//计算年份差的日数
		while (max_date._year > min_date._year)
		{
			if (is_leapyear(min_date._year))
			{
				t_day += 366;
			}
			else
			{
				t_day += 365;
			}
			min_date._year++;
		}
	}

	return k * t_day;
}

日期的前置后置的 ++ –

//前置++ 
//可返回引用 因为是先加再用   
//++i表示先将i自增1，再返回i的引用，（是左值）
Date& Date::operator++()
{
	*this += 1;
	return *this;
}
//在类中重载前置++时，无参数，返回值类型为引用


//后置++ 
//只能返回拷贝 因为是先用再加，   形参的int  只是占位防止函数重载冲突   ++是单目运算符，
//i++表示先返回i的值，再自增1，（右值）。
Date Date::operator++(int)//编译器是认为int占位的是后置++，且返回值，缺一不可
{
	Date tmp(*this);
	++(*this);//复用，是“基于前置增量实现后置增量”的方法！
	return tmp;
}
//重载后置++时，需要一个int类型的参数（必须为int类型，这一参数仅为了与前置++区分开，不会用于计算），返回值非引用。

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

//后置--
Date Date::operator--(int)
{
	Date temp(*this);
	--(*this);
	return temp;
}

利用前置++，重写日期相减

//有了前置++后 可以另写一个日期相减的运算符重载
int Date::operator-(const Date& oneday)
{
	Date max_date = *this;
	Date min_date = oneday;
	int k = 1;
	if (min_date > max_date)//复用重载符 >
	{
		min_date = *this;
		max_date = oneday;
		k = -1;
	}
	int t_day=0;
	while (min_date != max_date) //程序的可读性更强
	{
		++min_date;
		++t_day;  
	}
	return t_day*k;
}