日期类的实现

最新推荐文章于 2024-08-12 16:55:46 发布
最新推荐文章于 2024-08-12 16:55:46 发布
阅读量377 收藏
点赞数 1
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ahui_is_so_cool/article/details/127037198
版权

目录

定义日期类

属性

方法实现

获取某年某月的天数

构造函数

拷贝构造函数

赋值运算符的重载

析构函数

日期+=天数

日期+天数

日期-天数

日期-=天数

前置++

后置++

后置--

前置--

>运算符重载

==运算符重载

>=运算符重载

<运算符重载

<运算符重载

!=运算符重载

日期-日期 返回天数

整体代码展示

日期是日常生活中经常用到的东西，下面我将给大家展示一下如何用C++封装一个日期类，并且重载其各种操作

定义日期类

属性

日期有3个属性 年 月 日，还以若干个方法

class Date
{
public:
// 获取某年某月的天数
int GetMonthDay(int year, int month);

  // 全缺省的构造函数
Date(int year = 1900, int month = 1, int day = 1);

  // 拷贝构造函

// d2(d1)
Date(const Date& d);
 

  // 赋值运算符重载
// d2 = d3 -> d2.operator=(&d2, d3)
Date& operator=const Date& d);

  // 析构函数
~Date();

  // 日期+=天

Date& operator+=(int day);

  // 日期+天数
Date operator+(int day);

  // 日期-天数
Date operator-(int day);

   // 日期-=天数
Date& operator-=(int day);

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

  // 后置++
Date operator++(int);

  // 后置--
Date operator--(int);

  // 前置--
Date& operator--();

  // >运算符重载
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);

  // 日期-日期 返回天数
int operator-(const Date& d);
private:
int _year;
int _month;
int _day;
};

方法实现

获取某年某月的天数

int Date::GetMonthDay(int year,int month)
{
  if(month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12)
  {
    return 31;
  }
  if(month == 4 || month == 6 || month == 9 || month == 11)
  {
    return 30;
  }
  if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
  {
    return 29;
  }
  return 28;
}

构造函数

Date::Date(int year, int month, int day)
{
  _year = year;
  _month = month;
  _day = day;
}

拷贝构造函数

Date::Date(const Date& d)
{
  _year = d._year;
  _month = d._month;
  _day = d._day;
}

赋值运算符的重载

Date& Date::operator=(const Date& d)
{
  _year = d._year;
  _month = d._month;
  _day = d._day;
  return *this;
}

析构函数

Date::~Date()
{
  _year = 1900;
  _month = 1;
  _day = 1;
}

日期+=天数

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

日期+天数

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

日期-天数

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

日期-=天数

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

前置++

Date& Date::operator++()
{
  _day++;
  if(_day > GetMonthDay(_year, _month))
  {
    _day -= GetMonthDay(_year,_month);
    _month++;
    if(_month == 13)
    {
      _month = 1;
      _year++;
    }
  }
  return *this;
}

后置++


Date Date::operator++(int)
{
  Date ret(*this);
  operator++();
  return ret;
}

后置--

Date Date::operator--(int)
{
  Date ret(*this);
  operator--();
  return ret;
}

前置--

Date& Date::operator--()
{
  _day--;
  if(_day == 0)
  {
    _month--;
    if(_month == 0)
    {
      _month = 12;
      _year--;
    }
    _day = GetMonthDay(_year,_month);
  }
  return *this;
}

>运算符重载


bool Date::operator>(const Date& d)
{
  return *this - d > 0;
}

==运算符重载

bool Date::operator==(const Date& d)
{
  return *this - d == 0;
}

>=运算符重载

bool Date::operator>=(const Date& d)
{
  return *this - d >= 0;
}

<运算符重载

bool Date::operator<(const Date& d)
{
  return *this - d < 0;
}

<运算符重载

bool Date::operator<=(const Date& d)
{
  return *this - d <= 0;
}

!=运算符重载

bool Date::operator!=(const Date& d)

{

  return *this - d != 0;

}

日期-日期 返回天数

int Date::operator-(const Date& d)
{
  int day = 0;
  //获取当前月份的相差的日期值
  int day1 = _day;
  int day2 = d._day;
  int m1 = _month - 1;
  int m2 = d._month - 1;
  while(m1 > 0)
  {
    day1 += GetMonthDay(_year, m1);
    m1--;
  }
  while(m2 > 0)
  {
    day2 += GetMonthDay(d._year, m2);
    m2--;
  }
  day = day1 - day2; //当前月份与日期之间相隔的日期数
  //判断年份之间相差的日期数
  int y1 = _year;
  int y2 = d._year;
  while(y2 < y1)
  {
    day += 365;
    if(y2 % 4 == 0 && y2 % 100 != 0 || y2 % 400 == 0)
    {
      day++;
    }
    y2++;
  }
  while(y1 < y2)
  {
    day -= 365;
    if(y1 % 4 == 0 && y1 % 100 != 0 || y1 % 400 == 0)
    {
      day--;
    }
  }
  return day;
}

整体代码展示

#include <iostream>
using namespace std;

class Date
{
public:
    //获取某年某月的天数
    int GetMonthDay(int year, int month);
    //全缺省构造函数
    Date(int year = 1900, int month = 1, int day = 1);
    //拷贝构造函数
    Date(const Date &d);

    //赋值运算符重载
    Date &operator=(const Date &d);

    //析构函数
    ~Date();

    //日期+=天数
    Date &operator+=(int day);

    //日期+天数
    Date operator+(int day);

    //日期-天数
    Date operator-(int day);

    // 日期-=天数

    Date &operator-=(int day);

    // 前置++

    Date &operator++();

    // 后置++

    Date operator++(int);

    // 后置--

    Date operator--(int);

    // 前置--

    Date &operator--();

    // >运算符重载

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

    // 日期-日期 返回天数

    int operator-(const Date &d);

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

Date::Date(int year, int month, int day)
{
    _year = year;
    _month = month;
    _day = day;
}

int Date::GetMonthDay(int year,int month)
{
    if(month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12)
    {
        return 31;
    }
    if(month == 4 || month == 6 || month == 9 || month == 11)
    {
        return 30;
    }
    if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
    {
        return 29;
    }
    return 28;
}

Date::Date(const Date& d)
{
    _year = d._year;
    _month = d._month;
    _day = d._day;
}

Date& Date::operator=(const Date& d)
{
    _year = d._year;
    _month = d._month;
    _day = d._day;
    return *this;
}

Date::~Date()
{
    _year = 1900;
    _month = 1;
    _day = 1;
}

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

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

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

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

Date& Date::operator++()
{
    _day++;
    if(_day > GetMonthDay(_year, _month))
    {
        _day -= GetMonthDay(_year,_month);
        _month++;
        if(_month == 13)
        {
            _month = 1;
            _year++;
        }
    }
    return *this;
}

Date Date::operator++(int)
{
    Date ret(*this);
    operator++();
    return ret;
}

Date& Date::operator--()
{
    _day--;
    if(_day == 0)
    {
        _month--;
        if(_month == 0)
        {
            _month = 12;
            _year--;
        }
        _day = GetMonthDay(_year,_month);
    }
    return *this;
}

Date Date::operator--(int)
{
    Date ret(*this);
    operator--();
    return ret;
}

bool Date::operator>(const Date& d)
{
    return *this - d > 0;
}

bool Date::operator==(const Date& d)
{
    return *this - d == 0;
}

bool Date::operator>=(const Date& d)
{
    return *this - d >= 0;
}

bool Date::operator<(const Date& d)
{
    return *this - d < 0;
}

bool Date::operator<=(const Date& d)
{
    return *this - d <= 0;
}

bool Date::operator!=(const Date& d)
{
    return *this - d != 0;
}


int Date::operator-(const Date& d)
{
    int day = 0;
    //获取当前月份的相差的日期值
    int day1 = _day;
    int day2 = d._day;
    int m1 = _month - 1;
    int m2 = d._month - 1;
    while(m1 > 0)
    {
        day1 += GetMonthDay(_year, m1);
        m1--;
    }
    while(m2 > 0)
    {
        day2 += GetMonthDay(d._year, m2);
        m2--;
    }
    day = day1 - day2;  //当前月份与日期之间相隔的日期数
    //判断年份之间相差的日期数
    int y1 = _year;
    int y2 = d._year;
    while(y2 < y1)
    {
        day += 365;
        if(y2 % 4 == 0 && y2 % 100 != 0 || y2 % 400 == 0)
        {
            day++;
        }
        y2++;
    } 
    while(y1 < y2)
    {
        day -= 365;
        if(y1 % 4 == 0 && y1 % 100 != 0 || y1 % 400 == 0)
        {
            day--;
        }
    }
    return day;
}

伞兵一号ahui
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python实现简单日期工具类
09-19
这里我们讨论的是一个简单的日期工具类的实现，这个类提供了一系列方法来处理日期和时间相关的操作。以下是对这些方法的详细解释： 1. `curMilis()` 和 `curSeconds()`：这两个函数分别返回当前时间的毫秒数和秒数...
【C++】日期类
knous
05-19 2168
日期类的实现
C++中使用构造函数，析构函数，拷贝构造函数，运算符重载实现日期类
mcboke的博客
03-07 697
一、利用多文件实现日期类 当我们了解了类中默认的6个成员函数，我们就可以利用这些函数实现一个简单的类完成日期之间的计算。比如，计算两个不同时间之间隔了多少天，n天之后是几年几月几号，等等 首先创建一个头文件Date,h，包含头文件，命名空间，函数声明，和定义类。 #pragma once #include<iostream> using namespace std; class Date { public: //获得每个月天数的函数 int GetMonthDay(int year
C++日期类的实现
m0_51961114的博客
03-19 224
C++日期类的实现 要实现一个类的构建，首先需要对构造、析构、拷贝构造等函数的含义进行理解。 构造函数 是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。其特征如下： （1） 函数名与类名相同。 （2） 无返回值。 （3） 对象实例化时编译器自动调用对应的构造函数。 （4） 构造函数可以重载。 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。 析构函
【C++修炼秘籍】日期类的实现
m0_62824408的博客
10-15 643
类和对象的知识复习，主要实现了日期的各种功能读取，打印，计算日期加减天数后的日期，日期之间间隔的天数，日期之间的大小比较；实现了构造析构，拷贝构造，赋值运算符重载等等，运算符重载，加深映像
关于日期类实现的所有代码
11-19
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
C++实现日期类（Date）
08-26
"C++实现日期类（Date）" 本资源主要为大家详细介绍了C++实现日期类的相关代码，具有一定的参考价值。本文将详细讲解日期类的实现细节，包括构造函数、拷贝函数、析构函数、判断闰年、判断合法日期、判断当前月份...
一个简单的日期类的实现
03-30
简单的日期类，方便理解之前C++笔记中的一些默认函数和操作符重载，具体有获取天数，两个日期相减，实现了日期加天数，日期减天数，判断输入的日期是否合法，判断输入的日期是星期几，还有前置后置++(--)的重载等等...
Java实现的日期处理类完整实例
08-29
Java实现的日期处理类完整实例 Java实现的日期处理类是Java编程语言中对日期的处理和操作的集合，包括日期的获取、运算、转换等相关操作技巧。本文将详细介绍Java实现的日期处理类，结合完整实例形式分析了Java针对...
类和对象-日期类的实现
Windows869的博客
10-25 196
#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 (mo
类和对象（日期类）（构造函数、拷贝构造、析构、赋值操作符重载、this指针）
sophia__yu的博客
06-08 1094
首先，了解三种访问限定符： 1. public成员可从类外部直接访问，private/protected成员不能从类外部直接访问。 2. 每个限定符在类体中可使用多次，它的作用域是从该限定符出现开始到下一个限定符之前或类体结束前。 3. 类体中如果没有定义限定符，则默认为私有的。 4. 类的访问限定符体现了面向对象的封装性。 类实例化对象： 成员函数的声明和定义 1.类内定义...
C++：默认函数练习——日期类项目的实现
h2608011009的博客
06-14 499
文章目录一：前言二：布局三：实现1、默认成员函数实现（1）全缺省构造函数（2）拷贝构造函数（3）析构函数赋值运算符重载（1）日期 += 天数（2）日期 += 天数（3）日期 + 天数（4）日期 –= 天数（5）日期–天数（6）前置++和后置++（7）前置––和后置––2、比较运算符重载3、日期相减 一：前言 C++类和对象里面的默认成员函数，如构造函数，拷贝构造赋值重载这些问题虽然说是不难，但是想要写出一个标准的类还是具有一定挑战性的。而编写日期类是一个很好的练手项目 此次的博客，为了更好的练习类与对象，完
类和对象_2(构造函数，析构函数，拷贝构造)
Nemo
11-24 323
目录   类的默认成员函数 构造函数 析构函数 拷贝构造函数 类的默认成员函数            一个类中若没有成员则称为空类。            任何一个类都会生成6个默认成员函数：                                                                          1. 构造函数         // 初始...
C++笔记5•内存管理•
最新发布
qq_64446190的博客
08-12 699
内存管理
C语言一维数组(含数组二分查找)
hdxbufcbjuhg的博客
08-09 1190
在⼀个升序的数组中查找指定的数字n，很容易想到的⽅法就是遍历数组，但是这种⽅法效率⽐较低。比如我们之前写的猜数字游戏，会生成一个随机数来让玩家猜，范围是1~100，那玩家会从1开始一个一个猜吗，不会吧，那样就太慢了，我们一般会从整体的一半开始猜，比如猜50，告诉你大了还是小了，这样只需要一步就可以排除庞大数字中的一半，比如假设猜1 ~ 10000，猜5000后就可以知道猜大了还是小了，直接排除了5000个数字，效率很快，这就是⼆分查找，也叫折半查找。
C语言断言进阶篇：全面总结与实战技巧
极客代码
08-10 435
断言是一种用于验证程序中某个条件是否为真的语句。如果条件为假，程序会触发一个错误，通常会导致程序终止。断言主要用于开发和测试阶段，以帮助开发者发现和修正错误。在某些情况下，默认的assert宏可能无法满足我们的需求。if (!abort();= NULL);在这个自定义断言宏中，我们输出了更多的错误信息，包括失败的断言表达式、函数名、文件名和行号，方便我们定位错误。本文系统且全面地总结了C语言中的断言机制，包括断言的定义、作用、实现以及在实战中的运用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值