C++日期类的实现

最新推荐文章于 2023-09-07 17:13:44 发布

研冰坚

最新推荐文章于 2023-09-07 17:13:44 发布

阅读量772

点赞数

文章标签： c++

本文链接：https://blog.csdn.net/weixin_46323638/article/details/124296905

版权

本文详细介绍了C++类的成员函数，包括构造函数、析构函数、拷贝构造函数、运算符重载等核心概念。特别是构造函数用于初始化对象，析构函数在对象销毁时释放资源，拷贝构造函数用于复制对象，而运算符重载则允许自定义类支持常见的数学和逻辑运算。此外，还展示了如何实现日期类中的一些常见运算，如比较、加减、赋值等操作。

摘要由CSDN通过智能技术生成

类的默认成员函数

如果一个类中什么都没有简称空类，实际上会自动生成六个默认的成员函数。

在这里插入图片描述

构造函数

构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，保证每个数据成员都有一个合适的初始值，并且在对象的生命周期内之调用一次。

需要注意构造对象的主要任务并不是构造而是初始化对象。

特性

函数名与类名相同。

class Date{
	Date(){}
};

无返回值。
对象实例化时编译器自动调用相应的构造函数。
构造函数可以重载。

class Date{
	Date(){}
	Date(int year, int month, int day){}
};

C++会在用户未编写构造函数的情况下自动构建一个无参的默认构造函数。
默认构造函数只能有一个。

date类的构造函数：

class Date{
Date(int year = 1900, int month = 1, int day = 1){
		if (year <0 || month<0 || month>13 || day<0 || day>GetMonthDay(year, month)){
			cout << "日期错误!" << endl;
		}
		_year = year;
		_month = month;
		_day = day;
	}
}

析构函数

对象在销毁时会自动调用析构函数，完成一些资源清理工作。

特性

析构函数名是在类名前加~
~Date();
无参数无返回值。
一个类只有一个析构函数。
对象生命周期结束时，编译系统会自动调用析构函数。

拷贝构造函数

只有单个形参，是对本类型对象的引用（一般用const修饰），再用已存在的类类型对象创建新对象时由编译器自动调用。

特性

时构造函数的一个重载形式。
拷贝构造函数的参数只能有一个且必须使用引用传参，使用传值的方式会引起无穷递归调用。

// 全缺省的构造函数
	Date(int year = 1900, int month = 1, int day = 1){
		if (year <0 || month<0 || month>13 || day<0 || day>GetMonthDay(year, month)){
			cout << "日期错误!" << endl;
		}
		_year = year;
		_month = month;
		_day = day;
	}
	
	
	
	// 拷贝构造函数
	// d2(d1)
	Date(const Date& d){
		this->_year = d._year;
		_month = d._month;
		_day = d._day;
	}

若无显式定义则系统会生成默认的拷贝构造函数。

函数运算符重载

运算符重载

函数运算符重载是具有特殊函数名的函数。也具有其返回值类型、函数名以及参数列表。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型operator操作符。

注意：

不能通过连接其他符号来创造新的操作符。
重载操作符必须有一个类类型或者枚举类型的操作数。
用于内置类型的操作符其含义不能改变。
作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的操作符有一个默认的形参this，限定为第一个形参。
.、：：、sizeof、？：、.* 这五个操作符不能重载。

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



	// >=运算符重载
	inline bool operator >= (const Date& d){
		return *this > d || *this == d;
	}



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



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



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

赋值运算符重载

注意：

参数类型
返回值
检测是否自己给自己复制
返回*this

	// 赋值运算符重载

	// d2 = d3 -> d2.operator=(&d2, d3)
	Date& operator=(const Date& d){
		if (this != &d){
			this->_year = d._year;
			this->_month = d._month;
			this->_day = d._day;
		}
		return *this;
	}

	// 析构函数
	~Date();

	void print(){
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	// 日期+=天数

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

	// 日期+天数
	Date operator+(int day){
		Date ret(*this);
		ret += day;
		return ret;
	}
	 
	// 日期-天数
	Date operator-(int day){
		Date ret(*this);
		ret -= day;
		return ret;
	}

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



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


	// 后置++
	Date operator++(int){
		Date ret(*this);
		*this += 1;
		return ret;
	}



	// 后置--
	Date operator--(int){
		Date ret(*this);
		*this -= 1;
		return ret;
	}



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

const修饰类的成员函数

实际用const修饰的成员函数隐含*this指针，表示该成员函数中不能对类的任何成员进行修改。

在这里插入图片描述

Date类的具体实现：

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<stdlib.h>
#include <iostream>

using namespace std;

class Date
{
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 += day;
		}
		return day;
	}
	// 全缺省的构造函数
	Date(int year = 1900, int month = 1, int day = 1){
		if (year <0 || month<0 || month>13 || day<0 || day>GetMonthDay(year, month)){
			cout << "日期错误!" << endl;
		}
		_year = year;
		_month = month;
		_day = day;
	}
	
	
	
	// 拷贝构造函数
	// d2(d1)
	Date(const Date& d){
		this->_year = d._year;
		_month = d._month;
		_day = d._day;
	}


	// 赋值运算符重载

	// d2 = d3 -> d2.operator=(&d2, d3)
	Date& operator=(const Date& d){
		if (this != &d){
			this->_year = d._year;
			this->_month = d._month;
			this->_day = d._day;
		}
		return *this;
	}

	// 析构函数
	~Date();

	void print(){
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	// 日期+=天数

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

	// 日期+天数
	Date operator+(int day){
		Date ret(*this);
		ret += day;
		return ret;
	}
	 
	// 日期-天数
	Date operator-(int day){
		Date ret(*this);
		ret -= day;
		return ret;
	}

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



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


	// 后置++
	Date operator++(int){
		Date ret(*this);
		*this += 1;
		return ret;
	}



	// 后置--
	Date operator--(int){
		Date ret(*this);
		*this -= 1;
		return ret;
	}



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

	// >运算符重载

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



	// >=运算符重载
	inline bool operator >= (const Date& d){
		return *this > d || *this == d;
	}



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



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



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


	// 日期-日期 返回天数
	int operator-(const Date& d){
		int flag = 0;
		Date max = *this;
		Date min = d;
		if (*this < d){
			max = d;
			min = *this;
			flag = -1;
		}
		int day = 0;
		while (min < max){
			++(min);
			++day;
		}
		return day*flag;
	}

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