C++初阶：类与对象(中）
文章目录
- 1 类的默认成员函数
- 2 构造函数
-
- 2.1 功能
- 2.2 特性
- 2.3默认构造函数
- 2.4 Example
-
- 2.4.1Date类的构造函数
- 2.4.2 stack类的构造函数
- 2.4.3 MyQueue类的构造函数
- 3析构函数
-
- 3.1 功能
- 3.2 特性
- 3.3 默认的析构函数
- 3.4 Example
-
- 3.4.1 Date类的析构函数
- 3.4.2 stack类的析构函数
- 3.4.3 MyQueue类的析构函数
- 4 拷贝构造函数
-
- 4.1 功能
- 4.2 特征
- 4.3 默认的拷贝构造函数
- 4.4 Example
-
- 4.4.1 Date类的拷贝构造函数
- 4.4.2 Stack类的拷贝构造函数
- 4.4.3 MyQueue类的拷贝构造函数
- 4.5 拷贝构造函数的使用场景
- 5 运算符重载
-
- 5.1 概念
- 5.2 注意
- 5.3 Example(以日期类为例)
-
- 5.3.1 判断日期时是否相等
- 5.4 赋值运算符重载
- 6 日期类的实现
-
- 6.1日期类的接口实现
- 6.2 日期类的实现
- 7 const成员
- 8取地址及const取地址操作符重载
- 9日期类源代码
-
- 9.1 Date.h
- 9.2 Date.cpp
- 9.3 Test.cpp
1 类的默认成员函数
在C++中，一个空类，里面并不是什么都没有，编译器会自动生成以下6个默认成员函数。
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。
2 构造函数
2.1 功能
构造函数，完成成员变量初始化的工作(相当于数据结构中写的Init函数)。
之所以设计出构造函数，是为了保证对象一定会被初始化。有时候我们可能会忘记去初始化。
在初学数据结构阶段，我们多多少少都会犯这样的错误，没有初始化栈，就去往栈里面插入数据，进行一系列操作，等到编译的时候才发现连最初的初始化都没有做。然而，C++里面的构造函数就可以解决这个问题，保证对象一定会被初始化。
2.2 特性
构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象(这里一定要注意，很多初学的小伙伴都会搞错，开空间创建对象是编译器干的事情
其特征如下：
1.函数名与类名相同。
2.无返回值。
3.对象实例化时编译器自动调用对应的构造函数,并且在对象整个生命周期内只调用一次。
4.构造函数可以重载。
对象实例化时会调用对应的构造函数，即无参的调用无参的构造函数，含参的调用含参的构造函数。这里需注意，如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
也就是说，如果我们没有写构造函数，编译器还会帮助我们自动生成一个，这还有点神奇哈！真的是这样吗？一起来验证下
将之前写的构造函数屏蔽掉，发现编译通过，但编译器并没有帮助我们初始化d1，还是随机值。这是为什么呢？
原来在最初设计默认生成的构造函数时，对内置类型不做处理，自定义类型成员会去调用它的默认构造函数。
所谓内置类型就是语言本身提供的数据类型，如：int，double，char…这些，而自定义类型是我们用class或者struct自己定义的类型。
Date里面没有写构造函数，所以编译器会自动生成一个默认的构造函数，由于_day,_month,_year都是内置类型int，所以编译器不做处理，而对于自定义类型_time编译器会做处理，去调用它的默认构造函数，所以最终_time里面的成员都初始化了，而剩下的三个内置类型为随机值。
如果Time里面也没有写构造函数，那么最终_time里面的成员变量也不会被初始化
注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。
2.3默认构造函数
除了上文提到的我们没写编译器默认生成的函数是默认构造函数，无参的构造函数和全缺省的构造函数也可以称为默认构造函数，并且默认构造函数只能有一个。
即默认构造函数的特点是只要不传参数就可以调用。
2.4 Example
2.4.1Date类的构造函数
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
protected:
int _day;
int _month;
int _year;
};
int main()
{
Date d1(2022, 8, 26);
return 0;
}
日期类，因为它的成员变量一般情况下都是内置类型，我们不写编译器默认生成的也不会作初始化。所以对于日期类我们建议写一个全缺省的构造函数，这样如果没有传参就会使用形参的缺省值，如果传参了就会用传递的参数去初始化成员变量。
2.4.2 stack类的构造函数
class stack
{
public:
stack(int capacity = 3)
{
_array = (DataType*)malloc(sizeof(DataType)*capacity);
_capacity = capacity;
_size = 0;
}
protected:
DataType* _array;
int _capacity;
int _size;
};
int main()
{
stack st;
return 0;
}
stack的成员变量也是内置类型的，所以我们给capacity一个缺省值，剩下的放在函数体里面进行初始化。
2.4.3 MyQueue类的构造函数
MyQueue是用两个栈实现队列
class MyQueue
{
protected:
stack t1;
stack t2;
};
int main()
{
MyQueue q1;
return 0;
}
MyQueue的成员变量都是自定义类型，它的构造函数我们可以不用写，让编译器自己去调用自定义类型成员的默认构造函数(前提是stack的默认构造函数已经写好)
3析构函数
3.1 功能
析构函数：与构造函数功能相反，完成对象中资源的清理工作。(相当于数据结构中写的Destroy函数)
注意：析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。
3.2 特性
1.析构函数名是在类名前加上字符 ~。
2.无参数无返回值类型。
3.一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载
4. 对象生命周期结束时，C++编译系统自动调用析构函数。
5多个对象调用析构函数的顺序和创建对象的顺序是相反的，符合先进后出的原理
对构造函数和析构函数调用顺序的深入理解
前面我们已经讲过，多个对象调用析构函数的顺序和创建对象的顺序是相反的，先构造的函数会后析构，先来验证以下吧
class A
{
public:
A(int a = 0)
{
_a = a;
cout << "A(int a = 0)->" <<_a<< endl;
}
~A()
{
cout << "~A()->" <<_a<<endl;
}
private:
int _a;
};
int main()
{
A aa1(1);
A aa2(2);
A aa3(3);
A aa4(4);
return 0;
}
很明显，构造顺序是1,2,3,4析构顺序是4,3,2,1,析构顺序与构造顺序相反
再来康康下面这段代码
class A
{
public:
A(int a = 0)
{
_a = a;
cout << "A(int a = 0)->" <<_a<< endl;
}
~A()
{
cout << "~A()->" <<_a<<endl;
}
private:
int _a;
};
A a5(5);//全局对象
static A a6(6);//全局静态对象
void fun()
{
static A a1(1);//局部静态对象
A a2(2);
A a3(3);
static A a4(4);//局部静态对象
}
int main()
{
fun();
fun();
return 0;
}
这段代码里面既有局部对象，也有全局的，静态的对象，那么顺序应该是什么呢？先看构造的顺序，因为a5,a6都是全局对象，所以肯定先初始化，紧接着初始化fun函数里面的成员，a1,a4是局部静态对象，只第一次进来的时候初始化，所以虽然调用了两次fun函数，但局部静态对象只会初始化一次。综上所述，构造顺序为5,6,1,2,3,4,2,3
再看看析构的顺序，全局对象和静态对象存储在静态区，在整个程序结束以后才会销毁。当第一次调用fun函数结束的时候，局部对象会先被清理，因为先初始化的后清理，所以顺序为3,2；第二次调用fun函数结束的时候，一样是先清理3,2。等整个程序结束的时候才会去清理静态区的对象，而清理静态区也符合先初始化的后清理原则，顺序为4,1,6,5
3.3 默认的析构函数
与构造函数类似，我们没写析构函数，编译器会自己生成一个默认的析构函数，内置类型不做处理，自定义类型会去调用它的析构函数
可以看出，在Date里面，没有写析构函数，所以编译器会自己生成一个析构函数，对内置类型没做处理，(其实内置成员在销毁是也不需要做资源清理，最后出了作用域系统直接将其内存回收即可)。而对于自定义类型的成员，调用了它自己的析构函数，所以屏幕上打印了"~Time"。
3.4 Example
3.4.1 Date类的析构函数
因为类中没有申请资源，析构函数可以不写，直接使用编译器生成的默认析构函数
3.4.2 stack类的析构函数
因为有在堆上malloc申请空间，一定要写，否则会造成资源泄漏
class stack
{
public:
stack(int capacity = 3)
{
_array = (DataType*)malloc(sizeof(DataType)*capacity);
_capacity = capacity;
_size = 0;
}
void stackpush()
{
}
~stack()
{
cout <<"~stack()" << endl;
free(_array);
_capacity = _size = 0;
_array = nullptr;
}
protected:
DataType* _array;
int _capacity;
int _size;
};
int main()
{
stack st;
return 0;
}
3.4.3 MyQueue类的析构函数
MyQueue类中的成员都是自定义类型，所以不用自己写，编译器自己调用自定义类型成员对应的析构函数
4 拷贝构造函数
4.1 功能
在创建对象时，可以创建一个与已知对象一模一样的新对象
4.2 特征
1.拷贝构造函数是构造函数的一个重载形式。
2.拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
为什么传值传参就会发生无穷递归调用呢？
我们知道，形参是实参的拷贝，也就是说实参d1传递给形参date的时候，是拷贝完成的，而只要拷贝，就需要调用拷贝构造函数，调用拷贝构造函数，又需要传参，传参又需要拷贝构造函数…这样一直循环下去，没完没了，所以这里不能用传值传参。
用传引用传参为什么就可以了呢？
用引用传参，d就相当于d1的别名，这里是不需要拷贝的，对d的操作就相当于对d1的操作，在函数体内将d的成员变量赋值给d2的成员变量，也就相当于将d1的成员变量赋值给d2。
4.3 默认的拷贝构造函数
若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对于内置类型按照字节方式直接拷贝(这种拷贝叫做浅拷贝，或者值拷贝)就相当于memcpy函数，自定义类型会调用自己的拷贝构造函数。
将d1拷贝给d2，会调用拷贝构造函数，因为Date类中并没有写拷贝构造函数，所以编译器会自己生成默认的拷贝构造函数，对于_year,_month,_day这样的内置类型，直接按字节方式浅拷贝，_Time这样的自定义类型，会调用自己的拷贝构造函数，而Time类同样也没有写拷贝构造函数，所以编译器调用默认生成的拷贝构造函数，因为_hour,_minute,_second都是内置类型，因此同样按照字节方式浅拷贝。
我们可以看出，不管是内置类型，还是自定义类型，如果不写拷贝构造函数，都会按照字节方式进行浅拷贝，那我们还需要自己实现拷贝构造函数吗?
一起看看下面的代码
将st1拷贝给st2，会调用拷贝构造函数，因为stack类没有写拷贝构造函数，所以编译器默认生成，按照值进行拷贝，也就是将st1中的内容原封不动的拷贝到st2中，此时st1中的_array和st2中的_array指向了同一块空间，这就有bug了。先看结果
程序崩溃，打印了两次"~stack",也就是调用了两次析构函数，但清理的是同一块空间。同一块内存空间释放多次，肯定会造成程序崩溃。
综上所述：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
4.4 Example
4.4.1 Date类的拷贝构造函数
class Date
{
public:
Date(int year = 1, int month = 1, int day= 1)
{
_day = day;
_month = month;
_year = year;
}
protected:
int _day;
int _month;
int _year;
};
int main()
{
Date d1;
Date d2(d1);
return 0;
}
因为成员变量都不涉及资源申请，可以直接进行浅拷贝，不需要自己写。
4.4.2 Stack类的拷贝构造函数
成员变量中涉及资源的申请，就必须要自己写，这里就是深拷贝(后面会讲)
4.4.3 MyQueue类的拷贝构造函数
可以不用自己写，让编译器自己去调用它的自定义类型成员的拷贝构造函数，(前提是Stack中必须要写好)
4.5 拷贝构造函数的使用场景
(1)使用已存在对象创建新对象
(2)函数参数类型为类类型对象
(3)函数返回值类型为类类型对象
5 运算符重载
对于内置类型的变量，想要进行运算，可以直接使用运算符进行运算，因为编译器自己知道如何运算，但自定义类型呢？比如日期类，我们想要实现日期+日期，可以直接使用运算符吗？肯定是不可以的，这里就需要用到运算符重载
5.1 概念
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
一般情况下，有几个操作数就有几个参数，返回值类型根据自己的需求定。
5.2 注意
1不能通过连接其他符号来创建新的操作符：比如operator@
2重载操作符必须有一个类类型参数
3用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
4作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
5 以下5个运算符不能重载
5.3 Example(以日期类为例)
5.3.1 判断日期时是否相等
这里会发现，运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证？
可以用我们后面学习的友元解决。(先铺个彩蛋哈!)
也可以作为类成员函数进行运算符重载，但需注意类成员函数的第一个参数为默认的this，所以形参看着比操作数少一个)
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
bool operator==( const Date& d)
{
// bool operator==(Date* this, const Date& d)
//实际上形参的参数，左操作数是this，指向调用函数的对象
return ((this->_year == d._year) &&
(this->_month == d._month) &&
(this->_day == d._day));
}
protected:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2022, 8, 26);
Date d2(2022, 8, 27);
/*cout << operator==(d1, d2) << endl;err，形参与实参的参数不匹配*/
//调用成员函数可以用以下两种方式调用，但很明显第二种方式可读性更强
cout << d1.operator==(d2) << endl;
cout << (d1 == d2) << endl;
return 0;
}
5.4 赋值运算符重载
赋值运算符重载格式
1 参数类型：const T&，传递引用可以提高传参效率
2 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
3 检测是否自己给自己赋值
4 返回*this ：要符合连续赋值的含义
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
//赋值运算符重载
Date& operator=(const Date& d)
{
if (this != &d)//避免自己给自己赋值
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
protected:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2022, 8, 20);
Date d2;
d2 = d1;
}
之所以能用传引用返回，是因为*this出了赋值运算符重载的作用域不会销毁，*this就相当于d2,而d2的作用域不在重载函数里面，所以出了赋值运算符重载函数的作用域不会销毁。
注意：
(1) 用户没有显示写赋值运算符重载函数时，编译器就会默认生成一个，以值的方式逐字节拷贝，对内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值
这里什么时候用默认生成的赋值运算符重载函数，什么时候用自己写的，可以参照上文拷贝构造函数的情况。
(2) 赋值运算符只能重载成类的成员函数不能重载成全局函数,因为如果用户不显示写赋值运算符重载函数，编译器会默认生成一个，此时如果用户再在类外实现一个全局的赋值运算符重载函数，就会与默认生成的赋值运算符重载函数起冲突。
(3)和拷贝构造的区别
拷贝构造函数是用一个已经存在的对象去初始化另一个对象，赋值运算符重载是两个已经存在的对象进行赋值操作。
6 日期类的实现
6.1日期类的接口实现
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);//<=运算符重载
Date operator+(int day);//日期+天数
Date& operator+=(int day);//日期+=天数
Date& operator++(); // 前置++
Date operator++(int); // 后置++
Date operator-(int day);//日期-天数
Date& operator-=(int day);//日期-=天数
Date& operator--(); // 前置--
Date operator--(int); // 后置--
int operator-(const Date& d);//日期-日期
6.2 日期类的实现
实现日期类比较的函数，我们可以只实现>和==的运算符重载，其余的比较函数复用即可，后面的++，- -也可以按照上面的方法实现其中的几个，然后剩下的复用即可。
==运算符重载
bool Date::operator==(const Date& d)
{
return ((_year == d._year) &&
(_month == d._month) &&
(_day == d._day));
}
实现==的运算符重载，逻辑很简单，只要两个日期类的年月日都相等，便可返回true,否则返回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;
}
实现>的运算符重载，写if里面的条件时，注意一层一层来，先是看年，然后看月，最后看天
剩下的函数直接复用即可
!= ， >= ， <， <=运算符重载
bool Date::operator!=(const Date& d)
{
return !(*this == d);
}
bool Date::operator>=(const Date& d)
{
return (*this > d) || (*this == d);
}
bool Date:: operator<(const Date& d)
{
return !(*this >= d);//<的反面是>=
}
bool Date::operator<=(const Date& d)
{
return !(*this > d);//<=的反面是>
}
注意 *this是操作符左边的数，也就是形参隐藏的第一个参数
实现日期+=天数
Date& Date:: operator+=(int day)
{
if (day < 0)//如果输入的day<0，调用日期-天数的函数
{
return *this -= -day;
}
_day += day;//不管是否进位，先把天数加上再说
while (_day > GetMonthDay(_year, _month))//GetMonthDay(_year, _month)函数获取每个月份的最大合法天数，
//如果加后的天数大于该月份的最大天数，进循环
{
_day -= GetMonthDay(_year, _month);//减去当月的最大合法天数，相当于进到下一月
_month += 1;//月份数+1
if (_month == 13)//如果月份加到了13，说明该年进位了
{
_month = 1;//月份修改为1月
_year += 1;//年数+1
}
}
return *this;
}
因为出了作用域*this指针不会销毁,所以可以传引用返回，避免进行拷贝构造
再用+=去复用+
+和+=最大的区别就是+运算符重载不会改变日期类本身的值，只是把天数加上去，而+=会把天数直接加到日期类上去，日期类会改变。
日期+天数
Date Date:: operator+(int day)
{
Date tmp(*this);//拷贝出一个临时对象
(tmp += day);//给临时对象+=天数
return tmp;
}
注意：tmp为临时对象，出了作用域会销毁，所以不可传引用返回
日期-=天数，日期-天数的实现思想和日期+=天数，日期+天数类似
实现日期 -= 天数
Date& Date::operator-=(int day)
{
if (day < 0)//如果day<0，调用+=运算符重载函数
{
return *this += -day;
}
_day -= day;//不管需不需要借位，先减去天数
while (_day <= 0)//减去的天数<=0，说明月份需要往前进，进循环
{
_month--;//月份先往前 -1
if (_month == 0)//月份减到0时，说明此时年份需要往前进
{
_year--;
_month = 12;//月份修改为12月
}
_day += GetMonthDay(_year, _month);//天数加上合法最大值
}
return *this;
}
日期-天数
Date Date::operator-(int day)
{
Date tmp(*this);//拷贝出一个临时对象
tmp -= day;
return tmp;//返回临时变量
}
前置++和后置++重载
前置++和后置++都是一元运算符，为了让前置++与后置++能正确重载，C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
//前置++返回+1之后的值，直接复用+=函数重载，传引用返回
Date& Date::operator++()
{
return (*this += 1);
}
//后置++返回+1之前的值，所以需要把之前的值用tmp临时对象保存起来，再实现+1
//因为tmp对象出了作用域就销毁了，所以只能传值返回
Date Date:: operator++(int)
{
Date tmp(*this);
(*this += 1);
return tmp;
}
前置- -和后置- -重载
//前置--
Date& Date::operator--()
{
*this -= 1;
return *this;
}
//后置--
Date Date::operator--(int)
{
Date tmp(*this);
*this -= 1;
return tmp;
}
日期-日期=天数
实现思想，找出两个日期中较大的和较小的，然后从较小的加到较大的那一天，计算加了多少天，就是二者相隔的天数
int Date::operator-(const Date& d)
{
int flag = -1;
Date max = *this;
Date min = d;
//先假设大的是左边的操作数，小的是右边的操作数
if (max < min)
{
max = d;
min = *this;
flag = 1;
//如果与假设错误，则交换
}
int n = 0;
while (min != max)
{
min++;
n++;
//计算从小的那一天加到大的那一天一共加了多少天
}
return n * flag;//小的日期减大的日期相隔的天数为正数
//大的日期减小的日期相隔的天数为负数
}
流插入，流提取运算符重载
对于内置类型，我们想输出变量或输入变量， 直接cout<< ， cin>> 就行，在输出和输入的时候，不用自己输入类型，它可以自己识别类型，我们有没有想过，是怎么做到的呢？
cin是istream类型的对象，cout是ostream类型的对象
可以看出，之所以能自动识别类型，是因为库里面已经写好了内置类型的运算符重载函数，这些函数构成了函数重载，需要调用哪个，就根据函数名修饰规则，调用相应的函数。内置类型库里面有写好的，那自定义类型怎么办呢?没有我们就只能自己创造喽
inline ostream& operator<<(ostream& out,const Date&d)
{
out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
return out;
}
inline istream& operator>>(istream& in,Date&d)
{
in >> d._year >> d._month >> d._day;
return in;
}
将这两个函数重载成全局的函数，此时面临着一个问题，类里面私有的对象无法访问，这里我们采用友元的方式来解决(下一篇会详细讲)
在类的内部声明，声明时需要加friend关键字。这样友元函数就可以直接访问类的私有成员
因为流提取和流插入函数会频繁调用，所以可以搞成内联函数，为了支持连续的输入输出，所以要有返回值
这里有童鞋可能会有疑惑，既然类外面不能访问私有成员，那为什么我们不直接放类里面呢？
若放在类里面，成员函数的第一个参数都是隐藏的this，也就是在调用的时候需要写成这样d1<
7 const成员
将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针所指向的内容，表明在该成员函数中不能对类的任何成员进行修改
要解决此问题，只能将成员函数也变为const修饰的
一般成员函数内不对成员变量做修改，都建议把成员函数写成const修饰的，这样const对象和非const对象都可以调用这个函数
8取地址及const取地址操作符重载
这两个默认成员函数一般不用重新定义 ，编译器默认会生成
class Date
{
public :
Date* operator&()
{
return this ;
}
const Date* operator&()const
{
return this ;
}
private :
int _year ;
int _month ;
int _day;
};
9日期类源代码
9.1 Date.h
#include 9.2 Date.cpp
#include "Date.h"
void Date::Print()const
{
cout << _year << '/' << _month << '/' << _day << endl;
}
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 !(*this == d);
}
bool Date:: operator>(const Date& d)const
{
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)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);
}
Date& Date:: operator+=(int day)
{
if (day < 0)//如果输入的day<0，调用日期-天数的函数
{
return *this -= -day;
}
_day += day;//不管是否进位，先把天数加上再说
while (_day > GetMonthDay(_year, _month))//GetMonthDay(_year, _month)函数获取每个月份的最大合法天数，
//如果加后的天数大于该月份的最大天数，进循环
{
_day -= GetMonthDay(_year, _month);//减去当月的最大合法天数，相当于进到下一月
_month += 1;//月份数+1
if (_month == 13)//如果月份加到了13，说明该年进位了
{
_month = 1;//月份修改为1月
_year += 1;//年数+1
}
}
return *this;
}
Date Date:: operator+(int day)const
{
Date tmp(*this);//拷贝出一个临时对象
(tmp += day);//给临时对象+=天数
return tmp;
}
//前置++返回+1之后的值，直接复用+=函数重载，传引用返回
Date& Date::operator++()
{
return (*this += 1);
}
//后置++返回+1之前的值，所以需要把之前的值用tmp临时对象保存起来，再实现+1
//因为tmp对象出了作用域就销毁了，所以只能传值返回
Date Date:: operator++(int)
{
Date tmp(*this);
(*this += 1);
return tmp;
}
Date& Date::operator-=(int day)
{
if (day < 0)//如果day<0，调用+=运算符重载函数
{
return *this += -day;
}
_day -= day;//不管需不需要借位，先减去天数
while (_day <= 0)//减去的天数<=0，说明月份需要往前进，进循环
{
_month--;//月份先往前 -1
if (_month == 0)//月份减到0时，说明此时年份需要往前进
{
_year--;
_month = 12;//月份修改为12月
}
_day += GetMonthDay(_year, _month);//天数加上合法最大值
}
return *this;
}
Date Date::operator-(int day)const
{
Date tmp(*this);//拷贝出一个临时对象
tmp -= day;
return tmp;//返回临时变量
}
//前置--
Date& Date::operator--()
{
*this -= 1;
return *this;
}
//后置--
Date Date::operator--(int)
{
Date tmp(*this);
*this -= 1;
return tmp;
}
int Date::operator-(const Date& d)const
{
int flag = -1;
Date max = *this;
Date min = d;
//先假设大的是左边的操作数，小的是右边的操作数
if (max < min)
{
max = d;
min = *this;
flag = 1;
//如果与假设错误，则交换
}
int n = 0;
while (min != max)
{
min++;
n++;
//计算从小的那一天加到大的那一天一共加了多少天
}
return n * flag;//小的日期减大的日期相隔的天数为正数
//大的日期减小的日期相隔的天数为负数
}
9.3 Test.cpp
#include "Date.h"
void TestDate1()
{
Date d1(2022, 8, 24);
Date d2(2022, 8, 26);
Date d3(2022, 9, 23);
Date d4(2020, 10, 3);
cout << (d1 < d2) << endl;
cout << (d2 >= d3) << endl;
cout << (d3 == d4) << endl;
cout << (d3 < d1) << endl;
}
void TestDate2()
{
Date d1(2022, 8, 24);
(d1 + 4).Print();
(d1 + 40).Print();
(d1 + 400).Print();
(d1 + 4000).Print();
d1++.Print();
d1.Print();
/*(++d1).Print();
d1.Print();*/
}
void TestDate3()
{
Date d1(2022, 8, 24);
(d1-4).Print();
(d1 - 40).Print();
(d1 - 400).Print();
(d1 - 4000).Print();
(d1--).Print();
d1.Print();
(--d1).Print();
d1.Print();
}
void TestDate4()
{
Date d1(2022, 8, 24);
Date d2(1999, 9, 1);
cout << d1-d2<< endl;
cout << d2-d1<< endl;
}
void TestDate5()
{
Date d1;
Date d2;
int day = 0;
int option = 0;
do
{
cout << "****************************" << endl;
cout << "1日期加减天数 2.日期-日期" << endl;
cout << "3.退出 " << endl;
cout << "请输入选择";
cin >> option;
if (option == 1)
{
cout <<"请输入日期和天数,(减去天数就输入负数)"<<endl;
cin >> d1 >> day;
if (d1.CheckDate())
{
cout << (d1 + day) << endl;
}
else
cout << "输入日期错误，请重新输入" << endl;
}
if (option == 2)
{
cout << "请输入两个日期" << endl;
cin >> d1 >> d2;
if (d1.CheckDate()&&d2.CheckDate())
{
printf("二者相差%d天\n", d1 - d2);
}
else
cout << "输入日期错误，请重新输入" << endl;
}
if (option == 3)
{
cout << "退出程序" << endl;
break;
}
} while (option != -1);
}
int main()
{
/*TestDate1();
TestDate2();
TestDate3();*/
/*TestDate4();*/
TestDate5();
return 0;
}