C++ 入门篇 (五)

本篇主要是之前几篇的一个运用,也会补充一些之前的知识

1. 日期类的实现

1.1 类的声明与构造函数

我们之前举例子的时候经常用到日期类,现在我们就来实现一个完整的日期类。这里实现的时候也是分文件去实现的,在头文件里声明,在.cpp文件里面实现成员函数。

首先我们考虑一下,构造函数要不要写,要写,因为要自己输入日期。析构写不写,其实不用,拷贝构造和赋值重载其实都不用,因为这个日期类并没有去申请资源。

1
2
3
4
5
6
7
8
9
10
class Date
{
public:
Date(int year = 1900,int month = 1,int day = 1);
private:
int _year;
int _month;
int _day;

}
1
2
3
4
5
6
Date::Date(int year = 1900,int month = 1,int day = 1)
{
_year = year;
_month = month;
_day = 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
class Date
{
public:
Date(int year = 1900,int month = 1,int day = 1);

Date& operator+(int day);
Date& operator+=(int day);

Date& operator-(int day);
Date& operator-=(int day);

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 日期加减天数

下面我们来一个一个实现,

首先是日期加天数,主要思路和正常加法一样,加到对应的月份的天数就要进位,有的是三十有的是三十一,还要考虑闰年的问题(影响二月是二十八还是二十九天)。所以,我们需要一个GetMonthDay的一个函数,来得到每个月份的天数。这个函数我们定义在类的里面,因为这个获取月份天数的函数调用起来一定很频繁。

那么这个函数怎么写呢?可以用switch,case。或者if,else的条件判断的方法。但是这样都太麻烦了。还有一种办法就是用一个数组把所有月份的天数都存起来,因为总共就十二个月,输入哪个就可以下标访问哪个,所以函数就这么写:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int GetMonthDay(int year,int month)
{
month_day[13] = {-1, 31, 28 ,31,30,31,30,31,31,30,31,30,31 }; //加在下标为零的位置加一个-1,把数往后顶一个,让月份和下标配对起来。

//if((year%4==0&&year%100!=0) || (year%400 == 0) && month ==2)
if( month ==2 && (year%4==0&&year%100!=0) || (year%400 == 0)) //注意这里的写法,因为逻辑运算符有个短路,所以这里先判读是不是二月再判读是不是闰年,可以提效率。因为只有是二月的时候采取考虑闰年的事。
{
return 29;
}
else
{
return month_day[month];
}

}

然后我们就可以来实现日期加天数的操作符重载,先来看看+=,因为这个加上去的天数有可能超过本月的天数,要进位,所以,我们的思路就是先把天数全加上来,然后给一个循环,一直减月份的天数,然后进位,直到这个天数合法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Date& Date::operator+=(int day)   //注意这里是在类外面定义函数,所以,要加上域限定操作符
{
_day += day;
while( _day > GetMonthDay(_year,_month))
{
_day -= GetMonthDay(_year,_month);
_month++;

if(_month == 13)
{
_month = 1;
_year++;
}

}

return *this;
}

这就是+=的逻辑。加的逻辑和+=的逻辑很像,区别就是 d 改不改变。我们可以新开一个类类型的对象来解决。

还有一个地方要注意,就是逻辑的复用。虽然我们可以直接cv过来+=的逻辑,但是,这样写,

1
2
3
4
5
6
7
Date Date::operator+(int day)
{
Date tmp = *this;
tmp += day;

return tmp;
}

注意有几个点,第一个要注意,+= 这个操作符重载以后再类里面的函数当然也可以使用。 还有就是这里返回是值返回,而不是引用返回,因为这里的tmp是个局部变量,传引用返回的会出现”野引用”的问题。所以,在效率和正确性之间,我们选择正确性。

那么这里就还有一个问题。

是+复用+=的函数更好,还是+=复用+的函数更好?后面再说。

下一步我们来实现-和-=的操作符重载,这个的思路和+和+=差不多,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Date& Date::operator-=(int day)
{
_day -= day;
while( _day<=0 )
{
_day += GetMonthday(_year,_month);
_month--;
if(_month == 0)
{
_month = 12;
_year--;
}
}

return *this;

}

然后是-的操作符重载,

1
2
3
4
5
6
7
8
Date Date::operator-(int day)
{
Date tmp = *this;
tmp -= day;

return tmp;

}

那么现在我们就可以来看一看到底是谁复用谁会更好一些。首先,我们给出的结论是,- 复用 -= 会更好一些。

原因就是,在 - 的函数里面,多两次拷贝构造,一次是tmp数组初始化的时候,还有一次是传值返回的时候,但是 -= 的函数里面就没有。所以,如果 -= 复用减的话,会比正常的多两次拷贝的过程,这显然是不划算的。所以,我们用复用-=的函数。

1.3 日期比较

再之后,我们来实现一些关系操作符,注意关系操作符的实现复用的情况很多,因为他们的逻辑都是有关系的。

首先我们来实现一下==,这个很简单,

1
2
3
4
5
6
bool Date::operator(const Date& d)
{
return _year == d._year&&
_month == d._month&&
_day == d._day;
}

(还是要提醒一下,这里的_year,_month,_day,都是由this指针来访问的,只是这里没显式写出来而已,在类里面定义这些变量的时候是声明,是给编译器编译的时候用的)。

有了相等的逻辑,那么不等于的逻辑也就很简单了,逻辑非一下就好了,

1
2
3
4
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
bool Date::operator<(const Date* d)
{
if(this->_year < d.year)
{
return true;
}
else if(this->_year == d._year)
{
if(this->_month < d._month)
{
return true;
}
else if(this->month == d.month)
{
if(this->day < d.day)
{
return true;
}
}
}

return false; // 相当于所有的不true的地方都return false;
}

这就是 < 的重载。好了,有了这个以后,条件操作符就基本上结束了,其它的都可以复用,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
bool Date::operator<=(const Date d)
{
return *this<d || *this == d;
}

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

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

1.4 前置与后置自增

在之后,我们考虑实现重载++这个操作符,但是++这个操作符只有一个操作数,但是可以前置++,也可以后置++,那么我们要怎么区分前置和后置呢?

因为前置++用的更多一些,(前置++的效率更好,为什么呢?我们知道前置++是先++后传回来,所以可以传引用回来,但是后置++,是先传回来再++,所以肯定需要新开一个变量,而且不能传引用回来,多两次拷贝),所以祖师爷在C++语法上,重载后置++的时候需要再加上一个int类型当形参,但是我们一般什么都不传,它只是一个标记而已。

1
Date Date::operator++(int);

这就是后置++的重载函数的写法。至于实现的话,就是 += 1 ,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Date Date::operator++(int)
{
Date tmp = *this;
*this += 1;

return tmp;
} //后置++


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

–和++的几乎没区别,就不再赘述了。

1.5 两个日期相减

好了,现在日期和天数的操作符都重载完了。现在来考虑实现一个一个特殊的,就是日期减日期。

我们首先想到的思路就是,和正常减法一样借位减。但是,这样是对的吗?比如,2024 9 26 和 2020 12 3 。因为 9 不够减 12 ,所以要借位,减出来是 9 。但是,这 9 个月是 我们想要的那个月份吗?不一定是。而且,真的减起来还要考虑闰年的问题。

所以,这种办法理论上可以,但是巨麻烦,丢掉。(不止是在这里,一个思路不通的时候,不要老揪着不放,尝试换一种思路,也许就好很多)。

那么我们的第二种思路就是,利用相对天数。比如说 2024 年 9 月 26 日,和 1900 年 3 月 27 日。 我们可以先求出,2024年1月1日,和1900年1月1日,的差值的天数。就是 365*n + m (闰年多一天)。

然后再分别算出 2024 年 1 月 1 日,和 2024 9月 26 日,还有 1900 年 1 月 1 日,和 3 月 27 日之间的差值。 然后再加起来,这样就方便了很多。当然要注意一下闰年的问题。

但是,我们之前提到过很多次逻辑的复用,那么我们就还有另一种思路,就是从较小的天数开始++,一直加到较大的天数为止,用一个计数的看看加了多少次。看起来这个解法不如上面那个高效,但是实践中其实差不多。因为CPU的运算速度是以亿为单位的,而我们算的是日期,所以肯定没问题,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
int Date::operator-(const Date& d)
{
//这里就需要用的假设法了,而且肯存在减出来是负数的情况,所以要增加一个flag。
int flag = 1;
int n = 0;
Date greater = *this;
Date less = d;

if(*this < d)
{
greater = d;
less = *this;
flag = -1;
}

while(less != greater) //注意,这里用不等于就好,因为比<=要效率一些
{
++less;
n++;
}

return n*flag;

}

1.6 负数天数与日期校验

那么到这里,日期类的实现就接近尾声了。还有一个地方,如果有个哥们故意找茬,这么写:

1
d1 += -100;

我们发现我们的这个+=函数是解决不了的,但是要解决这个很简单,修改一下就好了,

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
Date& Date::operator+=(int day)   
{

if(day < 0)
{
*this -= -day;

return *this;
}

_day += day;
while( _day > GetMonthDay(_year,_month))
{
_day -= GetMonthDay(_year,_month);
_month++;

if(_month == 13)
{
_month = 1;
_year++;
}

}

return *this;
}

如果是减等一个负数的话,修改的方式一样。

这个问题解决以后,还有一个问题,就是日期非法,万一有个哥们传了一个 2024 年 6 月 31 日进来,怎么办。所以,还要再加一个日期判断。那么这个判断加在哪里呢?其实加在构造函数里面比较好,防止有人胡搞。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
bool Date::CheckDate ()  //对于年来说的话,我们暂时认定是无限的吧,只检查月份和天数
{
if(_month > 12 || _month <=0 || _day <= 0 || _day > GetMonthDay(_year,_momth))
{
return false;
}
else
{
return true;
}

} //把这个函数放构造里面调用一下就好了。
//其实我们还可以打印一下,是哪个日期。

void Date::Print()
{
cout << _year << '/'<< _month << '/' << _day << '/' << endl;
}


1.7 流插入与流提取

这样我们的日期类就基本完工。但是还有一点。如果我们想要输入去初始化一个类的话,(上面我们都是构造去初始化的)那么我们就需要重载一下流插入 << ,和留提取操作符 >> 。

如果我们用scanf 活着 printf 行不行?很明显不行,这两个输入输出都针对的是内置类型,还需要指定格式。 但是IO流就不一样了,这也是当初祖师爷为什么要搞这个IO流。

说到这里,还要补充一些知识。因为C++兼容C,所以C++和C的缓冲区是连在一起的,这样才可以同时支持cin,cout,scanf,printf。还有一点,cout和cin是有联系的,每一次调用cin的时候,都会先刷新一下cout的缓冲区。

因为这两种联系,所以,在使用cin,cout的时候,面对大量数据的输入输出效率是有问题的。

我们可以加上这几句,

1
2
3
4
5
ios_base sync_with_stdio(false);  //这一句是解开C++和C的缓冲区绑定的

cin.tied(nullptr); // 这是解开cin,cout 的绑定的。
cout.tied(nullptr);

当我们要去重载流插入 << 的时候,如果我们把它重载为成员函数,也就是这样,

1
2
3
4
5
ostream& Date::operator<<(osream& out)
{
out << _year << '/'<< _month << '/' << _day << '/' << endl;
return out;
}

这里要注意,cout是一个ostream的对象,这里传参必须要传引用,因为ostream的对象的拷贝构造是封起来来的,不让用,当然istream也一样,这里后面会讲。

返回值也是一个ostream的对象,是为了支持连续输出的。当然,这个函数里面的流插入,是调用的库里面的重载。

但是这样写成成员函数,还有一个问题,我们知道成员函数的第一个参数是this指针,所以,这样用起来的时候就要 d1 << cout ,倒反天罡了,和我们平时用的不一样了。所以不能就直接定义成成员函数。所以我们就要写成全局函数。

1
2
3
4
5
ostream& operator<<(osream& out)
{
out << _year << '/'<< _month << '/' << _day << '/' << endl;
return out;
}

但是,这样又有新的问题,就是这个日期类里面的数据是private的,不允许外面访问。所以,这个时候,就用到友元函数。后面详细介绍。

只需要在类里面加入友元函数的声明,就可以了。一般,友元函数的声明放在最前面。

1
frind ostream& operator<<(osream& out, const Date& d);

输入的时候的流提取也是类似。如果我们想要优化一下的话,可以加入一个判断日期输入合不合法,防止胡搞。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
istream& operator>>(istream& in, Date& d)
{
while(1)
{
cout << "请输入日期:>" ;

in >> d._year >> d._month >> d._day;
if(!d.CheckDate()) //这里就是CheckDate函数写成成员函数的好处。
{
cout << "日期非法,请重新输入" << endl ;
}
else
{
break;
}

}
return in;
}

这个循环可以直接写死,也可以写成do while。但是do while会有一点不爽,没法打印。

2. const 成员函数与取地址运算符

2.1 const 修饰成员函数

const 修饰函数是为什么呢?其实还是之前提到过的权限放大的问题。权限可以缩小,可以平替但是不能放大。我们之前也提到过只有引用和指针这块会出现权限放大的问题。其实什么函数都可以加const修饰,全局的也可以,按需求来吧。

我们来看这么一个例子,

1
const Date d1;

我们的类类型的对象加上const完全没有问题,但是,如果这样,

1
d1.Print();

编译器就会报错。那这是为什么呢?就是发生了权限放大的问题。这里放大权限的是this指针。取地址取出来的是 const d1 的地址。

this 指针全写出来是 Date* const this 可以看到这里是在*的右边加上了const,也就是只限定了this指针的指向,而*this指针依旧可以被修改,但是这里的d1又是加上了const变成了只读变量,所以就发生了权限放大。

由于this指针在语法上是不允许出现在函数实参和形参的位置的,那么我们要怎么修改呢?答案很简单,就是给函数后面加上const(声明和定义都要哦)

1
2
3
4
5
6
7
8
void Date::Print() const
{
cout << _year << '/'<< _month << '/' << _day << '/' << endl;
}

//......

Print() const;

这样加上const了以后就相当于是给this指针的*的右边加上了const。而且加上const以后,不管是不是只读的,都可以调用这个函数。但是,也别想着给成员函数加上const,因为加上const了以后this指针解引用就不能改了,换句话说就是需要修改类对象的函数不能加上const。

2.2 取地址运算符重载

取地址运算符重载也是类里面的默认成员函数。这个不是很重要,一般也不需要我们自己写,编译器默认支持的。

这个名字指的是两个函数:

1
2
3
4
Date* operator&()
{
return this;
}
1
2
3
4
const Date* operator&()
{
return this;
}

一个带const的一个不带const的,编译器会自己选用哪个。

当然,如果想使坏的话也是可以的,自己写一个,然后胡乱返回一个地址,给好友一个惊喜。