我们今天写一个Date类作为C++初始类的结尾，这里涉及到的知识，里面有很多运算符的重载,包括权限的问题,我们都已经分享过了，所以大家不用担心，这里算是一个总结吧.我这里用的的是Linux环境,主要是锻炼自己的能力.
我们要完成一个什么样的Date类呢,大家可以搜一下时间计算器,我们就完成他们的功能,比如说加减300天或者看看两个日期之间的天数,这就是我们要完成的任务.
这里我们用三个文件来写,分别是Date.h,Date.cpp,test.cpp.我们先把初始工作给做好了,我们先把框架各搭出来,后面要的功能一一补足.
Date.h
#include <iostream>
#include <assert.h>
using std::cout;
using std::endl;
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1);
//析构函数
~Date();
// 拷贝构造
Date(const Date& d);
private:
int _year;
int _month;
int _day;
};
Date.cpp
#include "Date.h"
Date::Date(int year, int month, int day)
{
}
~Date()
{
}
Date(const Date& d)
{
}
test.cpp
#include "Date.h"
int main()
{
return 0;
}
我们先来写一下日期类的构造函数,本来这是没有多少问题的,但是我们知道一个月的天数是有限制的,而且还有闰年于平年之分,这就考虑的有点难度了,但是这要符合我们的客观规律.我们先来把思路捋顺.
第一点 我们把年月份给对象,其中肯定都是大于0的整数,这个是毋庸置疑的,第二步,我们要判断这一年是平年还是闰年,第三步,要判断给的月数的对应的天数是否合理.
我们分别用方法来完成自己的要求.
这个很简单,记得去类里面声明这个方法.
bool Date::isLeap(int year)
{
assert(year > 0);
return (year % 4 == 0 && year %100 != 0)
|| year % 400 == 0;
}
我们都知道每一月分都有固定的天数,而且月份是肯定小于13的,
int Date::isLegitimate(int year,int month)
{
static int monthDay[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
assert(month > 0 && month < 13);
assert(day > 0);
//判断闰年 && 而且 月份是 2 月
if(isLeap(year) && month == 2)
{
return 29;
}
return monthDay[month];
}
我来解释一下我们定义数组的时候为什么用的是 static ? 我们知道,这是一个函数,也就是说函数栈帧会在结束后销毁,但是我们可能多次调用这个函数,为了避免多次开辟和销毁该数组的空间,这里直接用static修饰得了.
到这里我们已经写好了的构造函数,没必要在说其他了.
Date::Date(int year = 1900, int month = 1, int day = 1)
{
if(year > 0 && month > 0 && month <13 && day <= isLegitimate(year,month))
{
_year = year;
_month = month;
_day = day;
}
else
{
// 这里应该抛出一个异常
// 现在我还不太会 暂时用 assert代替
assert(NULL);
}
}
说实话,这两个函数我们不用写,主要是我们没有使用动态开辟空间,都是一些基本的内容,编译器生成的已经完全够了,这里大家看看就行了.
由于这两个函数都不大,这里就声明成内联函数函数吧,在类内实现.
// 析构函数
inline ~Date()
{
_year = 0;
_month = 0;
_day = 0;
}
// 拷贝构造
inline Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
某种意义上,运算符重载才是我们今天的大头,我们不是重载所有的运算符,而是要重载那些符合我们逻辑的,例如一个日期加上一个日期就没有什么意义,这里就不会重载它.
这个基本的逻辑运算符都有意义,这里我们一一给大家重载出来,同时也验证一下.
这个很好写,如果日期的年月日都相等,那么这两个日期一定相等.
bool Date:: operator==(const Date& d) const
{
return _year == d._year
&& _month == d._month
&& _day == d._day;
}
如果一个日期的年数比较大,那么它一定更大,如果相等,就比较月份,如果月份还相等,那就比较天数,这就是这个的原理.
bool Date:: operator>(const Date& d) const
{
return (_year > d._year)
||(_year == d._year && _month > d._month)
||(_year == d._year && _month == d._month && _day > d._day);
}
只要我们完成了上面的两个,后面就可以直接调用它们了,避免重复造轮子.
bool Date::operator>=(const Date& d) const
{
return *this > d || *this == d;
}
从这里开始,我就不演示结果了,都是和之前的一样.
我们知道,小于的对立面就是大于大于等于
bool Date::operator<(const Date& d) const
{
return !(*this >= d);
}
小于等于的对立面是大于,我们已经实现了.
bool Date::operator<=(const Date& d) const
{
return !(*this > d);
}
这个更加简单,不等于不就是等于的对立面吗
bool Date::operator!=(const Date& d) const
{
return !(*this == d);
}
上面的都挺简单的,这里算数运算符我们要重载的有加法,等于,减法,前置和后置++…有一定的额难度,尤其是加法和减法.
等于的重载基本来说对于我们是没有任何问题的,但是有一点是需要我们注意的,无论是C语言还是C++都是支持连等的,也就是a = b = c,那就意味者我们们重载等于的时候是要有返回值的.
Date& Date::operator=(const Date& d)
{
// 避免 重复
if(this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
说实话，加号还是比较简单的，我们首先要把给的天数判断一下,假如要是小于零,就去调用重载的减号,后面我会实现减法的,这里先考虑好.
那么我们该如何把这个逻辑给完善好呢?第一步,就是把给的天数直接加到_day上面,如果还没有超过当前月最大的天数,我们就直接返回这个日期就可以了,否则就把日期减去当前月最大的天数,当前月加一,注意,这里要明白,如果当前月是12月,我们直接把月份置为1,年加上一,这里要注意一点东西 ,我们不修改原来的日期
我们可以分为三种情况,每一个我都列出来,本质上是一个循环.
Date Date::operator+(const int day) const
{
//先判断 day 是否是 小于零
if(day < 0)
{
return (*this)-(-day);
}
// 第一步 来个第三方 不要修改原来的
Date ret(*this); // 这是拷贝构造
ret._day += day;
while(ret._day > ret.isLegitimate(ret._year,ret._month))
{
ret._day -= ret.isLegitimate(ret._year,ret._month);
if(ret._month == 12)
{
ret._month = 1;
ret._year += 1;
}
else
{
ret._month += 1;
}
}
return ret;
}
我们直接复用+和=就可以了,这里没什么可以分享的.
Date& Date::operator+=(const int day)
{
//判断 是不是 小于 0
if(day < 0)
{
return (*this) = (*this) - (-day);
}
return (*this) = (*this) + day;
}
我们们这里要重载加号的的话,需要分为两种共请情况
很荣幸,C++是支持重载的,我们也按照步骤来.
参数是天数
这个就是计算一个日期减去多少天得到另一个日期,也是比较简单的,我们要考虑一些之情况,这里小于零的情况就不解释了,主要看我们的思路是什么.
我们首先把_day减去day,判断是不是小于0,小于的话,就从上个月的日期天数加到 _day上,直到它它大于0,这里要注意的是,如果我们的月份恰好是12,那么上一个月是1月份,并且年也要减1
Date Date::operator-(const int day) const
{
// day 的大小
if(day < 0)
{
return (*this) + (-day);
}
Date ret(*this);
ret._day -= day;
//开始判断 ret._day
while(ret._day <= 0)
{
// 找上一个月的
if(ret._month == 1)
{
ret._month = 12;
ret._year -= 1;
}
else
{
ret._month -= 1;
}
int days = ret.isLegitimate(ret._year,ret._month);
ret._day += days;
}
return ret;
}
参数是日期
这个更加简单的,我们计算的是两个日期之间差的天数,我们可以复用前面的方法.
还是先说下思路,我们想,如果一个较小的日期每次加一,直到加到和较大的日期完全一样,我们计算加的次数是不是就可以完成这个操作符的重载了.那么我们如何要得到更小的日期,是不是要比较,然后交换这里是不用的,我们用一个标志位.我们假设日期A比日期B小,标志位flag = 1,如果不成立,我们把flag编程-1,随即我们用日期A加上flag,进行循环.
int Date:: operator-(const Date& d)
{
// 给一个 数 来计数
int count = 0;
int flag = 1;
// 不能修改原来的，这里用一个第三方
Date ret(*this);
if(ret > d)
{
flag = -1;
}
while(ret != d)
{
ret += flag;
count++;
}
return flag*count;
}
这个我们复用减号就可以了,就不解释了.
Date& Date::operator-=(const int day)
{
if(day < 0)
{
return(*this) = (*this)+(-day);
}
return (*this) = (*this) - day;
}
我们这就不解释前置和后置的区别了,上一个博客分享过了,直接开始吧.
前置
前置是不需要带参数的.
Date& Date::operator++()
{
*this += 1;
return *this;
}
后置
需要带一个int类型的参数
Date Date::operator++(int day)
{
Date ret(*this);
*this += 1;
return ret;
}
既然我们都把减法给重载了,那这我们直接复用就可以了
前置
不带参数
Date& Date::operator--()
{
*this -= 1;
return *this;
}
后置
带上参数
Date Date:: operator--(int day)
{
Date ret(*this);
*this -= 1;
return ret;
}
这原理我们已经分享过了,这里就不加赘述了,记得使用友元
>>
std::istream& operator>>(std::istream& in, Date& d)
{
in >> d._year >> d._month >> d._day;
return in;
}
<<
std::ostream& operator<<(std::ostream& out, Date& d)
{
out << d._year << "-" << d._month << "-" << d._day;
return out;
}
