日期类的实现

最新推荐文章于 2024-04-10 16:53:09 发布
最新推荐文章于 2024-04-10 16:53:09 发布
阅读量707 收藏 7
点赞数 15
分类专栏： C++笔记 文章标签： gnu 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53316121/article/details/124903454
版权

上一篇《类和对象二》中讲到了重载运算符。本篇文章用重载运算符的使用方法，实现日期类，就是写一个简单的日期计算器，精华在于运算符的重载和对已经定义好的符号的复用。

我们将声明放在类中，定义放在另一个源文件中，实现声明和定义的分离。

目录

1. 两个日期相互比较

1.1 ‘==’重载

声明

定义

注意

1.2 ‘<’重载

声明

定义

1.3 ‘<=’重载

声明

 用复用的定义

1.4 ‘>’重载

声明

定义

1.5 ‘>=’重载

声明

 定义

 1.6 ‘!=’重载

声明

 定义

2. 赋值 ‘=’重载

声明

定义

3. 对日期天数进行计算

确定月份天数

声明

定义

判断是否是闰年

定义

3.1 日期加天数 ‘+’的重载

声明

 定义

小拓展

3.2 日期加天数 ‘+=’的重载

声明

定义

3.3 +和+=相互复用定义比较 

复用+定义+=

 复用+=定义 +

到底谁复用谁效果更好呢？

3.4 日期减天数‘-=’的重载

声明

定义

3.5  日期减天数‘-’的重载

声明

用复用 -= 定义 -

4.日期 ++ 和 ++ 

4.1 ++

直接在类中定义

4.2 --

5. 求日期差，返回天数

声明

思路

第一思路：

第二思路：

定义

Date.h

Date.cpp

1. 两个日期相互比较

1.1 ‘==’重载

声明

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

定义

//这里隐含参数为this指针
bool Date::operator==(const Date& d)
{
	return _year == d._year&&
		_month == d._month&&
		_day == d._day;
}

注意

上述定义中为什么要加上 Date：：

 下面我们写其他重载是，也要在 operator 前面指向类域：

1.2 ‘<’重载

声明

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

定义

要考虑到年小于、年等于月小于、年月相同天小于，这三种情况

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

1.3 ‘<=’重载

声明

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

 用复用的定义

一行搞定，< 和 == 的重载我们已经写过了，在这里我们可以直接使用他们，会方便好多，不需要我们再次将冗余的代码写一次并再次判断逻辑。

bool Date::operator <= (const Date& d)
{

	return *this < d || *this == d;
}

1.4 ‘>’重载

声明

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

定义

直接用复用我们已经写过的 <= ：

bool Date::operator>(const Date& d)
{

	return !(*this <= d);
}

1.5 ‘>=’重载

声明

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

 定义

直接复用 > 和 == :

bool Date::operator >= (const Date& d)
{

	return *this > d || *this == d;
}

或者复用 < ：

bool Date::operator >= (const Date& d)
{

	return !(*this < d);
}

 1.6 ‘!=’重载

声明

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

 定义

复用 == ，取反即可：

bool Date::operator != (const Date& d)
{

	return !(*this == d);
}

2. 赋值 ‘=’重载

声明

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

定义

返回的就是Date类型，就好比有两个整型变量： a=b ，返回的类型也是整型

为什么要加引用呢？

a.this指针出了函数作用域会销毁，但是this所指向的内容是不会销毁的，因此我们可以考虑使用引用返回

b. 并且如果不用引用返回，同类型的对象传值传参会调用拷贝构造，减少开销，也推荐使用引用返回

Date& Date::operator=(const Date& d)
{
	if (*this != d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	return *this;
}

3. 对日期天数进行计算

对日期进行计算：

比如加上天数减去天数，会涉及到月份或年的增加或减少问题。这里就需要判断天数是否超过当前对应月份天数的限制，月份是否超过12等等。并且对于特殊的2月，我们还需区分闰年和平年。

确定月份天数

声明

最后返回的是天数

	int GetMonthDay(int year, int month);

定义

//Leapyear(year) 是bool类型，判断是否是闰年

int Date::GetMonthDay(int year, int month)
{

    在这里对年和月份进行判定
	assert(year >= 0 && month>0 && month<13);

	static int MDay[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	if (month == 2 && Leapyear(year))
	{
		return 29;
	}
	else
	{
		return MDay[month];
	}
}

这里要注意为什么在数组前加上 static ，不加也是可以的，但是每次创建时调用此函数，都会开辟出新数组，static 可以保持此数组只初始化一次，使用时再次调用即可，可降低开销，提高效率。

判断是否是闰年

定义

我们直接将此函数在类中定义，将默认他是内联函数： 

	bool Leapyear(int year)
	{
		if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
		{
			return true;
		}
		else
		{
			return false;
		}
	}

3.1 日期加天数 ‘+’的重载

声明

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

 定义

这里首先要用到拷贝构造，创建一个临时的日期类，对临时的进行更改，最后返回，就比如 a+3后，a 是不改变的。a = a+3，a才会改变。这里的运算相当于a+3

要考虑天数过大时，边界问题，天数有边界，月份有边界，超过月份的天数限制，月份+1，月份==13时，年+1

按照此逻辑进项实现：

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

小拓展

当一个对象取初始化另一个不存在的对象时，调用的是构造拷贝

只有两个存在的对象使用=时，才是赋值

 

3.2 日期加天数 ‘+=’的重载

相当于 a=a+b ，a本身会改变

声明

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

定义

和+的逻辑相同，只不过是直接修改 this 指向的内容，注意这里的返回值与 + 不同，+ 返回的是临时变量，用传值，而这里this会销毁，  *this 不会销毁，直接返回 *this即可，返回它本身用引用返回。

判断day为负的情况，复用 -=

+=负值等价于-=正值：

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

3.3 +和+=相互复用定义比较 

复用+定义+=

简便很多

Date& Date::operator+=(int day)
{

	*this = *this + day;
	return *this;
}

 复用+=定义 +

+= 不复用+来实现，那么+就可以复用 +=来实现

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

到底谁复用谁效果更好呢？

分别调用两种方式的+和+=

由拷贝构造的次数来看，+ 复用 += 效率会更高一些。

由此推出：- 复用 -= 效率会更高。

3.4 日期减天数‘-=’的重载

声明

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

定义

这里特别要注意的是当月份为0，时，重置月份，更新天数的时候，用更新后的月份来计算。

最后返回*this，不会销毁，用引用返回。

判断day为负的情况，复用 +=

-=负值等价于+=正值：：

Date& Date::operator-=(int day)
{
	if (day<0)
	{
		return *this += -day;
	}

	_day -= day;
	while (_day<=0)
	{
		_month--;
		if (_month==0)
		{
			_month = 12;
			_year--;
		}

	    //月份给的是前一个月，而不是原来的月份
	    _day += GetMonthDay(_year,_month);
	}

	return *this;
}

3.5  日期减天数‘-’的重载

声明

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

用复用 -= 定义 -

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

4.日期 ++ 和 ++ 

4.1 ++

++运算符重载分为前置++和后置++，他们的函数形式如下：

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


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

函数名相同，为了区分开来，语法规定：

没有参数的为前置++

有参数的为后置++

直接在类中定义

前置++，直接改变*this的内容

后置++，*this不变，返回的是此函数中构建好的临时变量，临时变量进行运算操作之后返回

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

	// 后置++
	Date operator++(int)
	{
		Date ret(*this);
		ret += 1;
		return ret;
	}

4.2 --

和++同理，直接在类中定义：

	// 后置--
	Date operator--(int)
	{
		Date ret(*this);
		ret -= 1;
		return ret;
	}

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

5. 求日期差，返回天数

两个日期不相等时，求他们之间相差多少天

声明

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

思路

第一思路：

年之间比较求差，月之间比较求差，天之间比较球差，最后判断对应天数，累加即可。

缺点：分别判断，分别计算，过程太繁琐

第二思路：

首先判断谁大谁小，让小的开始累加，直到和大的相等为止，只需要计加了多少天即可。 

定义

这里flag来确定正负，如果现在和未来比，天数是正的，加上天数即可和大的相等

如果是现在和过去比，天数是负的，现在+天数等于过去的时间

int Date::operator-(const Date& d)
{

	int flag = 1;
	Date max = *this;
	Date min = d;
	if (*this<d)
	{
		min = *this;
		max = d;
		flag = -1;
	}
	//让小的累加至大的
	//累加的天数n为差值
	int n = 0;
	while (min != max)
	{
		n++;
		min++;
	}

	return n*flag;
}

Date.h

#define _CRT_SECURE_NO_WARNINGS
#pragma once

#include <cassert>
#include <iostream>
using std::cout;
using std::cin;
using std::endl;

class Date
{
public:

	// 获取某年某月的天数
	bool Leapyear(int year)
	{
		if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	int GetMonthDay(int year, int month);


	// 全缺省的构造函数
	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)
	{
		cout << "构造拷贝" << endl;
		_year = d._year;

		_month = d._month;

		_day = d._day;
	}



	// 赋值运算符重载

	// 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++()
	{
		*this += 1;
		return *this;
	}

	// 后置++
	Date operator++(int)
	{
		Date ret(*this);
		ret += 1;
		return ret;
	}



	// 后置--
	Date operator--(int)
	{
		Date ret(*this);
		ret -= 1;
		return ret;
	}

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

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



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



	// >=运算符重载
	inline 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);

	void SetDate(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

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

Date.cpp

#define _CRT_SECURE_NO_WARNINGS


#include "Date.h"

// 赋值运算符重载

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

Date& Date::operator=(const Date& d)
{
	cout << "赋值" << endl;
	if (*this != d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	return *this;
}



 析构函数
//
//~Date()




// 日期+=天数

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 == 13)
		{
			_year++;
			_month = 1;
		}
	}
	return *this;
	//*this = *this + day;
	//return *this;
}

// 日期+天数
Date Date::operator+(int day)
{
	Date ret(*this);
	//ret._day += day;
	//while (ret._day>GetMonthDay(ret._year, ret._month))
	//{
	//	ret._day -= GetMonthDay(ret._year, ret._month);
	//	ret._month++;
	//	if (ret._month == 13)
	//	{
	//		ret._year++;
	//		ret._month = 1;
	//	}
	//}
	ret += day;
	return ret;
}



// 日期-天数

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



// 日期-=天数

Date& Date::operator-=(int day)
{
	if (day<0)
	{
		return *this += -day;
	}
	_day -= day;
	while (_day<=0)
	{
		_month--;
		if (_month==0)
		{
			_month = 12;
			_year--;
		}
		//月份给的是前一个月，而不是原来的月份
		_day += GetMonthDay(_year, _month);
	}
	return *this;
}


// >运算符重载

bool Date::operator>(const Date& d)
{
	//if ((_year > d._year) ||
	//	(_year == d._year) && (_month > d._month) ||
	//	(_year == d._year) && (_month == d._month) && (_day > d._day))
	//{
	//	return true;
	//}
	//else
	//{
	//	return false;
	//}
	return !(*this <= d);
}


// ==运算符重载

//参数：看运算符来定:两个相比较，那么就有两个形参
//返回值：看运算后的结构，比较相等返回真假即可，即bool

//这里隐含参数为this指针
bool Date::operator==(const Date& d)
{
	return _year == d._year&&
		_month == d._month&&
		_day == d._day;
}



// >=运算符重载

inline bool Date::operator >= (const Date& d)
{
	//if ((_year > d._year) ||
	//	(_year == d._year) && (_month > d._month) ||
	//	(_year == d._year) && (_month == d._month) && (_day >= d._day))
	//{
	//	return true;
	//}
	//else
	//{
	//	return false;
	//}
	return *this > d || *this == d;
	//return !(*this < d);
}



// <运算符重载

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



// <=运算符重载

bool Date::operator <= (const Date& d)
{
	//if ((_year < d._year) ||
	//	(_year == d._year) && (_month < d._month) ||
	//	(_year == d._year) && (_month == d._month) && (_day <= d._day))
	//{
	//	return true;
	//}
	//else
	//{
	//	return false;
	//}
	return *this < d || *this == d;
}



// !=运算符重载

bool Date::operator != (const Date& d)
{
	/*if ((_year != d._year) ||
	(_year == d._year) && (_month != d._month) ||
	(_year == d._year) && (_month == d._month) && (_day != d._day))
	{
	return true;
	}
	else
	{
	return false;
	}*/
	return !(*this == d);
}



// 日期-日期 返回天数

int Date::operator-(const Date& d)
{
	int flag = 1;
	Date max = *this;
	Date min = d;
	if (*this<d)
	{
		min = *this;
		max = d;
		flag = -1;
	}
	//让小的累加至大的
	//累加的天数n为差值
	int n = 0;
	while (min != max)
	{
		n++;
		min++;
	}

	return n*flag;
}

int Date::GetMonthDay(int year, int month)
{
	assert(year >= 0 && month>0 && month<13);
	static int MDay[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	if (month == 2 && Leapyear(year))
	{
		return 29;
	}
	else
	{
		return MDay[month];
	}
}
今年依旧去年春
关注
  • 15
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 10
    评论
专栏目录
关于日期类实现的所有代码
11-19
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
C++实现日期类
qq_34270874的博客
03-11 211
使用重载运算符（+，-,+=，-=,<,>等）实现日期类的操作。 #include <iostream> using namespace std; class Date { public: int getDay(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 (mo
【C++学习笔记】----日期类实现（运算符重载，天数计算等）
qq_41152046的博客
05-03 463
1.题目 实现日期类的运算符 +， -， +=， -=， ==， !=， >=， <= ，>， <， >> ，<<， 日期-日期等。 2.代码展示 Date.h #include<iostream> using namespace std; class Date { public: //获取某月的天数 friend int Getmo...
c++ - 运算符重载实践 -日期类
最新发布
2302_79539362的博客
04-10 857
深入了解运算符重载
日期类及其基本功能的实现
zhengyawen666的博客
07-27 204
日期类及其基本功能的实现
【C++】运算符重载（日期类的实现）
Ruaaa_iiiiiiiii的博客
05-25 1141
博主在快写完类和对象（中）时，突然发现需要用到运算符重载的知识但是运算符有很多运算符要进行重载，会导致文章的篇幅略长所以就单独写了一个，另外，日期类是学习运算符重载比较好的一个例子，所以这里就用了日期类来讲解运算符重载。
C++ 类和对象（三）运算符重载、const成员函数、实现日期类
2301_79391308的博客
09-12 348
本文主要介绍运算符重载和const成员函数的知识，运算符重载是设计类的重要工具，其中赋值运算符重载和取地址符重载是类的默认成员函数，最后基于本篇及之前关于类和对象的知识实现比较完善的日期类。
CPP2023-029-运算符重载 6-9 日期类的设计与实现
2303_79540797的博客
12-22 482
怎么说还是菜,所以copy了一下寝室大佬的代码,发现思路是一样的(我不过应该是哪个代码错了,但编译器只看能不能运行,不看符不符合题目),所以建议兄弟们不要直接抄,看完之后自己敲一遍(我吃过的苦你们也要吃,嘿嘿)相当于简化了err的代码量,要不然逻辑太复杂了(我估计我据说这错了,可能漏了啥东西,建议好好看看这一段,不是新东西,就是恶心人)最后,返回修改后的日期对象.(还是一个逻辑简化的作用,强者的话就随便搞,咋写都行)接着进行错误检查,如果日期不合法,就将日期设置为该月的第一天,并且月份加一.
6-7 日期类的设计与实现 (30分)
xzlscui的专栏
08-06 2488
使用重载运算符（++，+=，<<等）实现日期类的操作。功能包括： 1）设置日期，如果日期设置不符合实际，则设置为默认日期（1900年1月1日） 2）在日期对象中向日期添加1或者加若干天（加入日期值后根据实际的日期进行月份、年份的变化） 3）重载流插入运算符进行日期的输出，其中月份要用名称表示 定义类MyDate： class MyDate 主测试程序样例： #include <string>#include <iostream>using namespace st
python实现简单日期工具类
09-19
主要为大家详细介绍了python实现简单日期工具类，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
一个简单的日期类的实现
03-30
简单的日期类，方便理解之前C++笔记中的一些默认函数和操作符重载，具体有获取天数，两个日期相减，实现了日期加天数，日期减天数，判断输入的日期是否合法，判断输入的日期是星期几，还有前置后置++(--)的重载等等...
C++实现日期类（Date）
08-26
主要为大家详细介绍了C++实现日期类的相关代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java实现的日期处理类完整实例
08-29
主要介绍了Java实现的日期处理类,结合完整实例形式分析了Java针对日期的获取、运算、转换等相关操作技巧,需要的朋友可以参考下
[C++](5)类和对象练习，日期类的实现，运算符重载
CegghnnoR的博客
06-22 329
重载日期计算的运算符，包括大量细节
【C++】日期类的实现——运算符重载
weixin_67312366的博客
10-11 2441
C++日期类
C++ 操作符重载(1) 时间相加
alex1997222的博客
11-17 2787
重载操作符的目的:的  C++中预定义的运算符的操作对象仅限于基本的内置数据类型  大多时候我们需要对我们的类似类型进行类似运算,这个时候我们需要对运算符进行重新定义,赋予其新内容  赋予其新的功能,以满足自身的需求  运算符重载的实质就是函数重载或函数多态。运算符重载是一种形式的C++多态。目的在于让人能够用同名的函数来完成不同的基本操作。    基本格式如下: operator
【7.11】为Date类重载“+”运算符，实现在某一个日期上（月、日、年）加一个天数。
huanyu_liang的专栏
07-01 4394
 【7.11】为Date类重载“+”运算符，实现在某一个日期上（月、日、年）加一个天数。 Date类如下： class Date{    public:     Date (int m, int d, int y)     { month=m;       day=d;       year=y;     }     void print()    { cout
LHL PTA 实验11 运算符重载、模板
Simple_questions的博客
06-06 2074
题目1 6-1 学生成绩的输入和输出（运算符重载） (25分) 现在需要输入一组学生的姓名和成绩，然后输出这些学生的姓名和等级。 输入时，首先要输入学生数（正整数）N。接着输入N组学生成绩，每组成绩包括两项：第一项是学生姓名，第二项是学生的成绩（整数）。 输出时，依次输出各个学生的序号（从1开始顺序编号），学生姓名，成绩等级（不小于60为PASS，否则为FAIL） 函数接口定义： 面向Student类对象的流插入和流提取运算符 裁判测试程序样例： #include #include using name
c++设计一个日期类date
06-10
好的，我可以为您设计一个日期类date，实现日期的基本功能。 首先，我们需要确定日期类的属性，即年、月、日。因此，我们可以在类的私有部分定义三个整型变量，分别表示年、月、日。同时，我们还需要定义一些成员函数，来实现对日期的各种操作。 下面是一个简单的日期类的示例代码： ```cpp class Date { private: int year, month, day; public: // 构造函数 Date(int y, int m, int d) { year = y; month = m; day = d; } // 获取日期的年份 int getYear() const { return year; } // 获取日期的月份 int getMonth() const { return month; } // 获取日期的日份 int getDay() const { return day; } // 判断是否为闰年 bool isLeapYear() const { if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) return true; else return false; } // 获取当前月份的天数 int getDaysOfMonth() const { int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; if (isLeapYear() && month == 2) return 29; else return days[month - 1]; } // 判断日期是否合法 bool isValid() const { if (year < 0 || month < 1 || month > 12 || day < 1 || day > getDaysOfMonth()) return false; else return true; } // 重载运算符"=="，判断两个日期是否相等 bool operator==(const Date& d) const { return (year == d.year && month == d.month && day == d.day); } // 重载运算符"<"，判断当前日期是否小于另一个日期 bool operator<(const Date& d) const { if (year < d.year) return true; else if (year > d.year) return false; else if (month < d.month) return true; else if (month > d.month) return false; else if (day < d.day) return true; else return false; } // 增加一天 void increaseOneDay() { day++; if (day > getDaysOfMonth()) { day = 1; month++; if (month > 12) { month = 1; year++; } } } // 输出日期 void print() const { cout << year << "-" << setw(2) << setfill('0') << month << "-" << setw(2) << setfill('0') << day; } }; ``` 这个日期类中包含了获取年、月、日、判断是否为闰年、获取当前月份的天数、判断日期是否合法、重载运算符等常用功能，还有增加一天、输出日期等操作。您可以根据自己的需求进行扩展和修改。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

今年依旧去年春

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值