C++日期类的实现

#include <iostream>

using namespace std;

class Date

{

public:

	// 获取某年某月的天数

	int GetMonthDay(int year, int month)
	{
		static int days[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
		int day = days[month];
		//如果为二月，且是闰年，则修改天数
		if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
		{
			day += 1;
		}
		return day;
	}

	// 全缺省的构造函数

	Date(int year = 1900, int month = 1, int day = 1)
	{
		//判断日期是否有效
		if (year < 1900 || month < 1 || month > 12 || day < 1 || day > GetMonthDay(year, month))
		{
			//日期无效
			cout << "非法日期" << endl;
		}
		_year = year;
		_month = month;
		_day = day;
	}



	// 拷贝构造函数

  // d2(d1)

	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}



	// 赋值运算符重载
	//成员函数都会有一个this指针
	//运算符重载函数作为成员函数时，参数列表中显式定义的参数个数需要比实际的参数少一个

  // d2 = d3 -> d2.operator=(&d2, d3)

	Date& operator=(const Date& d)
	{
		//判断对象是否是同一个对象：通过指针判断
		if (&d != this)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}



	// 析构函数

	~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 > 12)
			{
				//年份进位
				_year++;
				//下一年的一月份
				_month = 1;
			}
		}
		//返回相加之后的结果
		return *this;
	}



	// 日期+天数
	//返回相加之后的结果，操作数不能改变
	Date operator+(int day)
	{
		//Date tmp = *this;
		Date tmp(*this);
		tmp += day;
		return tmp;
	}



	// 日期-天数

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



	// 日期-=天数

	Date& operator-=(int day)
	{
		if (day < 0)
		{
			return *this += -day;
		}
		_day -= day;
		while (_day < 1)
		{
			//用上一个月的天数回补
			--_month;
			//判断月份是否向下溢出
			if (_month < 1)
			{
				//需要回退到上一年的12月
				_year--;
				_month = 12;
			}
			_day += GetMonthDay(_year, _month);
		}
		return *this;
	}



	// 前置++

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



	// 后置++
	//int参数的作用：只是为了和前置++构成重载，函数内部不会用到
	Date operator++(int)
	{
		Date tmp(*this);
		*this += 1;
		//返回++之前的值
		return tmp;
	}



	// 后置--

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



	// 前置--

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

	// >运算符重载

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



	// ==运算符重载

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



	// >=运算符重载

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



	// <运算符重载

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



	// <=运算符重载

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



	// !=运算符重载

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



	// 日期-日期 返回天数

	int operator-(const Date& d)
	{
		//计算较小的日期经过多少次自加的运算，可以和较大的日期相同
		//自加的次数就是相差的天数
		int flag = 1;
		Date max = *this;
		Date min = d;
		if (max < min)
		{
			max = d;
			min = *this;
			int flag = -1;
		}
		int day = 0;
		while (min < max)
		{
			++min;
			++day;
		}
		return day * flag;
	}

private:

	int _year;

	int _month;

	int _day;

};