C++【面试题】:类实现万年历(日期计算器),(含构造函数、拷贝构造、运算符重载、析构函数)

原创 2016年05月30日 17:16:26
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<stdlib.h>
using namespace std;

class Date
{
public:
    Date(int year=0, int month=0, int day=0)
    :_year(year)
    , _month(month)
    , _day(day)
    {
        cout << "构造函数" << endl;
    }

    Date( const Date& d)
    {
        cout << "拷贝构造函数" << endl;
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }

    /*Date& operater = (const Date& d)
    {
        cout << "运算符重载" <<endl;

    }*/
    bool operator == (const Date&d)
    {
        return this->_year == d._year
            && this->_month == d._month
            &&this->_day = d._month;
    }

     //大于
    bool operator > (const Date& d)
    {
        if (this->_year > d._year)
        {
            return true;
        }
        else
        {
            if (this->_year == d._year)
            {
                if (this->_month > d._month)
                {
                    return true;
                }
                else
                {
                    if (this->_month == d._month)
                    {
                        if (this->_day > d._day)
                        {
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }
                    else
                    {
                        return false;
                    }
                }
            }
            else
            {
                return false;
            }
        }
    }

    //小于
    bool operator < (const Date& d)
    {
        if (this->_year < d._year)
        {
            return true;
        }
        else
        {
            if (this->_year == d._year)
            {
                if (this->_month < d._month)
                {
                    return true;
                }
                else
                {
                    if (this->_month == d._month)
                    {
                        if (this->_day < d._day)
                        {
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }
                    else
                    {
                        return false;
                    }
                }
            }
            else
            {
                return false;
            }
        }
    }

     //大于等于
    bool operator >= (const Date& d)
    {
        if (this->_year >= d._year)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    //小于等于
    bool operator <= (const Date& d)
    {
        if (this->_year <= d._year)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    //Date operator+ (int day);
    Date operator+ (int day)
    {
        
    }
    void Display()
    {
        cout << _year << "-" << _month << "-" << _day<<endl;
    }
    private:
        //判断平年闰年
        bool IsLeapYear(int year)
        {
            if ((year % 4 == 0) && (year % 100 != 0) || (year % 400 == 0))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        //判断天数
        int GetMonthDay(int year, int month)
        {
            if (year && month)
            {
                int monthArray[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
                int day = monthArray[month];

                if (month == 2 && IsLeapYear(year))
                {
                    day += 1;
                }
                return day;
            }
        }

        //加天数,Date operator+ (int day)
        Date operator+ (int day)
        {
            int rest = 0;
            if (day >= 0)
            {
                this->_day += day;
                while (this->_day > GetMonthDay(2016, 5))
                {
                    rest = this->_day - GetMonthDay(2016, 2);
                    if (this->_month != 12)
                    {
                        this->_month++;
                    }
                    else
                    {
                        this->_year++;
                        this->_month = 1;
                    }
                    this->_day = rest;
                }
            }
            else
            {
                Date operator - 50;
            }
            return *this;
        }


    //加天数,Date operator+= (int day);
    Date operator+= (int day )
    {
        Date tmp(*this);
        tmp._day += day;
        int rest = 0;
        if (day > 0)
        {
            while (tmp._day > GetMonthDay(2016, 5))
            {
                rest = tmp._day - GetMonthDay(2016, 2);
                if (tmp._month != 12)
                {
                    tmp._month++;
                }
                else
                {
                    tmp._year++;
                    tmp._month = 1;
                }
                tmp._day = rest;
            }
        }
        else
        {
            Date operator-= 50;
        }
        return tmp;

    }

    //减天数,Date operator- (int day);
    Date operator - (int day)
    {
        int rest = 0;
        if (day <= 0)
        {
            this->_day -= day;
            while (this->_day > GetMonthDay(2016, 5))
            {
                rest = this->_day - GetMonthDay(2016, 2);
                if (this->_month != 1)
                {
                    this->_month--;
                }
                else
                {
                    this->_year--;
                    this->_month = 12;
                }
                this->_day = rest;
            }
        }
        else
        {
            Date operator + 50;
        }
        return *this;
    }

    //减天数,Date operator-= (int day);
    Date operator-= (int day)
    {
        int rest = 0;
        Date tmp(*this);
        if (day <= 0)
        {
            tmp._day -= day;
            while (tmp._day > GetMonthDay(2016, 5))
            {
                rest = tmp._day - GetMonthDay(2016, 2);
                if (tmp._month != 1)
                {
                    tmp._month--;
                }
                else
                {
                    tmp._year--;
                    tmp._month = 12;
                }
                tmp._day = rest;
            }
        }
        else
        {
            Date operator + 50;
        }
        return tmp;
    }

    //前置++
    Date operator++()
    {
        if (day > GetMonthDay(int year, int month))
        {
            if (month != 12)
            {
                ++this->day;
            }
            else
            {
                ++year;
                month = 1;
                day = 1;
            }
        }
        else
        {
            ++day;
        }
        return *this;
    }

    //后置++
    Date operator++(int)
    {
        Date tmp(*this);
        tmp._day;
        if (day > GetMonthDay(int year, int month))
        {
            if (month != 12)
            {
                ++tmp.day;
            }
            else
            {
                ++tmp.year;
                tmp.month = 1;
                tmp.day = 1;
            }
        }
        else
        {
            ++tmp.day;
        }
        return tmp;
    }

    //前置--
    Date operator++()
    {
        if (day > GetMonthDay(int year, int month))
        {
            if (month != 1)
            {
                ++this->day;
            }
            else
            {
                --year;
                month = 12;
                day = 1;
            }
        }
        else
        {
            --day;
        }
        return *this;
    }

    //后置--
    Date operator--(int)
    {
        Date tmp(*this);
        tmp._day;
        if (day > GetMonthDay(int year, int month))
        {
            if (month != 1)
            {
                --tmp.day;
            }
            else
            {
                --tmp.year;
                tmp.month = 12;
                tmp.day = 1;
            }
        }
        else
        {
            --tmp.day;
        }
        return tmp;
    }
    ~Date()
    {
        cout << "析构函数" << endl;
    }

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

void Test1()
{
    Date d;
    d.Display();
    Date ret = operator + (50);
}
int main()
{
    Test1();
    system("pause");
    return 0;
}


String构造函数 拷贝构造函数 析构函数 赋值构造函数的实现

标题:String函数的实现-->主要实现构造函数,拷贝构造函数,析构函数,赋值构造函数。这几个函数是字符串函数最基本的函数,今天也总结一下 #include using namespace std...
  • zhou753099943
  • zhou753099943
  • 2015年10月21日 21:30
  • 1177

总结c++类的构造函数 拷贝构造函数 析构函数 赋值运算符重载的特点以及函数调用顺序

对 c++类成员函数中的构造函数 拷贝构造函数 析构函数 赋值运算符重载的一些特点以及函数调用顺序,并附上例子,希望对大家有帮助,有错误大家可以指出来。...
  • wenqiang1208
  • wenqiang1208
  • 2016年10月18日 19:04
  • 1140

C++中构造函数,拷贝构造函数,析构函数

C++中默认构造函数就是没有形参的构造函数。准确的说法,按照《C++ Primer》中定义:只要定义一个对象时没有提供初始化式,就是用默认构造函数。为所有 的形参提供默认实参的构造函数也定义了默认构造...
  • u012501459
  • u012501459
  • 2015年03月09日 21:29
  • 1477

C++类的构造函数与析构函数

C++中每个类都有其构造与析构函数,它们负责对象的创建和对象的清理和回收,即使我们不写这两个,编译器也会默认为我们提供这些构造函数。下面仍然是通过反汇编的方式来说明C++中构造和析构函数是如何工作的。...
  • lanuage
  • lanuage
  • 2016年06月29日 22:11
  • 3121

C/C++面试题:构造函数与析构函数

构造函数与析构函数的一道小题下面程序的输出是什么?#includeusing namespace std;class TestClass{ char x; public: TestCl...
  • u010429424
  • u010429424
  • 2017年08月11日 21:36
  • 261

构造函数,拷贝构造,析构函数,运算符重载。

1.构造函数 作用:初始化对象。 特点:在创建对象如果类内没用自定义构造函数,系统会自动调用默认的构造函数。 1.函数名和类名相同 2.没有返回值 3.对象构造(对象实例化)时系统自动调用对...
  • wMaiYniJ
  • wMaiYniJ
  • 2017年07月08日 20:21
  • 73

C++中class类 的 构造函数、析构函数

说明: demo.cpp:main.cpp所在之处 Line.h:线段类的.h文件 Line.cpp:线段类的.cpp文件 Coordinate.h:坐标类的.h文件 Coordinate.cpp:坐...
  • shangguanyunlan
  • shangguanyunlan
  • 2016年10月16日 17:05
  • 1741

C++里类的构造函数与析构函数的调用时间

在创建类类型的新的对象的时候,都要执行类中的构造函数。而当构造函数中分配了资源之后,需要一个相应的操作将这些资源释放出去,这就需要析构函数。 一般来说,在有多个类的程序中,先实现的类会先调用构造函数...
  • del_nasay
  • del_nasay
  • 2015年08月11日 23:18
  • 1467

构造函数、析构函数、拷贝构造函数小结

构造函数的定义与使用 构造函数是特殊的公有成员函数,其特征如下: 1.函数名与类名相同。 2.构造函数无函数返回类型说明。注意是没有而不是void,即什么也不写,也不可写vo...
  • qq_32744005
  • qq_32744005
  • 2016年06月05日 00:06
  • 922

C++:类的构造函数和析构函数

C++:类的构造函数和析构函数标签(空格分隔): c++ 作者:陈小默C类的构造函数和析构函数 构造函数 声明和定义 引用参数与构造函数 使用构造函数定义对象 默认构造函数 析构函数 声明和定义 析...
  • qq_32583189
  • qq_32583189
  • 2016年09月02日 17:05
  • 3901
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:C++【面试题】:类实现万年历(日期计算器),(含构造函数、拷贝构造、运算符重载、析构函数)
举报原因:
原因补充:

(最多只允许输入30个字)