Date

日期类的实现

注意日期合法的判断的函数和比较时间先后的函数

date.h

#include<iostream>
#include<string>
#include<sstream>
using namespace std;
class Date;
ostream& operator<<(ostream& out, const Date& date);
istream& operator>>(istream& in, Date& date);

class Date {
    private:
        int year;
        int month;
        int day;
    public:
        Date(int year = 0, int month = 0, int day = 0);
        Date(const Date& date);
        ~Date();
        void setYear(int year);
        void setMonth(int month);
        void setDay(int day);
        int getYear() const;
        int getMonth() const;
        int getDay() const;

        string toString() const;
        bool isValid();
        int daysOfMonth();
        void increment();
        Date after(int days);

        bool operator <(const Date& date);
        bool operator >(const Date& date);
        Date& operator =(const Date& date);
        bool operator ==(const Date& date);
        bool operator !=(const Date& date);

        int& operator[](int index);

        Date& operator ++();
        Date operator ++(int temp);

        friend ostream& operator<<(ostream& out, const Date & date);
        friend istream& operator>>(istream& in, Date & date);
};
Date::Date(int year, int month, int day) {
    this->year = year;
    this->month = month;
    this->day = day;
}

Date::Date(const Date& date) {
    *this = date;
}

Date::~Date() {}

void Date::setYear(int year) {
    this->year = year;
}

void Date::setMonth(int month) {
    this->month = month;
}

void Date::setDay(int day) {
    this->day = day;
}

int Date::getYear() const {
    return year;
}

int Date::getMonth() const {
    return month;
}

int Date::getDay() const {
    return day;
}

string intTranStr1(int integer) {
    stringstream ss;
    ss << integer;
    return ss.str();
}

void Date::increment() {
    ++(*this);
}

int Date::daysOfMonth() {
    if ((month%2 == 1 && month < 8) || (month%2 == 0 && month >= 8)) 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;
}

string Date::toString() const {
    return ("[" + intTranStr1(year) + "-" + intTranStr1(month) +\
        "-" + intTranStr1(day) + "]");
}

bool Date::isValid() {
    if (year <= 0) return false;
    if (month <= 0 || month > 12) return false;
    if (day <= 0 || day > 31) return false;
    return (day <= daysOfMonth());
}

Date Date::after(int days) {
    Date temp = Date(*this);
    while (days--) {
        ++temp;
    }
    return temp;
}

bool Date::operator <(const Date& date) {
    if (year < date.getYear()) return true;
    if (year > date.getYear()) return false;
    if (month < date.getMonth()) return true;
    if (month > date.getMonth()) return false;
    return (day < date.getDay());
}

bool Date::operator >(const Date& date) {
    return (*this != date) && !(*this < date);
}

Date& Date::operator =(const Date& date) {
    year = date.getYear();
    month = date.getMonth();
    day = date.getDay();
    return *this;
}

bool Date::operator ==(const Date& date) {
    return (year == date.getYear() &&\
        month == date.getMonth() && day == date.getDay());
}

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

int& Date::operator[](int index) {
    if (index == 0) return year;
    if (index == 1) return month;
    else return day;
}

Date& Date::operator ++() {
    day++;
    if (day > daysOfMonth()) {
        day = 1;
        month++;
        if (month > 12) {
            month = 1;
            year++;
        }
    }
    return *this;
}

Date Date::operator ++(int temp) {
    Date tmp = *this;
    ++(*this);
    return tmp;
}

ostream& operator<<(ostream& out, const Date& date) {
    out << date.toString() << endl;
    return out;
}

istream& operator>>(istream& in, Date& date) {
    in >> date.year >> date.month >> date.day;
    return in;
}

Time.h

class Time {
    private:
        int hour;
        int minute;
        int second;
    public:
        Time(int hour = 0, int minute = 0, int second = 0);
        Time(const Time& time);
        ~Time();
        void setHour(int hour);
        void setMinute(int minute);
        void setSecond(int second);
        int getHour() const;
        int getMinute() const;
        int getSecond() const;
        string toString() const;
        bool isValid() const;
        Time after(int seconds);
        void increment();
};

Time::Time(int hour, int minute, int second) {
    this->hour = hour;
    this->minute = minute;
    this->second = second;
}

Time::Time(const Time& time) {
    this->hour = time.getHour();
    this->minute = time.getMinute();
    this->second = time.getSecond();
}

Time::~Time() {}

void Time::setHour(int hour) {
    this->hour = hour;
}

void Time::setMinute(int minute) {
    this->minute = minute;
}

void Time::setSecond(int second) {
    this->second = second;
}

int Time::getHour() const {
    return hour;
}

int Time::getMinute() const {
    return minute;
}

int Time::getSecond() const {
    return second;
}

bool Time::isValid() const {
    if (hour < 0 || hour >= 24) return false;
    if (minute < 0 || minute >= 60) return false;
    if (second < 0 || second >= 60) return false;
    return true;
}

// auxiliary function that transfers the integer to string..
string intTranStr(int integer) {
    stringstream ss;
    ss << integer;
    return ss.str();
}

string Time::toString() const {
    string result = "";
    if (hour%12 < 10) result += "0";
    result += (intTranStr(hour%12) + ":");
    if (minute < 10) result += "0";
    result += (intTranStr(minute) + ":");
    if (second < 10) result += "0";
    result += intTranStr(second);
    if (hour >= 12) result += " PM";
    else result += " AM";
    return result;
}

Time Time::after(int seconds) {
    Time temp_time = Time(*this);
    while (seconds--) {
        temp_time.increment();
    }
    return temp_time;
}

void Time::increment() {
    second++;
    if (second >= 60) {
        second = 0;
        minute++;
        if (minute >= 60) {
            minute = 0;
            hour++;
            if (hour >= 24) hour = 0;
        }
    }
}

Datetime.h

class Datetime:public Date, public Time {
public:
  Datetime(int y, int m, int d, int hr, int min, int sec);
  Datetime(const Date& d, const Time& t);
  ~Datetime();
  string toString();
  Datetime after(int seconds);
  bool operator<(const Datetime& dt);
  bool operator>(const Datetime& dt);
  Datetime& operator=(const Datetime& dt);
  bool operator==(const Datetime& dt);
  bool operator!=(const Datetime& dt);
  Datetime& operator++();
  Datetime operator++(int temp);
};
Datetime::Datetime(int y, int m, int d, int hr, int min, int sec):\
Date(y, m, d), Time(hr, min, sec) {}
Datetime::Datetime(const Date& d, const Time& t):Date(d), Time(t) {}
string Datetime::toString() {
  Date::toString();
  Time::toString();
  string result;
  result = Date::toString();
  result += " ";
  result += Time::toString();
  return result;
}
Datetime::~Datetime() {
  cout << "Destructor:" << this->toString() << endl;
}
bool Datetime::operator<(const Datetime& dt) {
  if (getYear() < dt.getYear()) return true;
  else if (getYear() == dt.getYear()) {
    if (getMonth() < dt.getMonth()) return true;
    else if (getMonth() == dt.getMonth()) {
      if (getDay() < dt.getDay()) return true;
      else if (getDay() == dt.getDay()) {
        if (getHour() < dt.getHour()) return true;
        else if (getHour() == dt.getHour()) {
          if (getMinute() < dt.getMinute()) return true;
          else if (getMinute() == dt.getMinute()) {
            if (getSecond() < dt.getSecond()) return true;
            else return false;
          } else {
            return false;
          }
        } else {
          return false;
        }
      } else {
        return false;
      }
    } else {
      return false;
    }
  } else {
    return false;
  }
}
bool Datetime::operator>(const Datetime& dt) {
  if (getYear() > dt.getYear()) return true;
  else if (getYear() == dt.getYear()) {
    if (getMonth() > dt.getMonth()) return true;
    else if (getMonth() == dt.getMonth()) {
      if (getDay() > dt.getDay()) return true;
      else if (getDay() == dt.getDay()) {
        if (getHour() > dt.getHour()) return true;
        else if (getHour() == dt.getHour()) {
          if (getMinute() > dt.getMinute()) return true;
          else if (getMinute() == dt.getMinute()) {
            if (getSecond() > dt.getSecond()) return true;
            else return false;
          } else {
            return false;
          }
        } else {
          return false;
        }
      } else {
        return false;
      }
    } else {
      return false;
    }
  } else {
    return false;
  }
}
bool Datetime::operator==(const Datetime& dt) {
  if (getYear() == dt.getYear())
  if (getMonth() == dt.getMonth())
  if (getDay() == dt.getDay())
  if (getHour() == dt.getHour())
  if (getMinute() == dt.getMinute())
  if (getSecond() == dt.getSecond())
  return true;
  return false;
}
bool Datetime::operator!=(const Datetime& dt) {
  if (getYear() == dt.getYear())
  if (getMonth() == dt.getMonth())
  if (getDay() == dt.getDay())
  if (getHour() == dt.getHour())
  if (getMinute() == dt.getMinute())
  if (getSecond() == dt.getSecond())
  return false;
  return true;
}
Datetime& Datetime::operator=(const Datetime& dt) {
  setYear(dt.getYear());
  setMonth(dt.getMonth());
  setDay(dt.getDay());
  setHour(dt.getHour());
  setMinute(dt.getMinute());
  setSecond(dt.getSecond());
  return *this;
}
Datetime& Datetime::operator++() {
  setSecond(getSecond() + 1);
  if (getSecond() >= 60) {
    setMinute(getMinute() + getSecond()/60);
    setSecond(getSecond()%60);
    if (getMinute() >= 60) {
      setHour(getMinute()/60 + getHour());
      setMinute(getMinute()%60);
      if (getHour() >= 12) {
      setDay(getDay() + getHour()/24);
      setHour(getHour()%24);
      }
    }
  }
  if (!daysOfMonth()) {
    switch (getMonth()) {
      case 1:
      case 3:
      case 5:
      case 7:
      case 8:
      case 10:
      case 12:
      setMonth(getDay()/31);
      setDay(getDay()%31);
      if (getMonth() > 12) {
        setYear(getMonth()/12);
        setMonth(getMonth()%12);
      }
      case 4:
      case 6:
      case 9:
      case 11:
      setMonth(getDay()/30);
      setDay(getDay()%30);
      if (getMonth() > 12) {
        setYear(getMonth()/12);
        setMonth(getMonth()%12);
      }
      case 2:
      if ((getYear()%4 == 0&&getYear()%100 != 0)||getYear()%400 == 0) {
        setMonth(getDay()/29);
        setDay(getDay()%29);
        if (getMonth() > 12) {
          setYear(getMonth()/12);
          setMonth(getMonth()%12);
        }
      } else {
        setMonth(getDay()/28);
        setDay(getDay()%28);
        if (getMonth() > 12) {
          setYear(getMonth()/12);
          setMonth(getMonth()%12);
        }
      }
    }
  }
  return *this;
}
Datetime Datetime::operator++(int temp) {
  Datetime dt = *this;
  ++(*this);
  return dt;
}
Datetime Datetime::after(int seconds) {
  Datetime dt = Datetime(getYear(), getMonth(), getDay(), getHour(),\
  getMinute(), getSecond());
  dt.setSecond(dt.getSecond() + seconds);
  if (dt.getSecond() >= 60) {
    dt.setMinute(dt.getMinute() + dt.getSecond()/60);
    dt.setSecond(dt.getSecond()%60);
    if (dt.getMinute() >= 60) {
      dt.setHour(dt.getMinute()/60 + dt.getHour());
      dt.setMinute(dt.getMinute()%60);
      if (dt.getHour() >= 24) {
      dt.setDay(dt.getDay() + dt.getHour()/24);
      dt.setHour(dt.getHour()%24);
      }
    }
  }
    switch (dt.getMonth()) {
      case 1:
      case 3:
      case 5:
      case 7:
      case 8:
      case 10:
      case 12:
      if (dt.getDay() > 31) {
      dt.setMonth(dt.getMonth() + dt.getDay()/31);
      dt.setDay(dt.getDay()%31);
      if (dt.getMonth() > 12) {
        dt.setYear(dt.getYear() + dt.getMonth()/12);
        dt.setMonth(dt.getMonth()%12);
      }
      }
      case 4:
      case 6:
      case 9:
      case 11:
      if (dt.getDay() > 30) {
      dt.setMonth(dt.getMonth() + dt.getDay()/30);
      dt.setDay(dt.getDay()%30);
      if (dt.getMonth() > 12) {
        dt.setYear(dt.getYear() + dt.getMonth()/12);
        dt.setMonth(dt.getMonth()%12);
      }
      }
      case 2:
      if ((dt.getYear()%4 == 0&&dt.getYear()%100 != 0)||dt.getYear()%400 == 0) {
        if (dt.getDay() > 29) {
        dt.setMonth(dt.getMonth() + dt.getDay()/29);
        dt.setDay(dt.getDay()%29);
        if (dt.getMonth() > 12) {
          dt.setYear(dt.getYear() + dt.getMonth()/12);
          dt.setMonth(dt.getMonth()%12);
        }
        }
      } else {
        if (dt.getDay() > 28) {
        dt.setMonth(dt.getMonth() + dt.getDay()/28);
        dt.setDay(dt.getDay()%28);
        if (dt.getMonth() > 12) {
          dt.setYear(dt.getYear() + dt.getMonth()/12);
          dt.setMonth(dt.getMonth()%12);
        }
        }
      }
    }
  return dt;
}

main.cpp

int main() {
    Datetime datetime1(2015, 3, 21, 23, 59, 58);

    // test for overloaded operator ++.
    Datetime datetime2 = (datetime1++);
    cout << datetime2.toString() << endl;
    cout << datetime1.toString() << endl;
    datetime2 = ++datetime1;
    cout << datetime2.toString() << endl;
    cout << datetime1.toString() << endl;

    Datetime datetime3(datetime2);
    if (datetime3 == datetime1) cout << "They are the same!" << endl;
    else cout << "They are different!" << endl;

    int year, month, day, hour, minute, second;
    cin >> year >> month >> day >> hour >> minute >> second;
    datetime3.setYear(year);
    datetime3.setMonth(month);
    datetime3.setDay(day);
    datetime3.setHour(hour);
    datetime3.setMinute(minute);
    datetime3.setSecond(minute);

    if (datetime3 != datetime1) cout << "They are different!\n";
    else cout << "They are not different!\n";
    if (datetime3 > datetime1) cout << "First datetime"
        << "is latter than the second one.\n";
    if (datetime3 < datetime1) cout << "First datetime"
        << "is earlier than the second one.\n";

    int seconds = 10;
    cin >> seconds;
    cout << datetime3.after(seconds).toString() << endl;
}