title: Overloading the '-' operator
body: <p>Currently I'm writing a program that has a section to determine the difference in days between two dates, but by overloading the minus operator.</p>
  
  <p>I'm currently staring at my screen drawing a complete blank. I have some fleeting thoughts in my head but they are exactly that, fleeting.</p>
  
  <p>What's to happen in the main.cpp is that there are going to be two variables, for instance <code>beethovenDeathDate</code> and <code>beethovenBirthDate</code> that will be subtracted to determine how long he lived for. Which is something around 22000 days if I recall correctly.</p>
  
  <p>So without further ado, here is my code:</p>
  
  <h1>Date.cpp</h1>
  
  <pre><code>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( &amp; t );
      _year = now -&gt; tm_year + 1900;
      _month = now -&gt; tm_mon + 1;
      _day = now -&gt; tm_mday;
  }
  
  int Date::maxDay(int month, int year)
  {
      int ret = DAYS_PER_MONTH[month];
      if(isLeapYear(year) == true &amp;&amp; month == 2)
      {
          ++ret;
      }
      return ret;
  }
  
  void Date::addDay(bool forward)
  {
      if(forward)
      {
          if(_day &lt; maxDay(_month, _year))
          {
              ++_day;
          }
          else
          {
              _day = MIN_DAY;
              ++_month;
              if(_month &gt; MAX_MONTH)
              {
                  _month = MIN_MONTH;
                  ++_year;
              }    
          }
      }
      else
      {
          if(_day &lt;= MIN_DAY)
          {
              --_month;
              if(_month &lt; 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  &lt;&lt; MONTH_STRINGS[_month] &lt;&lt; " " &lt;&lt; _day &lt;&lt; ", " &lt;&lt;  _year;
      return ss.str();            
  }    
  
  
  bool Date::isValid() const
  {
      if(_month &lt; MIN_MONTH || _month &gt; MAX_MONTH)
      {
          std::cerr &lt;&lt; "Invalid date " &lt;&lt; std::endl;
          return false;
      }
      int daysThisMonth = maxDay(_month, _year);
  
      if(_day &lt; MIN_DAY || _day &gt; daysThisMonth)
      {
          std::cerr &lt;&lt; "Invalid date " &lt;&lt; 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 &amp;&amp;  month == 2 &amp;&amp; isLeapYear(year) == true)
      {
          return true;
      }
      else
      {
          return false;
      }
  }
  
  
  void Date::addYears(int years)
  {
      if(years == 0)
      {
          return;
      }
      if(isLeapDay() &amp;&amp; !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 &gt; 0)
      {
          newMonth = (_month + deltamonths) % MAX_MONTH;
          if((_month + deltamonths) &gt; MAX_MONTH)
          {
              ++deltayears;
          }
      }
      else
      {
          if((_month + deltamonths) &lt; MIN_MONTH)
          {
              --deltayears;
              newMonth = _month + deltamonths + MAX_MONTH;
          }
          else
          {
              newMonth = _month + deltamonths;
          }       
      }
      if(_day &gt; maxDay(newMonth, _year + deltayears))
      {
          _day = maxDay(newMonth, _year + deltayears);
      }
      _year += deltayears;
      _month = newMonth;
  
  }
  
  void Date::addDays(int days)
  {
      if(days == 0)
      {
          return;
      }
  
      if(days &lt; 0)
      {
          for(int i = 0; i &gt; days; --i)
          {
              addDay(false);
          }
          return;
      }
  
      for(int i = 0; i &lt; days; ++i)
      {
          addDay(true);
      }
  }
  
  std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, const Date&amp; date)
  {
      os &lt;&lt; date.toString();
      return os;
  }
  
  Date Date::operator+(int days) const
  {
      Date ret = *this;
      ret.addDays(days);
      return ret;
  }
  
  Date&amp; Date::operator+=(int days)
  {
      addDays(days);
      return *this;
  }
  //This is where I get stumped (the parameters was just one of my failed experiments
  Date&amp; Date::operator-(int day, int month, int year)
  {
  }
  </code></pre>