【C++】实现日期类运算符重载_c++日期类运算符重载

什么是日期类？

用C++来实现一个日期类Date，包括年(_year)、月（_month）、日(day),来实现对日期的自增(++)，自减(–)，加上特定天数(+days)，减去指定天数(-days)，输入输出的实现，以及通过输入两个特定的日期，来计算相隔的天数。其中会用到构造函数、拷贝构造函数、析构函数，以及多类运算符的重载。

日期类实现思路

在设计日期类过程中，有一个月份相对特殊，那就是二月。可以通过判断是否闰年来确定二月的天数，为了后面实现的方便与简洁，可以将12个月的天数存储于一个一维数组中。在运算符重载中，对this指针的迷惑可以查看 this指针的详解。重载中会巧妙运用引用&及const关键字，程序中会降低一些算法的复杂度，具体实现将在函数调用中详细介绍。

函数调用模块

①构造函数及非法日期判断(以1900-1-1日为下限)

// 全缺省参数构造函数
	Date(int year = 1997, int month = 11, int day = 4)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		//检查合法
		if (year >= 0
			&& _month > 0 && _month < 13
			&& _day > 0 && _day <= GetMonthDay(year, month))
		{
			_year = year;
			_month = month;
			_day = day;
		}
		else
		{
			cout << "Date Invalid" << endl;
		}
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

②拷贝构造函数(注意函数参数为const Date&类型)

//拷贝构造函数：Date d3(d1)或者 Date d3 = d1
	Date::Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
1
2
3
4
5
6
7

③析构函数（可以在里面打印"~Date",什么都不做也可以,对于动态开辟内存，在析构函数中free）

~Date()
	{
		;
	}
1
2
3
4

④ 判断是否闰年（4年一闰，逢百年不闰，400年一闰与获取某年某月的指定天数（判断闰年后月份已经确定，可存储于数组中方便调用）

//获取当月天数
int Date::GetMonthDay(int year, int month)
{
	//方法一：十二个if、else语句
	//方法二：switch分支语句
	//此处方法三：
	 static const int days[13] = {0, 31,28, 31,30, 31,30, 31,31,30, 31,30, 31 };//润年二月多一天
	 //4年一润百年不润400年一润且此处至于二月有关
	 if ((month == 2)&&((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
	 {
		 return 29;

	 }
	 return days[month];
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

⑤赋值运算符 = 重载(分两种情况：1.自己给自己赋值,但是无意义，建议不使用 2.自己给别人赋值)

//赋值操作符重载
	Date&  Date::operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
1
2
3
4
5
6
7
8
9
10
11

⑥取地址操作符重载

//取地址操作符重载
	Date* operator&()
	{
		return this;
	}

1
2
3
4
5
6

⑦重载 + days（加上指定天数）的重载（当+days大于该月总天数时，用days减去该月天数，月份month+1，差值即为新月份的天数。若遇到年末，即month = 12时，年份year++，月份month置1，否则month++）

Date Date::operator+(int day)
{
	Date ret(*this);

	if (day<0)
		return ret - abs(day);
	ret._day += day;

	while (ret._day > GetMonthDay(ret._year, ret._month))
	{
		ret._day -= GetMonthDay(ret._year,ret._month);
		if (12 == ret._month)
		{
			ret._year++;
			_month = 1;

		}
		else
		{
			_month += 1;
		}
	}
	return ret;
}

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

		}
		else
		{
			_month += 1;
		}
	}
	return *this;
}
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

⑧重载 - days （减去指定天数）的重载（与+days类似，用该月天数-days，其差值若小于0，且在年初，则年份year–，置月份month=12，否则month–）

//（与+days类似，用该月天数-days，
//其差值若小于0，且在年初，则年份year--，置月份month=12，否则month--）
Date Date::operator-(int day)
{
	Date ret(*this);

	if (day < 0)
		return ret + abs(day);
	ret._day -= day;
	while (ret._day <= 0)
	{

		if (ret._month == 1)
		{
			ret._year--;
			ret._month = 12;
		}
		else
		{
			ret._month--;
		}
		ret._day += GetMonthDay(ret._year,ret._month);

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

	}
	return *this;
}
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

⑨前置 ++ 的重载（+1操作应该考虑天数为月末，月份为年末时的特殊情况，通过判断月末与年末，对指定的月份+1或年份+1，并置新月份=1）

//（ + 1操作应该考虑天数为月末，月份为年末时的特殊情况，
//通过判断月末与年末，对指定的月份 + 1或年份 + 1，并置新月份 = 1）
Date& Date::operator++()// ++d => d.operator++(&d)
{
	_day++;
	if (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		_month++;
		if (_month > 12)
		{
			_year++;
			_month = 1;
		}
	}
	return *this;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

⑩后置 ++ 的重载（后置++与前置++类似，返回值略有差异，可以拷贝构造一个临时的函数来保存this指针保存的内容，最终返回临时的函数）

//（后置++与前置++类似，返回值略有差异，
//可以拷贝构造一个临时的函数来保存this指针保存的内容，最终返回临时的函数）
Date Date::operator++(int)// d++ => d.operator(&d, 0)
{
	Date ret(*this);
	_day++;
	if (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		_month++;
		if (_month > 12)
		{
			_year++;
			_month = 1;
		}
	}
	return ret;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

⑪前置 – 的重载（-1操作应该考虑天数为月初，月份为年初时的特殊情况，通过判断月末与年末，对指定的月份-1或年份-1，并置新月份=12）

// （-1操作应该考虑天数为月初，月份为年初时的特殊情况，
//通过判断月末与年末，对指定的月份-1或年份-1，并置新月份=12）
Date& Date::operator--() // --d 
{
	_day--;
	if (_day <= 0)
	{
		if (_month == 1)
		{
			_year--;
			_month = 12;
		}
		else
		{
			_month--;
		}
		_day += GetMonthDay(_year, _month);
	}
	return *this;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

⑫后置 – 的重载（与前置–类似，可以使用拷贝构造函数构造一个临时的函数，最终返回临时函数即可）

//（与前置--类似，可以使用拷贝构造函数构造一个临时的函数，最终返回临时函数即可）
Date Date::operator--(int) // d--
{
	Date ret(*this);
	if (_day <= 0)
	{
		if (_month == 1)
		{
			_year--;
			_month = 12;
		}
		else
		{
			_month--;
		}
		_day += GetMonthDay(_year, _month);
	}
	return ret;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

⑬关系运算符的重载

//日期类关系操作符重载
bool Date::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 Date::operator==(const Date& d)
{
	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}

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

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

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

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

⑭输出运算符 << 的重载（模拟cout输出）

// 重载输出 <<
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day << endl;
	return _cout;
}
1
2
3
4
5
6

⑮ 输入运算符 >> 的重载（模拟cin输入）

//重载输入>>
istream& operator>>(istream& _cin, Date& d)
{
	_cin >> d._year;
	_cin >> d._month;
	_cin >> d._day;
	return _cin;
}
1
2
3
4
5
6
7
8

⑯两个日期相隔天数 - 的重载（这里可以运用一个巧妙的方法，将当前对象拷贝构造为Max，引用对象拷贝构造为Min，如果Max<Min，调用库函数交换，并用一个状态量flag标记。再利用while循环，只要Max与Min不相等，Max–，计数器Count++，Count即为最终的相隔天数）

//（这里可以运用一个巧妙的方法，将当前对象拷贝构造为Max，引用对象拷贝构造为Min，
//如果Max<Min，调用库函数交换，并用一个状态量flag标记。再利用while循环，
//只要Max与Min不相等，Max--，计数器days++，days即为最终的相隔天数）
int Date::operator-(const Date& d)
{
	int flag = 1;
	Date Max(*this);
	Date Min(d);
	if ((*this) < d)
	{
		std::swap(Max, Min);
		flag = -1;
	}
	int days = 0;
	while (Max != Min)
	{
		--Max;
		++days;
	}
	return days*flag;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

参考代码

Date.h

#pragma once

#include<iostream>
#include<Windows.h>
#include<cmath>
 
using namespace std;


//日期类实现操作符重载
class Date
{
public:
	 
	// 全缺省参数构造函数
	Date(int year = 1997, int month = 11, int day = 4)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		//检查合法
		if (year >= 0
			&& _month > 0 && _month < 13
			&& _day > 0 && _day <= GetMonthDay(year, month))
		{
			_year = year;
			_month = month;
			_day = day;
		}
		else
		{
			cout << "Date Invalid" << endl;
		}
	}
	//析构函数
	~Date()
	{
		;
	}

	//拷贝构造函数：Date d3(d1)或者 Date d3 = d1
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	//赋值操作符重载
	Date&  operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
	//取地址操作符重载
	Date* operator&()
	{
		return this;
	}

	//关系操作符重载
	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 GetMonthDay(int year, int month);

	//返回自身加引用，返回临时值返回
	Date operator+(int day);
	Date& operator+=(int day);
	Date operator-(int day);
	Date& operator-=(int day);
	int operator-(const Date& d);
	Date& operator++();  
	Date operator++(int);  
	Date& operator--();  
	Date operator--(int);  

	//重载输出<<
	friend ostream& operator<<(ostream& _cout, const Date& d);

	//重载输入>>
	friend istream& operator>>(istream& _cin, 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
86
87
88
89
90
91
92
93
94
95
96
97
98
99

Date.cpp

#include "Date.h"

//获取当月天数
int Date::GetMonthDay(int year, int month)
{
	//方法一：十二个if、else语句
	//方法二：switch分支语句
	//此处方法三：
	 static const int days[13] = {0, 31,28, 31,30, 31,30, 31,31,30, 31,30, 31 };//润年二月多一天
	 //4年一润百年不润400年一润且此处至于二月有关
	 if ((month == 2)&&((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
	 {
		 return 29;

	 }
	 return days[month];
}

//日期类关系操作符重载
bool Date::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 Date::operator==(const Date& d)
{
	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}

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

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

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


//日期类操作符重载
// d1 + 100	  
//当+days大于该月总天数时，用days减去该月天数，月份month+1，差值即为新月份的天数。
//若遇到年末，即month = 12时，年份year++，月份month置1，否则month++）
Date Date::operator+(int day)
{
	Date ret(*this);

	/*if (day<0)
		return ret - abs(day);
	ret._day += day;

	while (ret._day > GetMonthDay(ret._year, ret._month))
	{
		ret._day -= GetMonthDay(ret._year,ret._month);
		if (12 == ret._month)
		{
			ret._year++;
			_month = 1;

		}
		else
		{
			_month += 1;
		}
	}*/
	//改进：
	ret += day;
	return ret;
}

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

		}
		else
		{
			_month += 1;
		}
	}
	return *this;
}
//（与+days类似，用该月天数-days，
//其差值若小于0，且在年初，则年份year--，置月份month=12，否则month--）
Date Date::operator-(int day)
{
	Date ret(*this);

	/*if (day < 0)
		return ret + abs(day);
	ret._day -= day;
	while (ret._day <= 0)
	{

		if (ret._month == 1)
		{
			ret._year--;
			ret._month = 12;
		}
		else
		{
			ret._month--;
		}
		ret._day += GetMonthDay(ret._year,ret._month);

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

	}
	return *this;
}
//（这里可以运用一个巧妙的方法，将当前对象拷贝构造为Max，引用对象拷贝构造为Min，
//如果Max<Min，调用库函数交换，并用一个状态量flag标记。再利用while循环，
//只要Max与Min不相等，Max--，计数器days++，days即为最终的相隔天数）
int Date::operator-(const Date& d)
{
	int flag = 1;
	Date Max(*this);
	Date Min(d);
	if ((*this) < d)
	{
		std::swap(Max, Min);
		flag = -1;
	}
	int days = 0;
	while (Max != Min)
	{
		--Max;
		++days;
	}
	return days*flag;
}
//（ + 1操作应该考虑天数为月末，月份为年末时的特殊情况，
//通过判断月末与年末，对指定的月份 + 1或年份 + 1，并置新月份 = 1）
Date& Date::operator++()// ++d => d.operator++(&d)
{
	/*_day++;
	if (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		_month++;
		if (_month > 12)
		{
			_year++;
			_month = 1;
		}
	}*/
	//该进：
	*this += 1;
	return *this;

}
//（后置++与前置++类似，返回值略有差异，
//可以拷贝构造一个临时的函数来保存this指针保存的内容，最终返回临时的函数）
Date Date::operator++(int)// d++ => d.operator(&d, 0)
{
	Date ret(*this);
	/*_day++;
	if (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		_month++;
		if (_month > 12)
		{
			_year++;
			_month = 1;
		}
	}*/
	*this += 1;
	return ret;

}
// （-1操作应该考虑天数为月初，月份为年初时的特殊情况，
//通过判断月末与年末，对指定的月份-1或年份-1，并置新月份=12）
Date& Date::operator--() // --d 
{
	/*_day--;
	if (_day <= 0)
	{
		if (_month == 1)
		{
			_year--;
			_month = 12;
		}
		else
		{
			_month--;
		}
		_day += GetMonthDay(_year, _month);
	}*/
	*this -= 1;
	return *this;
}
//（与前置--类似，可以使用拷贝构造函数构造一个临时的函数，最终返回临时函数即可）
Date Date::operator--(int) // d--
{
	Date ret(*this);
	/*_day--;
	if (_day <= 0)
	{
		if (_month == 1)
		{
			_year--;
			_month = 12;
		}
		else
		{
			_month--;
		}
		_day += GetMonthDay(_year, _month);
	}*/
	*this -= 1;
	return ret;
}
// 重载输出 <<
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day << endl;
	return _cout;
}
//重载输入>>
istream& operator>>(istream& _cin, Date& d)
{
	_cin >> d._year;
	_cin >> d._month;
	_cin >> d._day;
	return _cin;
}
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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291

Main.cpp

#include "Date.h"
void FunTest()
{
	Date date1(2015, 3, 31);
	Date date2(date1);
	Date date3(2017, 12, 1);
	Date date4(date3);
	Date date5(2012, 2, 2);
	Date date6(date5);
	Date date7(2017, 2, 19);
	Date date8(2015, 8, 8);
	Date date9;

	cout<<"date1:"<<date1<<endl;
	cout<<"date2:"<<date2<<endl;
	cout<<"date3:"<<date3<<endl;
	cout<<"date4:"<<date4<<endl;
	cout<<"date5:"<<date5<<endl;
	cout<<"date6:"<<date6<<endl;
	cout<<"date7:"<<date7<<endl;
	cout<<"date8:"<<date8<<endl;
	cout<<"date9:"<<date9<<endl;

	cout << "前置++：" << ++date1 << endl;
	cout << "后置++：" << date2++ << endl;
	cout << "前置--：" << --date3 << endl;
	cout << "后置--：" << date4-- << endl;
	cout << "加指定天数：" << date5 + 24 << endl;
	cout << "减指定天数：" << date6 - 5 << endl;
	cout << "两个日期相差的天数：" << date7 - date8 << endl;
	
	cin>>date9;
}
int main()
{
	FunTest();
	system("pause");
	return 0;
}
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

效果样例：

结语

初识C++的大门，希望自己在这条路上越走越远！