AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【C++】日期类@类和对象（中）—— const成员函数

2022-07-29 92
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 类和对象

@TOC

0. 引

继C++入门、类和对象上篇中篇后，我们把这些学到的知识都用起来，来写一个日期类。这不禁让我想起了闷热又潮湿的夏季小学期java的第一个作业，写一个万年历，那时我写的真是一塌糊涂啊哈哈。下面我贴出头文件，各位自己写。所有要注意的小点我都写出来了，文章尽量呈现一套自然而然理所当然的思路。开始吧！

#include<iostream>
using namespace std;

class Date
{
public:
    //构造函数
    Date::Date(int year = 0, int month = 1, int day = 1);
    //析构函数、拷贝构造、赋值重载都不用写
    //Date(const Date& d)
    //{
    //    cout << "Date(const Date& d)" << endl;
    //}
    void Print();

    int getMonthDay(int year, int month);
    //运算符重载系列
    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);

    // d1 += 100;
    Date& operator+=(int day);
    // d1 + 100;
    Date operator+(int day);
    // d1 -= 100;
    Date& operator-=(int day);
    // d1 - 100;
    Date operator-(int day);
    
    // 前置++
    Date& operator++();
    // 后置++
    Date operator++(int);
    // 前置--
    Date& operator--();
    //后置 --
    Date operator--(int);

    // 日期 - 日期
    int operator-(const Date& d);
    // 今天是星期几？
    void PrintWeekday();
private:
    int _year;
    int _month;
    int _day;
};

1. 基本接口

1.1 默认成员函数

1.1.1 构造函数

通过对于构造函数、析构函数、拷贝构造这一系列函数特征的学习，我们知道对于日期类，我们并不需要写析构、拷贝构造一类，用默认的就行。只需要自己实现构造函数。

注：

  • [ ] 缺省参数不能在声明和定义中同时出现，一般写在声明中
Date::Date(int year, int month, int day )
{
    _year = year;
    _month = month;
    _day = day;

    if (year<0
        ||(month<0 || month >12)
        ||(day <0 || day >getMonthDay(year,month)))
    {
        cout << "非法日期:>";
        Print(); //在类里，可以直接访问类函数
    }
}

这就还需要考虑非法日期的输入：为了判断天数是否合理，我们引入了下一个接口，来获取某年某月的天数 ——

1.1.2 拷贝构造函数

可以不写。但后面我为了验证拷贝构造函数的调用，在里面瞎写了一句打印。

1.2 获取某年某月天数

这里采用了比较巧妙的用数组存储天数，第几月就对应着相应天数。

注：

  • [ ] 对于天数，不会修改，置为静态数组。
  • [ ] 对闰年的处理，先来判断month == 2
int Date::getMonthDay(int year, int month)
{
    //静态数组
    static int monthDayArray[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    int day = monthDayArray[month];
    //闰年：四年一闰、百年不闰、四百年再闰
    if (month == 2
        && ((year%4==0 && year%100!=0)||( year%400 == 0)))
    {
        day += 1;
    }
    return day;
}

2. 一系列运算符重载函数

2.1 += 、+、++

2.2.1 日期 += 天数 = ？

2022.1.21 + 100是几号？这个功能的实现，乍一想好像挺复杂，还要考虑闰年，不同月的天数。但顺着我们正常的计算思维，列写几个例子，其实很简单。:white_check_mark:它其实就是一个不断进位的过程，天满了往月进；月满了往年进、月归1。

<img src=" title="">

那就写个循环直至合法 ——

Date& Date::operator+=(int day)
{
    _day += day;
    while (_day > getMonthDay(_year, _month))
    {
        _day -= getMonthDay(_year, _month);
        _month++;

        if (_month == 13)
        {
            _year += 1;
            _month = 1;
        }
    }
    return *this;//d1没销毁，可以传引用返回
}
  • [ ] 注意，这里我们实现的是+=，而不是 +，在这里我们改变了d1，回想，我们之前多次强调过
    int i = 0;
    i + 100;

i的值并不会改变。那怎么实现运算符+的重载呢？我们就弄一个临时对象来 ——

2.2.2 日期 + 天数

  • [ ] 拷贝构造一个临时对象，以避免对d的改变
  • [ ] 可以巧妙复用+=接口
// d1 + 100; 不能改变d1
Date Date::operator+(int day)
{
    Date ret(*this);//拷贝构造一个
    ret += 100; // ret.operator+=(&ret, 100);
    return ret;
}

2.2.3 前置++、后置++

在写++的运算符重载函数时，发现这两个函数啊，函数名相同。为了区分前置++和后置++，我们增加一个参数占位，它们俩就构成了函数重载。

实现：前置++，与后置++，区别就在于返回值的不同。

  • [ ] 注意：究竟传引用返回（能不能?），还是传值返回 —— 不是背出来一开始就写上的。而是根据你实现的的不同逻辑，看你返回的对象，出了作用域被没被销毁，分析出来加上的，当然熟练了就直接写了。

:strawberry:前置++

// 先++后使用
Date& Date::operator++()
{
    *this += 1;
    return *this;
}

:strawberry:后置++

// 先使用后++
Date Date::operator++(int)
{
    Date ret(*this);
    *this += 1;
    return ret;
}

注：

  • [ ] 如何调用？

编译器会把它们转化为 ——

    Date d1(2022, 1, 22);
    ++d1; //d1.operator(&d1);
    d1++; //d1.operator(&d1, 1);

后置++，这个整数只起到占位作用，没有实在意义，所以传什么随意。

  • [ ] 对于整型，前置++后置++区别不大（不涉及使用返回值时），但是对于自定义类型，建议使用前置++。这是因为前置++，我们可以传引用返回；后置++，拷贝构造临时对象加上传值返回，要拷贝构造两次（调试/打印可测，我都测了哈），效率低下。

所以你看，前置++也保持了它原生的样子。

2.2 -=、-、--

有了2.1节“加”的一系列铺垫，关于“减”那是不在话下。

2.2.1 日期 -= 天数 = 日期

怎么减呢？写过“加”了，那思路就顺下来。（在我测试的时候，把几个易错点全测到了，或许女生真的适合去做测试？哈哈，值得表扬的是通过调试都改过来了，也侧面说明我踩雷踩得相当准，我都写在注意里了）

<img src=" title="">

注意：

  • [ ] 天数 <= 0都不合法
  • [ ] 注意我们借到的天数是上一个月的天数（这与“加”不同，“加”获取的是本月天数）。
  • [ ] 到达边界时，我们是先把月置12，再对天数处理（这与”加“也不同，这里是先处理月份，后处理天，光我说你可能晕了，自己想想者的逻辑很简单）。
Date& Date::operator-=(int day)
{
    while (_day <= 0)
    {
        _month--;
        if (_month == 0)
        {
            _year--;
            _month = 12;
        }
        _day += getMonthDay(_year, _month);

    }
    return *this;
}

在这里要考虑，万一我输入的day是负数？

我们需要把它单拎出来处理一下，-= day 等价于+= (-day)。同样的刚刚我们实现的+=运算符重载函数也需要同样处理，代码如下 ——

// +=
Date& 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)
        {
            _year += 1;
            _month = 1;
        }
    }
    return *this;//d1没销毁，可以传引用返回
}
//-=
Date& 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;
}

2.2.2 日期 - 天数

复用嗷！

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

2.2.3 前置--、后置--

注意事项同++

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

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

2.3 一堆比较 >、>=、<、<=、==、!=

事实上，在我们实现了>、==，就可以根据这些符号简单的关系，疯狂复用完成其他所有接口。

相似的逻辑，很自然的就能想到能不能复用。来！

// >
// d1>d2 => d1.operator(&d1, d2)
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);
}

3. 日期 - 日期

这乍一想是挺复杂，又可能是闰年，跨几个月也不定。其实可以暴力求解，找那个较小的日期，加加加到较大的日期。

这里我计算一个，从今天到小边冲实习生那天还有多少天吧！诶，有高考倒计时的感觉了。来！

// 日期 - 日期
// offerDay - today => offerDay.operator(&offerday, today);
int Date::operator-(const Date& d)
{
    // 假设
    Date min = d;//早
    Date max = *this;//晚
    int flag = 1;
    if (*this < d)
    {
        min = *this; //早
        max = d; // 晚
        flag = -1;
    }

    int count = 0;
    while (min < max)
    {
        min++;
        count++;
    }
    return count*flag;
}

<img src=" title="">

4. 星期几？

void Date::PrintWeekday()
{
    Date start(1900, 1, 1); //查询得星期一
    int count = *this - start;
    cout << "星期" << ((count % 7) + 1) << endl;
}

5. const成员

引入 ——

<img src=" title="">

于是C++增加了const成员函数，实际修饰this指针，保护this指向的内容不被修改，即不能对任何类成员进行修改。

class Date
{
public:
    void Display() const
    {
        cout << "year:" << _year << endl;
        cout << "month:" << _month << endl;
        cout << "day:" << _day << endl << endl;
    }

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

int main()
{
    Date d1;
    d1.Display(); //权限缩小

    const Date d2;
    d2.Display(); //权限不变
    return 0;
}

总结：成员函数加const是好的，建议能加上的都加上，这样普通对象和const对象都能调用。

但是如果要修改成员变量的成员函数就不可以加。比如日期类中的+=和++

6. 取地址及const取地址操作符重载

这两个运算符重载意义不大。

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况才需要重载，比如想让别人获取到指定的内容！

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

    const Date* operator&()const
    {
        return this;
    }
private:
    int _year; // 年
    int _month; // 月
    int _day; // 日
};

附录：

测试文件随写随测

Date.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include"Date.h"

int Date::getMonthDay(int year, int month)
{
    //静态数组
    static int monthDayArray[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    int day = monthDayArray[month];
    //闰年：四年一闰、百年不闰、四百年再闰
    if (month == 2
        && ((year%4==0 && year%100!=0)||( year%400 == 0)))
    {
        day += 1;
    }
    return day;
}

//缺省参数不能在声明和定义中同时出现
Date::Date(int year, int month, int day )
{
    _year = year;
    _month = month;
    _day = day;

    if (year<0
        ||(month<0 || month >12)
        ||(day <0 || day >getMonthDay(year,month)))
    {
        cout << "非法日期:>";
        Print(); //在类里，可以直接访问类函数
    }
}

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

Date& 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)
        {
            _year += 1;
            _month = 1;
        }
    }
    return *this;//d1没销毁，可以传引用返回
}

// d1 + 100; 不能改变d1
Date Date::operator+(int day)
{
    Date ret(*this);//拷贝构造一个
    ret += 100; // ret.operator+=(&ret, 100);
    return ret;
}

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

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



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

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

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

// 日期 - 日期
// offerDay - today => offerDay.operator(&offerday, today);
int Date::operator-(const Date& d)
{
    // 假设
    Date min = d;//早
    Date max = *this;//晚
    int flag = 1;
    if (*this < d)
    {
        min = *this; //早
        max = d; // 晚
        flag = -1;
    }

    int count = 0;
    while (min < max)
    {
        min++;
        count++;
    }
    return count*flag;
}

void Date::PrintWeekday()
{
    Date start(1900, 1, 1); //查询得星期一
    int count = *this - start;
    cout << "星期" << ((count % 7) + 1) << endl;
}

test.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include "Date.h"

void test1()
{
    Date d1(2002, 3, 7);
    d1.Print();

    Date d2(2022, 2, 29);
}

//测试+、+=、++
void test2()
{
    Date d1(2022, 1, 16);
    /*Date ret = d1 + 100;
    ret.Print();*/

    //Date d2(2022, 1, 16);
    //d2 += 100;
    //d2.Print();

    //++d1;
    d1++;
}

//测试这一堆运算符重载函数
void test3()
{
    
    Date d1(2002, 3, 7);
    Date d2(2002, 2, 19); //missing lmyy
    Date d3(2002, 3, 7);

    cout << (d1 == d3) << endl;
    cout << (d1 >= d2) << endl;
    cout << (d1 < d3) << endl;
    cout << (d1 <= d2) << endl;
    cout << (d1 != d3) << endl;

}

// 测试-,-=,--
void test4()
{
    Date d1(2022, 1, 10);
    Date d2(2022, 2, 19);

    Date ret2 = d2 - 60;
    ret2.Print();

    d1 -= 10;
    d1.Print();

    /*--d2;
    d2--;*/
}

//测试日期 - 日期，星期几
void test5()
{
    Date today(2022,1,23);
    Date offerDay(2022, 9, 1);
    cout << (offerDay - today) << endl;
    today.PrintWeekday();
}

int main()
{
    //test1();
    //test2();
    //test3();
    //test4();
    test5();
    return 0;
}
文章标签：
Java
C++
存储
编译器
关键词：
C++函数
C++ const
C++类
C++对象
C++成员
@浮光掠影
目录
相关文章
ephemerals__
|
2月前
|
存储 编译器 C语言
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色，它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作，帮助读者更好地理解和掌握`string`类的应用。
ephemerals__
63 2
ephemerals__
|
2月前
|
存储 编译器 C++
【c++】类和对象（下）（取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象）
本文介绍了C++中类和对象的高级特性，包括取地址运算符重载、构造函数的初始化列表、类型转换、static修饰成员、友元、内部类及匿名对象等内容。文章详细解释了每个概念的使用方法和注意事项，帮助读者深入了解C++面向对象编程的核心机制。
ephemerals__
113 5
ephemerals__
|
2月前
|
存储 编译器 C++
【c++】类和对象（中）（构造函数、析构函数、拷贝构造、赋值重载）
本文深入探讨了C++类的默认成员函数，包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化，析构函数用于对象销毁时的资源清理，拷贝构造函数用于对象的拷贝，赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项，并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
ephemerals__
115 4
ephemerals__
|
2月前
|
存储 编译器 Linux
【c++】类和对象（上）（类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针）
本文介绍了C++中的类和对象，包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用，以及如何使用访问限定符控制成员的访问权限。此外，还讨论了对象的内存分配规则和this指针的使用场景，帮助读者深入理解面向对象编程的核心概念。
ephemerals__
153 4
白子寰
|
3月前
|
存储 编译器 对象存储
【C++打怪之路Lv5】-- 类和对象（下）
【C++打怪之路Lv5】-- 类和对象（下）
白子寰
35 4
白子寰
|
3月前
|
编译器 C语言 C++
【C++打怪之路Lv4】-- 类和对象（中）
【C++打怪之路Lv4】-- 类和对象（中）
白子寰
34 4
白子寰
|
3月前
|
存储 安全 C++
【C++打怪之路Lv8】-- string类
【C++打怪之路Lv8】-- string类
白子寰
33 1
努力学习的小廉
|
3月前
|
存储 编译器 C++
【C++类和对象（下）】——我与C++的不解之缘（五）
【C++类和对象（下）】——我与C++的不解之缘（五）
努力学习的小廉
28 1
努力学习的小廉
|
3月前
|
编译器 C++
【C++类和对象（中）】—— 我与C++的不解之缘（四）
【C++类和对象（中）】—— 我与C++的不解之缘（四）
努力学习的小廉
28 1
努力学习的小廉
|
3月前
|
存储 编译器 C语言
【C++类和对象（上）】—— 我与C++的不解之缘（三）
【C++类和对象（上）】—— 我与C++的不解之缘（三）
努力学习的小廉
25 1