《日期类》

本文主要附上日期类的代码，不做讲解，代码中都有注释

---

前言

首先创建3个文件

date.h:用于日期类函数的声明
date.cpp：用于实现日期类的函数
test.c:用于测试

Date.h

#pragma once

#include 
#include 
using namespace std;


//ios::sync_with_stdio(false); // 关掉同步，提速 cin 
//cout.tie(NULL); // 提速 cout


//本日期类实现的功能：主要是运用运算符重载
//1：给你一个日期和天数，使用运算都重载知识，实现
// (1)日期+=天数
// (2)日期+天数
// (3)日期-=天数
// (4)日期-天数
// (5)++日期 （前置++）
// (6)日期++（后置++）
// (7)--日期（前置--）
// (8)日期--（后置--）

//2：实现日期比较，初始化两个日期对象。然后比较两个日期对象的的大，也是使用运算符重载知识，因为日期类不是内置类型
//（1）	>
//（1）	<
//（1）	==
//（1）>=
//（1）<=
//（1）!=
//（1）日期-日期（返回相差的天数）
//（1）=(赋值)




//日期类
class Date
{
public:
	 
	//友元函数
	friend ostream& operator<<(ostream& out, const Date& d);

	//cin >d1
	friend istream& operator>>(istream& in, Date& d);

	//构造函数
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//拷贝构造函数
	//d2(d1)
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	//1:赋值运算符 d1 = d2     d1.operator=(d2)
	Date& operator=(const Date& d);

	//获取当月的日期
	int GetMonthDay(int year, int month)const;

	//2:日期+=天数 d1+=100
	Date& operator+=(int day);

	//3:日期+天数 d1+100
	Date operator+(int day)const;

	//4:日期-天数 d1-100
	Date operator-(int day)const;

	//5:日期-=天数 d1-=100
	Date& operator-=(int day);

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

	//7:后置++,用一个参数为了占位，区别前置和后置，没有实际意义
	Date operator++(int);


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

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

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

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

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

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

	//14:日期-日期
	int operator-(const Date& d)const;  //和日期-天数构成函数重载


	void print();

	//析构函数
	~Date() {}
private:
	int _year;
	int _month;
	int _day;
};


//写成内敛需要放在.h里面，因为内敛的声明和定义不能分离
//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)//这里的d应该可以修改
//{
//	in >> d._year >> d._month >> d._day;
//	return in;
//}

Date.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include "date.h"

void Date::print()
{
	cout << _year << "/" << _month << "/" << _day << endl;
}


//1:赋值运算符 d1 = d2     d1.operator=(d2)
Date& Date::operator=(const Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
	return *this;
}

//获取当月的日期
int Date::GetMonthDay(int year, int month) const
{
	assert(month > 0 && month < 13);
	int arr[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	if (month == 2 && ((year % 4 == 0 && year %100 != 0) || year % 400 ==0))
	{
		return 29;
	}
	return arr[month];
}


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

//3:日期+天数 d1+100
Date Date::operator+(int day)const
{
	Date temp(*this);
	/*temp._day += day;
	while (temp._day > GetMonthDay(temp._year, temp._month))
	{
		temp._day -= GetMonthDay(temp._year, temp._month);
		temp._month++;
		if (temp._month == 12)
		{
			temp._year++;
			temp._month = 1;
		}
	}*/
	//复用+=，这种复用更好
	temp += day;
	return temp;
}

利用-复用实现-=，不好，复用-时需要调用拷贝构造
4:日期-天数 d1-100
//Date Date::operator-(int day)
//{
//	Date temp(*this);
//	temp._day -= day;
//	while (temp._day <= 0)
//	{
//		temp._month--; 
//		if (temp._month == 0)
//		{
//			temp._year--;
//			temp._month = 12;
//		}
//		temp._day += GetMonthDay(temp._year, temp._month);  //向上个月借天数，更新天数
//	}
//	return temp;
//}
//
//
5:日期-=天数 d1-=100
//Date& Date::operator-=(int day)
//{
//	*this = *this - day;
//	return *this;
//}


//利用-=复用实现-,实现-=不需要拷贝构造，实现减时候只需要两次
//4:日期-天数 d1-100
Date Date::operator-(int day)const
{
	Date temp(*this);
	temp -= day;
	return temp;
}


//5:日期-=天数 d1-=100
Date& Date::operator-=(int day)
{
	_day -= day;
	while (_day <= 0)
	{
		_month--;
		if (_month == 0)
		{
			_year--;
			_month = 12;
		}
		_day += GetMonthDay(_year, _month);  //向上个月借天数，更新天数
	}
	return *this;
}




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


//7:后置++,用一个参数为了占位，区别前置和后置，没有实际意义
Date Date::operator++(int)
{
	Date temp = *this;
	*this += 1;
	return temp;
}


// 8:>运算符重载
bool Date::operator>(const Date& d)const
{
	/*if (_year > d._year)
	{
		return true;
	}
	else if (_year == d._year && _month > d._month)
	{
		return true;
	}
	else if (_year == d._year && _month == d._month && _day > d._day)
	{
		return true;
	}
	else
	{
		return false;
	}*/

	return (_year > d._year
			|| _year == d._year && _month > d._month
			|| _year == d._year && _month == d._month && _day > d._day);
}


// 9:==运算符重载
bool Date::operator==(const Date& d)const
{
	/*if (_year == d._year && _month == d._month && _day == d._day)
	{
		return true;
	}
	else
	{
		return false;
	}*/
	return (_year == d._year && _month == d._month && _day == d._day);
}



// 10:>=运算符重载
bool Date::operator >= (const Date& d)const
{
	/*if (*this > d || *this == d)
	{
		return true;
	}
	else
	{
		return false;
	}*/
	return (*this > d || *this == d);
}

//11: <运算符重载
bool Date::operator < (const Date& d)const
{
	return !(*this >= d);
}


//12: <=运算符重载
bool Date::operator <= (const Date& d)const
{
	return !(*this > d);
}



//13: !=运算符重载
bool Date::operator != (const Date& d)const
{
	return !(*this == d);
}


//14:日期-日期
//找出一个小的日期，让小的日期一直++，并且记录++的次数，直到等于大的那个就结束，返回++的次数
//注意：加一个flag防止在使用该操作符时，不知道那个大，这样就不在-两边的操作数的大小了
int Date::operator-(const Date& d)const  //和日期-天数构成函数重载
{
	Date max = *this;
	Date min = d;
	int flag = 1;
	int n = 0;
	if (max < d)
	{
		max = d;
		min = *this;
		flag = -1;
	}
	while (min != max)
	{
		++min;
		++n;
	}
	return n * flag;
}


15:重载实现 <<
1：d1 << cout;太别扭了，且不能改变
//void Date::operator<<(ostream& out)
//{
//	out << _year << "/" << _month << "/" << _day << endl;
//}

15:重载实现	<<	流插入
 在外面写成函数,是全局函数，不是成员函数
cout << d1 << d2
//ostream& operator<<(ostream& out, const Date& d)
//{
//	out << d._year << "/" << d._month << "/" << d._day << endl;
//	return out;
//} 
//
//
16:重载实现 >>
 全局函数，不是成员函数,没有
cin >d1
//istream& operator>>(istream& in, Date& d)//这里的d应该可以修改
//{
//	in >> d._year >> d._month >> d._day;
//	return in;
//}
//


ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "/" << d._month << "/" << d._day << endl;
	return out;
}

istream& operator>>(istream& in, Date& d)//这里的d应该可以修改
{
	in >> d._year >> d._month >> d._day;
	return in;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1


#include "date.h"

//演示+=
void test1()
{
	Date d1(2023, 3, 27);
	d1 += 100;
	d1.print();  //d1改变
}

//演示+
void test2()
{
	Date d1(2023, 3, 27);

	Date d2;
	d2 = d1 + 100;

	d1.print();
	d2.print();
}

//演示-
void test3()
{
	Date d1(2023, 3, 27);

	Date d2;
	d2 = d1 - 100;

	d1.print();
	d2.print();
}


//演示-=
void test4()
{
	Date d1(2023, 3, 27);
	d1.print();

	d1 -= 100;
	d1.print();
}


//演示前置++和后置++
void test5()
{
	Date d1(2023, 3, 27);
	Date d2(2023, 3, 27);
	
	
	(d1++).print();  //2023/3/27
	(++d2).print();	//2023/3/28
}





//演示日期之间的比较
void test6()
{
	Date d1(2023, 3, 27);
	Date d2(2023, 3, 29);

	cout << (d1 > d2) << endl;	//0
	cout << (d1 == d2) << endl;//0
	cout << (d1 >= d2) << endl;//0
	cout << (d1 < d2) << endl;//1
	cout << (d1 <= d2) << endl;//1
	cout << (d1 != d2) << endl; //1
}


//演示日期-日期=之间的天数
void test7()
{
	Date d1(2023, 3, 27);
	Date d2(2023, 8, 15);
	cout << (d2 - d1) << endl;
}


//演示运算符重载实现cout和cin
//cout 是类ostream里面的一个对象
//cin 是类istream里面的一个对象
//void test8()
//{
//	Date d1(2023, 3, 27);
//	d1 << cout;  =》  d1.operator<<(cout)
// 
// 
//}

void test9()
{
	Date d1(2023, 3, 27);
	Date d2(2023, 3, 28);
	cout << d1 << endl;  //=》operator<<(cout,d1)
	cout << d1 << d2 <<endl;  //=》
}

void test10()
{
	Date d1;
	cin >> d1;  //输入时记得加上空格，就和普通的cin输入数字一样
	cout << d1;
}


int main()
{
	test3();
	return 0;
}