类和对象进阶------构建日期类-Toy模板网

这篇具有很好参考价值的文章主要介绍了类和对象进阶------构建日期类。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、日期类的构造

二、日期类的比较运算符重载

三、日期类的加减运算符重载

四、日期相减

五、const成员

六、日期类重载流输入输出

一、日期类的构造

首先，日期类不能没有年月日，因此需要年月日参数，我们int一下这三个参数，我们不希望外界直接访问这三个参数，因此设置为private，同时我们需要自己写一个拷贝构造来对参数进行初始化。这里使用了全缺省,同时为了更加贴合实战项目的要求，我们将声明写到头文件Date.h里，将定义写到Date.cpp里，来进行声明和定义分离。

同时为了保证我们传入的参数是合法的，我们在拷贝构造函数里可以添加判断，先写出一个 GetMonthDay 类函数来获取这一年的这一月有多少天

Date.h的声明

class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1);
    int GetMonthDay(int year,int month);
private:
	int _year;
	int _month;
	int _day;
};

我们在Date.cpp写了定义。构造函数赋值并判断是否合法 GetMonthDay 能返回这一年的这个月有几天

Date::Date(int year, int month, int day)
{
	_year = year;
	_month = month;
	_day = day;
    if (month < 1 || month>12 || day<1 || day>GetMonthDay(year, month))
    {
	    cout << "非法日期" << endl;
    }
}

int Date::GetMonthDay(int year, int month)
{
	static int MonthDay[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	if (month == 2 && (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)))
	{
		return 29;
	}
	return MonthDay[month];
}

注意：缺省参数一定要写在声明的地方，定义的地方不能写缺省参数。

二、日期类的比较运算符重载

我们想要一个能简便的对比两个日期类对象的大小，也就是两个日期比较大小，由于是自定义类型不能直接比较，因此我们要进行函数重载，在Date.h文件类里面添加上如下定义

bool operator<(const Date& d);

同时在Date.cpp添加上函数实现，注意一定要在函数名前加上 Date:: 来表示是那个作用域下的，代码部分就是简单的作比较，先比较年，再比较月，最后比较天是最符合逻辑的。

bool Date::operator<(const Date& d)
{
	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;
	}
}

到目前我们已经重载了 < 符号，还有其他的判断符号需要重载，都很简单，我就直接代码了

声明：

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

定义：

bool Date::operator<(const Date& d)
{
	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;
	}
}
bool Date::operator==(const Date& d)
{
	return _year == d._year && _month == d._month && _day == d._day;
}
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);
}
bool Date::operator!=(const Date& d)
{
	return !(*this == d);
}

我们写个日期类打印函数测试一下

Date.h 里面声明

void Print();

Date.cpp里面定义

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

已经可以完成Date类对象的比较操作了

类和对象进阶------构建日期类,c++

三、日期类的加减运算符重载

我们还想做到运算这个日期加上天数是什么日期。

例如今天是2023年10月10号，我想要知道300天后是几几年多少月多少号，就可以重载加法运算符来帮助我们计算。

首先要直接将要加的天数先加到当前类对象的_day，算出到了这个月的多少天，在判断这个天数有没有越阶，如果天数不符合，就将天数减去这个月的天数，同时月份++，如果月份也溢出了，到了13月，就将月份置为1，年再加加。注意返回值为 *this 因为是+=，返回的就是类对象本身，同时由于函数结束后， *this 依然存在，因此可以穿&（引用返回）。

同时，day有可能为负数，那就相当于减day天，因此我们还要加个判断 day大于等于0走上面的代码，小于0可以复用上－=。我们只需把－=完善一下即可

if (day >= 0)
{
	this->_day += day;
	while (_day > GetMonthDay(_year,_month))
	{
		_day -= GetMonthDay(_year, _month);
		_month++;
		if (_month == 13)
		{
			_month = 1;
			_year++;
		}
	}
}
else
{
	*this -= (-day);
}
return *this;

-=和+=类似的，唯一的区别是要区分出去找哪个月借，这里是先将_month-- 之后，在去让_day+=月的天数，因为你当前day是负数后，你需要找前一个月去借天数，直到大于0才对。

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

日期类的+=和-=我们已经处理好了，还有+和-没有重载，我们也可以直接服用，拷贝构造一个tmp类对象，复用+=和-=，再return这个临时对象即可。

注意：返回值不能加&（引用），因为tmp的生命周期是在这个函数内部，出了函数就销毁，因此不能加&

Date Date::operator+(int day)
{
	Date tmp(*this);
	tmp += day;
	return tmp;
}
Date Date::operator-(int day)
{
	Date tmp(*this);
	tmp -= day;
	return tmp;
}

Date.h文件填上就好，后续就不多赘述了，在最后面也会附上代码。

运算符重载还有++和--

这里会产生一个问题，按照之前的思路来重载++运算符，你无法区分这个++是前置还是后置，C++祖师爷添加了一个参数来区分前置还是后置，没有参数的是前置++，有int参数的是后置++，这个int可以不给值，他只是一个占位符，来表示后置++。

同理 -- 也是一样的。

这里我们也可以复用之前的+=来帮我们处理，前置++返回的是++后的值，直接返回 *this，因此可以用&返回。

后置++返回的是++前的值，因此需要拷贝构造一份tmp，返回tmp即可，tmp出了函数就销毁了不能用&返回。

注意：对于类对象来说，前置++没有产生拷贝构造，而后置++产生了拷贝构造，因此如果只是单条语句用前置++效率会更高

Date& Date::operator++()
{
	*this += 1;
	return *this;
}
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;
}

四、日期相减

日期减日期，可以找到这两个日期之前相差多少天，是日期加天数的变形。

这里采用了一个很简单的方法，就是先找到两个日期小的那个，再将小的日期一步一步加到大的日期，加了多少次，就有多少天。

flag既可以判断谁大，又可以作为符号，因为是相减，有可能是小的日期减去大的日期，这样结果是一个负数。

int Date::operator-(const Date& d)
{
	int flag = 1;
	Date max = *this;
	Date min = d;
	if (max < min)
	{
		flag = -1;
		max = d;
		min = *this;
	}
	int n = 0;
	while (max != min)
	{
		++min;
		++n;
	}
	return n * flag;
}

再运行一下检查

类和对象进阶------构建日期类,c++

跟网上的日期计算器作对比，没问题~。

五、const成员

对于一个参数有类对象的函数，如果我们不需要在函数里面进行修改操作，那么我们可以给类对象添加上const修饰，使其无法修改，这样操作会更加安全，但是这有会引发一些问题，例如类对象调用不了类的成员函数

类和对象进阶------构建日期类,c++

为什么会发生上图这种情况？

因为这里的d是一个const修饰的类对象，而 Print() 函数是一个普通的成员函数，没有被const修饰，这就会引发权限放大的问题，由const转为非const，是不能够实现的，即使我们在 Print() 函数例没有进行任何修改。

那么似乎我们只需要给类对象的成员函数加上 const 修饰一下即可，但是我们又发现函数实现并没有传任何参数，只有一个默认传的this指针，而this指针我们既不需要传给函数，又不能够穿给函数，这似乎是一个悖论，那么我们该如何让这个指针加上const呢？

类和对象进阶------构建日期类,c++

C++祖师爷想了一个很好的方法，在 Print() 后面添加上const来代表传递的this指针为const，如下

类和对象进阶------构建日期类,c++

这个时候我们回过头来看，就会发现代码不再报错了，也可以正常调用了。

类和对象进阶------构建日期类,c++

再验证一下普通类对象能不嫩调用 const函数，可以发现也是没问题的。

类和对象进阶------构建日期类,c++

同理，如果函数是只读函数（内部不涉及修改成员的都是只读函数），就可以加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);
	Date& operator-=(int day);
	Date operator+(int day) const;
	Date operator-(int day) const;
	Date& operator++();
	Date operator++(int);
	Date& operator--();
	Date operator--(int);
	//日期相减
	int operator-(const Date& d) const;
	void Print() const;
	int GetMonthDay(int year,int month) const;

const对象不可以调用非const成员函数（权限的扩大）

非const对象可以调用const成员函数（权限的缩小）

权限可以平移，可以缩小，但是不能放大

对于类对象来说，再后面加了const函数和不加const函数是构成重载的，因为他们默认给到的this指针类型不同。因此有时候会需要我们写两个函数，一个是const的一个是非const的，如下

类和对象进阶------构建日期类,c++

不过这里我们可以不需要重载，没涉及到那么复杂的情景，加了const就足够了。

六、日期类重载流输入输出

我们想让日期类对象和普通的内置类型一样可以用 cin和 cout 来处理，就得重载>>和 << 这两个操作符，如果我们将重载 >> 函数放在类的里面是不可行的，如下

ostream& Date::operator<<(ostream& out)
{
	out << _year << "/" << _month << "/" << _day << endl;
	return out;
}

类和对象进阶------构建日期类,c++

我们明明重载了，为啥会报链接错误呢？因为this指针默认在第一个参数。而out是第二个参数，这和我们的代码 cout << d1; 不匹配，要交换位置才能运行，因此我们不能够这样写。

类和对象进阶------构建日期类,c++

这里我们采取的方法是写出全局函数，用友元的形式去访问类的私有变量。将类对象放在第二个参数的位置就能符合我们的要求。同时也重载一下 >> 流输入，只需要关注流输入的类对象d不要加const修饰就行，因为我们要修改这个对象，因此不能加const。

friend ostream& operator<<(ostream& out, const Date& d);
friend istream& operator>>(istream& in, Date& d);

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

istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

如此一来，代码就大功告成了

类和对象进阶------构建日期类,c++

附上全部代码

Date.h

#pragma once
#include<iostream>
using namespace std;
class Date
{
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);
public:
	Date(int year = 1, int month = 1, int day = 1);
	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);
	Date& operator-=(int day);
	Date operator+(int day) const;
	Date operator-(int day) const;
	Date& operator++();
	Date operator++(int);
	Date& operator--();
	Date operator--(int);
	int operator-(const Date& d) const;

	void Print() const;
	int GetMonthDay(int year,int month) const;
private:
	int _year;
	int _month;
	int _day;
};

ostream& operator<<(ostream& out, const Date& d);
istream& operator>>(istream& in, Date& d);

Date.cpp

#include"Date.h"
Date::Date(int year, int month, int day)
{
	_year = year;
	_month = month;
	_day = day;
	if (month < 1 || month>12 || day<1 || day>GetMonthDay(year, month))
	{
		cout << "非法日期" << endl;
	}
}
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;
	}
}
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 || *this == d;
}

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);
}
Date& Date::operator+=(int day)
{
	if (day >= 0)
	{
		this->_day += day;
		while (_day > GetMonthDay(_year,_month))
		{
			_day -= GetMonthDay(_year, _month);
			_month++;
			if (_month == 13)
			{
				_month = 1;
				_year++;
			}
		}
	}
	else
	{
		*this -= (-day);
	}
	return *this;
}
Date& Date::operator-=(int day)
{
	if (day >= 0)
	{
		this->_day -= day;
		while (_day <= 0)
		{
			_month--;
			_day += GetMonthDay(_year, _month);
			if (_month == 0)
			{
				_month = 12;
				_year--;
			}
		}
	}
	else
	{
		*this += (-day);
	}
	return *this;
}
Date Date::operator+(int day) const
{
	Date tmp(*this);
	/*if (day >= 0)
	{
		tmp._day += day;
		while (tmp._day > GetMonthDay(tmp._year,tmp._month))
		{
			tmp._day -= GetMonth(tmp._month);
			tmp._month++;
			if (tmp._month == 13)
			{
				tmp._month = 1;
				tmp._year++;
			}
		}
	}
	else
	{
		*this - (-day);
	}*/
	tmp += day;
	return tmp;
}
Date Date::operator-(int day) const
{
	Date tmp(*this);
	/*if (day >= 0)
	{
		tmp._day -= day;
		while (tmp._day < 0)
		{
			tmp._day += GetMonthDay(tmp._year,tmp._month);
			tmp._month--;
			if (tmp._month == 0)
			{
				tmp._month = 12;
				tmp._year--;
			}
		}
	}
	else
	{
		*this + (-day);
	}*/
	tmp -= day;
	return tmp;
}


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

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) const
{
	int flag = 1;
	Date max = *this;
	Date min = d;
	if (max < min)
	{
		flag = -1;
		max = d;
		min = *this;
	}
	int n = 0;
	while (max != min)
	{
		++min;
		++n;
	}
	return n * flag;
}

void Date::Print() const
{
	cout << _year << "/" << _month << "/" << _day << endl;
}
int Date::GetMonthDay(int year, int month) const
{
	static int MonthDay[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	if (month == 2 && (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)))
	{
		return 29;
	}
	return MonthDay[month];
}

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

istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

Test.cpp文章来源地址https://www.toymoban.com/news/detail-726529.html

#include"Date.h"
int main()
{
	Date d1(2023, 10, 10);
	Date d2(2000, 2, 16);
	cout << d1 << d2;
	cin >> d1 >> d2;
	cout << d1 << d2;
}

到了这里，关于类和对象进阶------构建日期类的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

类和对象进阶------构建日期类

一、日期类的构造

二、日期类的比较运算符重载

三、日期类的加减运算符重载

四、日期相减

五、const成员

六、日期类重载流输入输出

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

支付宝扫一扫领取红包，优惠每天领

二维码1

二维码2