用C++实现一个日期类

---

1. 前言

在前面的章节中，已经初步理解类和对象的基本思想，也知道了类和对象的一些特性。

而前面一直贯穿着我们学习类和对象的例子“日期类(Date)”一直只是定义了它的属性，

而这一章我们就要运用前面的知识去完善这一个日期类的实现！

---

2. 日期类大致的功能概况

一些实现的注意点

1.日期类的构造函数和析构函数，其实编译器自己默认生成的已经够用了（对于日期类可选性自己实现）

2.拷贝构造函数必须使用传引用的方式返回，否则会造成无穷递归

3.主要区分前置++（–）和后置++（–）

相同点：两者的运算符都是 ++，所以易于混淆

不同点：因为本身难以区分，所以编译器帮了我们很大的忙，在调用++（–）运算符时，编译器当然可以辨别程序员输入的是前置还是后置，如果是后置，编译器在传参的时候就会传一个 int 类型的变量，在调用的时候如果发现什么参数都没有，

那就默认是前置++（–），如果发现参数中有一个 int 类型的形参，那么就会处理成后置的++（–），但是这里的 int形参什么事情都不做，只是为了区分前置和后置

---

class Date

{

public:

	// 获取某年某月的天数
	int GetMonthDay(int year, int month);
	
	// 全缺省的构造函数
	Date(int year = 1900, int month = 1, int day = 1);

	// 拷贝构造函数
	// d2(d1)
	Date(const Date& d);

	// 赋值运算符重载
	// d2 = d3 -> d2.operator=(&d2, d3)
	Date& operator=(const Date& d);

	// 析构函数
	~Date();
	// 日期+=天数
	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;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

3. 具体代码实现

头文件

//date.h文件
#pragma once 
#include
using namespace std;

class Date
{
	//友员声明
	//流输出
	friend ostream& operator<<(ostream& out, const Date&d); 
	//流输入
	friend istream& operator>>(istream& in, Date&d);
public:
	Date(int year = 1970, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}
	// 拷贝构造，这里不显式写法也够用
	//Date(const Date&d)
	//{
	//	_year = d._year;
	//	_month = d._month;
	//	_day = d._day;
	//}

	//析构函数，这里不写也够用
	//~Date()
	//{
	//	_year = 0;
	//	_month = 0;
	//	_day = 0;
	//}
	int GetMonthDay(int year, int month)
	{
		static int MonthDayArry[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 MonthDayArry[month];
		}
	}

	bool operator==(Date&d)const;

	bool operator!=(Date&d)const;

	bool operator>(Date&d)const;

	bool operator>=(Date&d)const;

	bool operator<(Date&d)const;

	bool operator<=(Date&d)const;

	Date& operator+=(int day);

	Date& operator-=(int day);

	Date operator+(int day)const;

	Date operator-(int day)const;

	int operator-(Date&d)const;

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

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

	Date& operator=(const Date& d);

private:
	int _year;
	int _month;
	int _day;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

功能函数实现文件

#include"Date.h"

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

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

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

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

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

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

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

Date& Date::operator-=(int 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 tem(*this);

	tem += day;
	return tem;
}

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

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 (min != max)
	{
		++n;
		++min;
	}

	return n*flag;
}

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

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

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

	return *this;
}


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

istream& operator>>(istream& in, Date&d)
{
	in >> d._year ;
	in >> d._month;
	in >> d._day;
	return in;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168