c – 重载’ – ‘运算符

2023年11月9日 206次阅读

目前我正在编写一个程序,其中有一个部分用于确定两个日期之间的天数差异,但是通过重载减号运算符.

我正在盯着我的屏幕画一个完整的空白.我头脑中有一些短暂的想法,但它们就是那个,转瞬即逝.

在main.cpp中发生的事情是,将会有两个变量,例如beethovenDeathDate和beethovenBirthDate,它们将被减去以确定他的生存时间.如果我没记错的话,这大约是22000天.

所以不用多说,这是我的代码：

Date.cpp

const std::string Date::MONTH_STRINGS[] = 
{
    "", //one based indexing
    "January",
    "February",
    "March",
    "April",
    "May", 
    "June",
    "July",
    "August",
    "September",
    "October",
    "November",
    "December"
};

const int Date::DAYS_PER_MONTH[] =
{
    0, //one based indexing
    31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};      

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

Date::Date()
{
    time_t t = time(0);   // get time now
    struct tm * now = localtime( & t );
    _year = now -> tm_year + 1900;
    _month = now -> tm_mon + 1;
    _day = now -> tm_mday;
}

int Date::maxDay(int month, int year)
{
    int ret = DAYS_PER_MONTH[month];
    if(isLeapYear(year) == true && month == 2)
    {
        ++ret;
    }
    return ret;
}

void Date::addDay(bool forward)
{
    if(forward)
    {
        if(_day < maxDay(_month, _year))
        {
            ++_day;
        }
        else
        {
            _day = MIN_DAY;
            ++_month;
            if(_month > MAX_MONTH)
            {
                _month = MIN_MONTH;
                ++_year;
            }    
        }
    }
    else
    {
        if(_day <= MIN_DAY)
        {
            --_month;
            if(_month < MIN_MONTH)
            {
                _month = MAX_MONTH;
                --_year;
            } 
            _day = maxDay(_month, _year);
        }
        else
        {
            --_day;
        }
    }    
}


std::string Date::toString() const
{
    if(isValid() == false)
    {
        return std::string();
    }
    std::stringstream ss;
    ss  << MONTH_STRINGS[_month] << " " << _day << ", " <<  _year;
    return ss.str();            
}    


bool Date::isValid() const
{
    if(_month < MIN_MONTH || _month > MAX_MONTH)
    {
        std::cerr << "Invalid date " << std::endl;
        return false;
    }
    int daysThisMonth = maxDay(_month, _year);

    if(_day < MIN_DAY || _day > daysThisMonth)
    {
        std::cerr << "Invalid date " << std::endl;            
        return false;   
    }
    return true;
}

bool Date::isLeapYear(int year)
{
    if(!(year % 4))
    {
        if(!(year % 100))
        {
            if(!(year % 400))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return true;
        }
    }
    else
    {
        return false;
    }
}

bool Date::isLeapYear() const
{
    return isLeapYear(_year);
}

bool Date::isLeapDay() const
{
    return isLeapDay(_day, _month, _year);
}

bool Date::isLeapDay(int day, int month, int year) 
{
    if(day == 29 &&  month == 2 && isLeapYear(year) == true)
    {
        return true;
    }
    else
    {
        return false;
    }
}


void Date::addYears(int years)
{
    if(years == 0)
    {
        return;
    }
    if(isLeapDay() && !isLeapDay(_day, _month, _year + years))
    {
        _day = Date::DAYS_PER_MONTH[_month];
    }
    _year += years;
}

void Date::addMonths(int months)    
{
    if(months == 0)
    {
        return;
    }
    int deltayears = months / MAX_MONTH;
    int deltamonths = months % MAX_MONTH;
    int newMonth = 0;
    if(months > 0)
    {
        newMonth = (_month + deltamonths) % MAX_MONTH;
        if((_month + deltamonths) > MAX_MONTH)
        {
            ++deltayears;
        }
    }
    else
    {
        if((_month + deltamonths) < MIN_MONTH)
        {
            --deltayears;
            newMonth = _month + deltamonths + MAX_MONTH;
        }
        else
        {
            newMonth = _month + deltamonths;
        }       
    }
    if(_day > maxDay(newMonth, _year + deltayears))
    {
        _day = maxDay(newMonth, _year + deltayears);
    }
    _year += deltayears;
    _month = newMonth;

}

void Date::addDays(int days)
{
    if(days == 0)
    {
        return;
    }

    if(days < 0)
    {
        for(int i = 0; i > days; --i)
        {
            addDay(false);
        }
        return;
    }

    for(int i = 0; i < days; ++i)
    {
        addDay(true);
    }
}

std::ostream& operator<<(std::ostream& os, const Date& date)
{
    os << date.toString();
    return os;
}

Date Date::operator+(int days) const
{
    Date ret = *this;
    ret.addDays(days);
    return ret;
}

Date& Date::operator+=(int days)
{
    addDays(days);
    return *this;
}
//This is where I get stumped (the parameters was just one of my failed experiments
Date& Date::operator-(int day, int month, int year)
{
}

最佳答案 该函数既可以作为成员编写,也可以作为自由函数编写.成员函数签名如下所示：

TimeDuration Date::operator-(Date const & rhs) const

免费功能如下所示：

TimeDuration operator-(Date const & lhs, Date const & rhs)

这里的TimeDuration是一个完全独立的类型,代表一段时间.如果你愿意,你可以把它变成一个表示天数的int,但在我看来,为了这个目的,有一个更具表现力的类型会更好.无论你决定什么类型的返回类型,它都没有任何意义,因为类型是Date(当然不是Date&).

一个可能的(尽管不是非常有效)实现,假设你已经编写了一个函数来添加一天的日期,将是这样的：

if lhs_date comes before rhs_date
    add days to (a copy of) lhs_date until lhs_date == rhs_date
    return the negative of number of days added
if rhs_date comes before lhs_date
    add days to (a copy of) rhs_date until rhs_date == lhs_date
    return the number of days added
else
    return 0

您可能想要的另一个功能(或者这可能是您最初想要的功能,但您的措辞并未表明它)是一个可以从Date中减去一段时间的功能.在这种情况下,返回值将是另一个Date对象(但不是Date&),可能的签名看起来像这样：

Date Date::operator-(TimeDuration rhs) const // member version
Date operator-(Date const & lhs, TimeDuration const & rhs) // non-member version
点赞