C++日期类的实现

类的定义

#pragma once
#include < iostream>
using std::cout;
using std::cin;
using std::endl;
class Date
{
public:
	// 获取某年某月的天数
	int GetMonthDay(int year, int month);
	// 全缺省的构造函数
	Date(int year = 0, int month = 1, int day = 1);
	void Print();
    //析构，拷贝构造，赋值重载函数可以不用写，默认生成的就够用
	//日期+=天数
	Date& operator+=(int day);

	// 日+天数
	Date operator+(int day);

	// 日期-天数
	Date operator-(int day);

	// 日期-=天数
	Date& operator-=(int day);

	// 前置++
	Date& operator++();

	// 后置++   
	Date operator++(int);

	//后置--   
	Date operator--(int);
	
	// 前置--
	Date& operator--();
	
	// >运算符重载
	bool operator>(const Date& d);

	// ==运算符重载
	bool operator==(const Date& d);

	// >=运算符重载
	bool operator >= (const Date& d);

	// <运算符重载
	bool operator < (const Date& d);

	// <=运算符重载
	bool operator <= (const Date& d);

	// !=运算符重载
	bool operator != (const Date& d);

	// 日期-日期 返回天数
	int operator-(const Date& d);

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

确定某年某月有多少天

//因为闰年和平年二月份的天数不一样，随便加加减减会有问题，这个函数可以根据闰年和平年给出对应的天数
//因为后面需要频繁调用它，设置成内联函数
inline int Date::GetMonthDay(int year, int month) {
	//设置成静态变量，不用每次调用这个函数都开辟一个数组
	static int arr[13] = {0,31,28,31,30,31,30,31,31,30,31, 30, 31};
	int day = arr[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) {
	//防止给的日期有错误
	if (year >= 0 && month > 0 && month < 13 
		&& day >0 && day <= GetMonthDay(year, month)) {
		_year = year;
		_month = month;
		_day = day;
	}
	else {
		cout << "非法日期" << endl;
		cout << year << "年" << month << "月" << day << "日" << endl;
	}
}

打印日期

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

日期+=天数

Date& Date::operator+=(int day) {
	if (day < 0){
		*this -= (-day);
	}
	else {
		_day += day;
		//如果天数大于月份对应的最大天数，就先减去这个月天数，然后月份++，然后再判断月份对应的天数对不对，往复循环
		while (_day > GetMonthDay(_year, _month)) {
			_day -= GetMonthDay(_year, _month);
			++_month;
			if (_month > 12) {
				++_year;
				_month = 1;
			}
		}
		//如果是传值返回的话传的是他的一个拷贝临时变量，又需要调用拷贝构造函数，因为出了函数作用域对象还在，所以传引用更好。
	}
	return *this;
}

日期+天数

Date Date::operator+(int day) {
	Date ret(*this);
	//复用operator+=函数
	ret += day;
	//ret是一个局部变量，出了作用域就销毁了，传不了引用
	return ret;
}

日期-=天数

Date& Date::operator-=(int day) {
	if (day < 0) {
		*this += (-day);
	}
	else {
		_day -= day;
		while (_day <= 0) {
			--_month;
			if (_month < 1) {
				--_year;
				_month = 12;
			}
			_day += GetMonthDay(_year, _month);
		}
	}
	return *this;
}

日期-天数

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

前置++

//返回的是++后的值，可以复用+=函数，逻辑是一样的，把day换成1即可
Date& Date::operator++() {
	*this += 1;
	return *this;
}

后置++

//返回的是++前的值，不能传引用返回
//为了和前置++赋值重载函数构成函数重载，需要加个int ，不需要传实参，因为没用,如果不加参数那么前置++和后置++函数就一样了，们在进行前置++或者后置++操作时，编译器就不知道调用哪一个了
Date Date::operator++(int) {
	Date ret(*this);
	*this += 1;
	return ret;
}

后置–

//返回原对象，然后对象再--
Date Date::operator--(int) {
	Date ret = *this;
	*this -= 1;
	return ret;
}

前置–

返回--后的对象
Date& Date::operator--() {
	*this -= 1;
	return *this;
}

>运算符重载

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

==运算符重载

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

>=运算符重载

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

<运算符重载

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

<=运算符重载

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

!=运算符重载

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

计算两个日期之间的间隔天数，日期减去日期

int Date::operator-(const Date& d) {
	Date min = *this;
	Date max = d;
	int flag = -1;
	int daycount = 0;
	if (*this > d) {
		min = d;
		max = *this;
		flag = 1;
	}
	while (min != max) {
		++min;
		daycount++;
	}
	return flag * daycount;
}