C++——类和对象练习（日期类）

初夏02024-04-22 21:35

日期类

  • [1. 构造函数和析构函数](#1. 构造函数和析构函数)
  • [2. 拷贝构造和赋值运算符重载](#2. 拷贝构造和赋值运算符重载)
  • [3. 运算符重载](#3. 运算符重载)
    • [3.1 日期的比较](#3.1 日期的比较)
    • [3.2 日期加减天数](#3.2 日期加减天数)
    • [3.3 日期减日期](#3.3 日期减日期)
    • [3.4 流插入和流提取](#3.4 流插入和流提取)
  • [4. 取地址和const取地址重载](#4. 取地址和const取地址重载)
  • [5. 完整代码](#5. 完整代码)

对日期类进行一个完善，可以帮助我们理解六个默认成员函数，这里选择全部显式实现，包括构造函数，运算符重载，赋值重载等。对有之前的知识点的提示，以及注意事项，这里采用声明和定义分离的形式，下面代码放的全部是定义，除非必要说明。在最后会有完整的代码。包括头文件和源文件内的。

1. 构造函数和析构函数

cpp 复制代码 
//构造函数，初始化列表
Date::Date(int year = 2024, int month = 1, int day = 1)
	:_year(year)
	,_month(month)
	,_day(day)
{}

//析构函数
Date::~Date() {}

2. 拷贝构造和赋值运算符重载

cpp 复制代码 
//拷贝构造函数
Date::Date(const Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

//赋值运算符重载
Date& Date::operator=(const Date& d)
{
    //可能出现d=d的情况，即自己给自己赋值，可以不用执行代码
	if (this != &d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	return *this;
}

3. 运算符重载

3.1 日期的比较

比较包括大于，等于，小于，大于或等于，小于或等于，不等于六种。

不需要全部都实现，复用代码即可。我们先写一个大于，日期的比较按照年月日依次比较，年大日期就大，年等的情况，月大日期就大，年等月等的情况，天大日期就大。剩下的所有情况就是不大于。

cpp 复制代码 
//运算符重载  大于
bool Date::operator>(const Date& d)const
{
	//年大日期就大
	if (_year > d._year)
	{
		return true;
	}
	else if (_year == d._year)
	{
		//年等，月大日期就大
		if (_month > d._month)
		{
			return true;
		}
		else if (_month == d._month)
		{
			//年等月等，天大日期就大
			if (_day > d._day)
			{
				return true;
			}
		}
	}
	return false;
}

再写一个等于，年月日都相等，日期才相等。

cpp 复制代码 
//等于
bool Date::operator==(const Date& d)const
{
	return _year == d._year &&
		_month == d._month &&
		_day == d._day;
}

剩下的四种比较全部复用这两个函数即可。
小于就是不大于或不等于。
小于等于就是不大于
大于等于就是不小于
不等于就是等于取反

这种方法适用于所有需要重载这六种运算符的类，只需要写一个大于和等于或小于和等于，剩下的都复用代码即可。

cpp 复制代码 
//小于
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) || (*this > d);
}

//不等于
bool Date::operator!=(const Date& d)const
{
	return !(*this == d);
}

3.2 日期加减天数

加包括 + 和 +=，减包括 - 和 -=。前者不会修改左操作数，后者会修改左操作数，比如

a=10;

a+5 //不会修改a

a+=5 //会修改a

减同理。

这里先实现 += ，我们需要判断闰年，因为闰年2月有29天，因此，这里封装一个函数，用来获得某年某月的最大天数。

cpp 复制代码 
//内联函数声明定义不能分离，在调用处直接展开，不用建立栈帧
inline int GetMonthDay(int year, int month) //获得某年某月的天数
{
	int MonthDay[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
	{
		++MonthDay[2];
	}
	return MonthDay[month];
}

由于这个函数会频繁调用，因此将这个函数声明为内联函数，由于声明定义不能分离，所有这段代码是在头文件内。

有了这个函数后，在实现+=就比较容易了，我们不需要判断是不是闰年，是不是二月了，全部交给这个函数就可以了。

思路：把天全部加上，判断是否超过该月最大天数。有则进行修改，在判断是否超过最大月份，有则进行修改。循环，直到天数小于该月的最大天数。

那么+=代码如下

cpp 复制代码 
//日期加等天数（会改变*this）
Date& Date::operator+=(int day)
{
    //+=一个负数，相当于-=一个正数
	if (day < 0)
	{
		*this -= -day;
	}
	else
	{
		_day += day;
		while (_day > GetMonthDay(_year, _month))
		{
			_day -= GetMonthDay(_year, _month);
			_month++;
			if (_month == 13)
			{
				_year++;
				_month = 1;
			}
		}
	}
	return *this;
}

+的实现，可以复用+=的代码

如下

cpp 复制代码 
//日期加天数（不会改变*this）
Date Date::operator+(int day) const
{
	//加不改变*this，需要创建局部变量
	Date retDate = *this;//拷贝构造
	retDate += day;
	//出作用域局部变量销毁，不能传引用返回
	return retDate;
}

因为+不能改变*this，所以先拷贝一个对象，修改这个对象的内容，在返回。

-= 和 - 的重载很类似，就不赘述了，直接放码

cpp 复制代码 
//日期减天数
Date Date::operator-(int day) const
{
	Date retDate = *this;
	retDate -= day;
	return retDate;
}

Date& Date::operator-=(int day)
{
	if (day < 0)
	{
		*this += -day;
	}
	else
	{
		_day -= day;
		while (_day <= 0)
		{
			--_month;
			if (_month == 0)
			{
				--_year;
				_month = 12;
			}
			_day += GetMonthDay(_year, _month);
		}
	}
	return *this;
}

我们的代码是否正确呢，大家可以自行测试。建议天数跨大一些，以保证不会出现特殊情况。

除了这些，还有++和--操作，并且分为前置和后置。实现起来也很容易，直接复用上面的代码即可。

cpp 复制代码 
//前置++，先++后使用
Date& Date::operator++()
{
	*this += 1;
	return *this;
}
//后置++，先使用后++，为了构成函数重载，后置++需要多一个int类型的参数，不需要我们传参
//函数调用时，编译器自动传参。
Date Date::operator++(int)
{
    //返回修改前的值
	Date retDate(*this);
	*this += 1;
	return retDate;
}

//前置--
Date& Date::operator--()
{
	*this -= 1;
	return *this;
}
//后置--
Date Date::operator--(int)
{
	Date retDate(*this);
	*this -= 1;
	return retDate;
}

3.3 日期减日期

日期的相加没有意义，但是相减还是比较有意义的，比如计算一下我们从出生到现在生活了多久，和对象已经在一起多久等。

有两种方法：

法一：

法二：

先比较日期，在对小日期进行自增，直到与大日期相等。

这里选择法二

cpp 复制代码 
//日期减日期
int Date::operator-(const Date& d) const
{
	//找出日期大的和日期小的
	Date maxDate = *this > d ? *this : d;
	Date minDate = *this < d ? *this : d;
	int flag = 1;
	int day = 0;
	//第一个日期较小，结果是负数。
	if (minDate == *this)
	{
		flag = -1;
	}
	while (minDate != maxDate)
	{
		++minDate;
		++day;
	}
	return day * flag;
}

3.4 流插入和流提取

对于内置类型，可以使用<<和>>来打印或者从键盘输入，自定义类型也可以重载一个流插入和流提取。

cpp 复制代码 
// >>和<<需要重载成全局函数，因为成员函数的第一个参数默认是this，重载成成员函数会打破 cout<<d 的习惯

//流插入重载
ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
	return out;
}

//流提取重载
istream& operator>>(istream& in,Date& d)
{
	cin >> d._year >> d._month >> d._day;
	return in;
}

istream和ostream是标准库内的一种输入输出类型，代码内的cou和in就是cout和cin，只不过是别名，在函数内部可以自己定义输出格式，甚至检查错误等。返回值是为了支持连续的输入和输出。

注意：在类外想使用类内部的私有成员，需要在类内部声明为友元函数。

4. 取地址和const取地址重载

这两个函数较为简单，就不过的讲解了。

cpp 复制代码 
//const取地址重载
const Date* Date::operator&()const
{
	return this;
}
//取地址重载
Date* Date::operator&()
{
	return this;
}

5. 完整代码

Date.h

cpp 复制代码 
#pragma once
#include<iostream>
using namespace std;

class Date
{
	//友元函数声明，友元函数可以在类外使用类内的私有成员
	
	friend ostream& operator<<(ostream& out,const Date& d);
	friend istream& operator>>(istream& out,Date& d);

public:
	//内联函数声明定义不能分离，在调用处直接展开，不用建立栈帧
	inline int GetMonthDay(int year, int month) //获得某年某月的天数
	{
		int MonthDay[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
		if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
		{
			++MonthDay[2];
		}
		return MonthDay[month];
	}

	//构造函数特征：
	//              1、程序员不显示实现的话，编译器会自动生成默认构造函数
	//              2、函数名和类名相同，没有返回值(也不能写void，这是规定)
	//              3、在类对象实例化的过程中编译器对会自动调用对应的构造函数
	//              4、无参的构造函数，全缺省的构造函数，编译器自动生成的构造函数都可以称为默认构造函数，
	//                 并且默认构造函数只能存在一个，虽然编译时没有问题，但在调用时会有歧义
	//              5、构造函数支持函数重载
	//              6、对内置数据类型如int，char，double等，构造函数不做处理，
	//                 对自定义数据类型，编译器会调用对应的默认构造函数
	Date(int year = 2024, int month = 1, int day = 1);


	//析构函数特征：
	//              1、函数名为类名但需要在类名前加 ~ 符号，没有参数，没有返回值（也不能写void，这是规定）
	//              2、我们不显示实现的话，编译器会自动生成对应的析构函数
	//              3、在类对象生命周期结束后，编译器自动调用对应的析构函数
	//              4、析构函数不能重载，因为析构函数没有参数
	//              5、一个类只允许有一个析构函数
	~Date() {};


	//拷贝构造函数特征：
	//                  1、拷贝构造函数是构造函数的重载函数，所以函数名和类名相同
	//                  2、有且只有一个参数，该参数必须是类对象的引用，如果不是引用，编译器会直接报错
	//                  3、若没有显示实现，编译器会自动实现一个默认的拷贝构造函数，对已有的类对象进行拷贝
	//                     但是是按对应的字节序列完成拷贝，这种拷贝方式称为浅拷贝。
	//                  4、编译器生成的默认拷贝构造函数可以完成浅拷贝

	Date(const Date& d);


	//日期的比较，末尾const是限制*this的，此时this的类型为const Date* const this
	//不能修改this指针，也不能修改this指针指向的内容

	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=(const Date& d2);
	Date operator+(int day)const;
	Date& operator+=(int day);

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

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

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

	int operator-(const Date& d) const;

	const Date* operator&()const;

	Date* operator&();

private:
	int _year;
	int _month;
	int _day;
};

Date.c

cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
#include"Date.h"

//构造函数，初始化列表
Date::Date(int year = 2024, int month = 1, int day = 1)
	:_year(year)
	,_month(month)
	,_day(day)
{}

//析构函数
Date::~Date() {}


//拷贝构造函数
Date::Date(const Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

//运算符重载  大于
bool Date::operator>(const Date& d)const
{
	//年大日期就大
	if (_year > d._year)
	{
		return true;
	}
	else if (_year == d._year)
	{
		//年等，月大日期就大
		if (_month > d._month)
		{
			return true;
		}
		else if (_month == d._month)
		{
			//年等月等，天大日期就大
			if (_day > d._day)
			{
				return true;
			}
		}
	}
	return false;
}

//等于
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
{
	return !(*this > d);
}

//大于等于
bool Date::operator>=(const Date& d)const
{
	return (*this == d) || (*this > d);
}

//不等于
bool Date::operator!=(const Date& d)const
{
	return !(*this == d);
}


//Date Date::operator+(int day) const
//{
//	Date retDate = *this;
//	retDate._day += day;
//	while (retDate._day > GetMonthDay(retDate._year, retDate._month))
//	{
//		retDate._day -= GetMonthDay(retDate._year, retDate._month);
//		retDate._month++;
//		if (retDate._month == 13)
//		{
//			retDate._year++;
//			retDate._month = 1;
//		}
//	}
//	
//	return retDate;
//}
//Date& Date::operator+=(int day)
//{
//	*this = *this + day;//赋值
//	return *this;
//}

//日期加天数（不会改变*this）
Date Date::operator+(int day) const
{
	//加不改变*this，需要创建局部变量
	Date retDate = *this;//拷贝构造
	retDate += day;
	//出作用域局部变量销毁，不能传引用返回
	return retDate;
}

//日期加等天数（会改变*this）
Date& Date::operator+=(int day)
{
	if (day < 0)
	{
		*this -= -day;
	}
	else
	{
		_day += day;
		while (_day > GetMonthDay(_year, _month))
		{
			_day -= GetMonthDay(_year, _month);
			_month++;
			if (_month == 13)
			{
				_year++;
				_month = 1;
			}
		}
	}
	return *this;
}

//日期减天数
Date Date::operator-(int day) const
{
	Date retDate = *this;
	retDate -= day;
	return retDate;
}
Date& Date::operator-=(int day)
{
	if (day < 0)
	{
		*this += -day;
	}
	else
	{
		_day -= day;
		while (_day <= 0)
		{
			--_month;
			if (_month == 0)
			{
				--_year;
				_month = 12;
			}
			_day += GetMonthDay(_year, _month);
		}
	}
	return *this;
}

//前置++，先++后使用
Date& Date::operator++()
{
	*this += 1;
	return *this;
}
//后置++，先使用后++，为了构成函数重载，后置++需要多一个int类型的参数，不需要我们传参
//函数调用时，编译器自动传参。
Date Date::operator++(int)
{
	Date retDate(*this);
	*this += 1;
	return retDate;
}

//前置--
Date& Date::operator--()
{
	*this -= 1;
	return *this;
}
//后置--
Date Date::operator--(int)
{
	Date retDate(*this);
	*this -= 1;
	return retDate;
}

//日期减日期
int Date::operator-(const Date& d) const
{
	//找出日期大的和日期小的
	Date maxDate = *this > d ? *this : d;
	Date minDate = *this < d ? *this : d;
	int flag = 1;
	int day = 0;
	//小日期减大日期为负数
	if (minDate == *this)
	{
		flag = -1;
	}
	while (minDate != maxDate)
	{
		++minDate;
		++day;
	}
	return day * flag;
}

// >>和<<需要重载成全局函数，因为成员函数的第一个参数默认是this，重载成成员函数会打破 cout<<d 的习惯
//流插入重载
ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
	return out;
}

//流提取重载
istream& operator>>(istream& in,Date& d)
{
	cin >> d._year >> d._month >> d._day;
	return in;
}

//赋值运算符重载
Date& Date::operator=(const Date& d)
{
	if (this != &d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	return *this;
}

const Date* Date::operator&()const
{
	return this;
}

Date* Date::operator&()
{
	return this;
}
相关推荐
萝卜兽编程7 分钟前
优先级队列
c++·算法
Bruce小鬼8 分钟前
QT文件基本操作
开发语言·qt
2202_7544215414 分钟前
生成MPSOC以及ZYNQ的启动文件BOOT.BIN的小软件
java·linux·开发语言
我只会发热21 分钟前
Java SE 与 Java EE：基础与进阶的探索之旅
java·开发语言·java-ee
懷淰メ30 分钟前
PyQt飞机大战游戏（附下载地址）
开发语言·python·qt·游戏·pyqt·游戏开发·pyqt5
hummhumm44 分钟前
第 22 章 - Go语言 测试与基准测试
java·大数据·开发语言·前端·python·golang·log4j
宁静@星空1 小时前
006-自定义枚举注解
java·开发语言
hummhumm1 小时前
第 28 章 - Go语言 Web 开发入门
java·开发语言·前端·python·sql·golang·前端框架
武子康1 小时前
Java-07 深入浅出 MyBatis - 一对多模型 SqlMapConfig 与 Mapper 详细讲解测试
java·开发语言·数据库·sql·mybatis·springboot
珹洺1 小时前
C语言数据结构——详细讲解 双链表
c语言·开发语言·网络·数据结构·c++·算法·leetcode
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07怎样让音频速度变慢？请跟随以下方法进行操作08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10【目标跟踪】相机运动补偿