C++初阶：类与对象(中）

文章目录

1 类的默认成员函数
2 构造函数
3析构函数
4 拷贝构造函数
5 运算符重载
6 日期类的实现
- 6.1日期类的接口实现
- 6.2 日期类的实现
7 const成员
8取地址及const取地址操作符重载
9日期类源代码

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<<cout ；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 <iostream>
#include <assert.h>
using namespace std;
class Date
{
	friend inline ostream& operator<<(ostream& out, const Date& d);
	friend  inline istream& operator>>(istream& in, Date& d);
public:
	
	int GetMonthDay(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 (month == 2 && (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
		{
			day += 1;
		}
		return day;
	}
	bool CheckDate()
	{
		if (_year >= 1
			&& _month > 0 && _month < 13
			&& _day>0 && _day <= GetMonthDay(_year, _month))
			return true;
		else
			return false;
	}
	Date(int year = 1, int month = 1, int day = 1)//构造函数
	{
		_year = year;
		_month = month;
		_day = day;
		assert(CheckDate());
	}
	void Print()const;
	bool operator==(const Date& d)const;//==运算符重载
	bool operator!=(const Date& d)const;//！=运算符重载
	bool operator>(const Date& d)const;//>运算符重载
	bool operator>=(const Date& d)const;//>=运算符重载
	bool operator<(const Date& d)const;//<运算符重载
	bool operator<=(const Date& d)const;//<=运算符重载

	Date operator+(int day)const;//日期+天数
	Date& operator+=(int day);//日期+=天数
	Date& operator++(); // 前置++
	Date operator++(int); // 后置++
	Date operator-(int day)const;//日期-天数
	Date& operator-=(int day);//日期-=天数
	Date& operator--(); // 前置--
	Date operator--(int); // 后置--
	int operator-(const Date& d)const;//日期-日期
	
protected:
	int _year;
	int _month;
	int _day;
};
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;
}

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;
}