Форум программистов [Powered by Invision Power Board]

Код

#ifndef __MAIN_H__
#define __MAIN_H__

#include <windows.h>
#include <ctime>
//#include <iostream>

using namespace std;

//Абстрактный класс, т.к. имеется чисто виртуальная фукнция IsBigDiff
class ABS_date
{
  public:
          enum datesign{dd = 1, mm, yy};
          virtual ~ABS_date(){}; // Конструктор виртуальный
          virtual bool __stdcall IsBigDiff(ABS_date&, int) = 0;     //чисто виртаульная функция
          virtual ABS_date& GetDate() = 0;                //-//-//
         // virtual void __stdcall Viewing() const = 0;               //-//-//
          virtual int datediff(datesign, ABS_date&, ABS_date&) = 0; //-//-//
          virtual bool operator== (const ABS_date&) const = 0;      //-//-//
          virtual bool operator> (const ABS_date&) const = 0;       //-//-//
          virtual bool operator< (const ABS_date&) const = 0;       //-//-//
          virtual bool IsLeapYear(int) = 0;                         //-//-//
          virtual int& MaxDayOfMonth(int&, int&, int&) = 0;         //-//-//
};

typedef ABS_date* (__cdecl *cr_IsBigDiff) ();

//Наследуем от абстрактного класса
class Date : public ABS_date
{
  public:

           enum Month{jan = 1,feb,mar,apr,may,jun,jul,aug,sep,oct,nov,dec,unk};
           Date(int dd = 0, Month mm = Month(0), int year = 0);


           //Деструктор
           virtual ~Date(){};
           //Функции доступа к датам
           int   f_day()const;
           Month f_month()const;
           int   f_year()const;

           //Класс исключений
           /*class Bad_date
           {
            public:
                    Bad_date(short);
                    string& viewing_ex();
            private:
                    string error;
           };*/

           //Функция - модификатор даты
           Date& dateadd (datesign, int, Date&);

           //Проверка высокосного года
           virtual bool IsLeapYear(int);
           //Максимальный день в месяц
           virtual int& MaxDayOfMonth(int&, int&, int&);
           //Перегрузка == для сравнения двух дат
           virtual bool operator== (const Date&) const;
           //Перегрузка > для сравнения двух дат
           virtual bool operator> (const Date&) const;
           //Перегрузка < для сравнения двух дат
           virtual bool operator< (const Date&) const;
           //Функция - разница между двумя датами
           virtual int datediff(datesign, Date&, Date&);
           // Текущая дата
           virtual Date& GetDate();
          // virtual void  __stdcall Viewing()const;
           //True or False если даты сильно отличаются в днях (по умолчанию больше чем на 5 дней)
           virtual bool __stdcall IsBigDiff(ABS_date&, int);

  private:
           int day, year;
           Month month;
           //static ABS_date* default_date; // дата по умолчанию

};

//===============================================================================
//Перегрузка == для сравнения двух дат
bool Date::operator== (const Date& p_date) const
{
  return (this->day == p_date.day && this->month == p_date.month && this->year == p_date.year);
}

//Перегрузка >= для сравнения двух дат
bool Date::operator> (const Date& p_date) const
{
  if   (this->year > p_date.year)
       return true;
  else

  if   (this->year < p_date.year)
       return false;

  if   (this->month > p_date.month)
       return true;
  else

  if   (this->month < p_date.month)
       return false;

  if   (this->day > p_date.day)
       return true;
  else

  if   (this->day < p_date.day)
       return false;
}

//Перегрузка <= для сравнения двух дат
bool Date::operator< (const Date& p_date) const
{
  if   (this->year < p_date.year)
       return true;
  else

  if   (this->year > p_date.year)
       return false;

  if   (this->month < p_date.month)
       return true;
  else

  if   (this->month > p_date.month)
       return false;

  if   (this->day < p_date.day)
       return true;
  else

  if   (this->day > p_date.day)
       return false;
}

//Проверка на високосный год
bool Date::IsLeapYear(int yy)
{
    if ((yy%4 == 0 && yy%100 != 0) || yy%400 == 0)
       return true;
    else
        return false;
}

//Максимальный день в месяце
int& Date::MaxDayOfMonth(int& ref_temp_mm, int& ref_max_date, int& ref_year)
{
   switch (ref_temp_mm)
   {
     case 2:
            ref_max_date = 28 + Date::IsLeapYear(ref_year);
     break;

     case 4: case 6: case 9: case 11: ref_max_date = 30;
     break;

     case 1: case 3: case 5: case 7: case 8: case 10: case 12: ref_max_date = 31;
     break;
   }

   return ref_max_date;

}

/*
void  Date::Viewing()const
{
    cout << day << "-" << month <<  "-" << year;
}*/

//Текущая дата
Date& Date::GetDate()
{
  time_t t;
  tm* tm_t;
  time(&t);

  tm_t = localtime(&t);

  year  = (tm_t->tm_year + 1900);
  month = Month(tm_t->tm_mon + 1);
  day   = tm_t->tm_mday;

  return *this;
}
//===========================__stdcall===========================================
bool Date::IsBigDiff(ABS_date& date_isbig, int value = 5)
{

   ABS_date* g_date;
    g_date->GetDate(); // Дата по умолчанию

    if   (g_date->datediff(ABS_date::dd, date_isbig, *g_date) <= value)
         return false;
    else
         return true;

    delete g_date; // Очищаем выделенную память под Дату по умолчанию
}

//Функция - разница между двумя датами
int Date::datediff(datesign sign, Date& date_first, Date& date_second)
{
    if (date_first == date_second) // Даты идентичны
       return 0;
    else

    switch(sign)
   {
       case yy: //Год между двумя датами
                {
                  int yy_f = date_first.year, yy_s = date_second.year;
                  return (yy_s - yy_f);

                } break;

       case mm: // Месяц между двумя датами
                {
                  int mm_f = date_first.month,  yy_f = date_first.year,
                      mm_s = date_second.month, yy_s = date_second.year,
                      count_mm = 0;

                  if (date_second > date_first) // Вторая дата больше первой
                  {

                    while (yy_s != yy_f || mm_s != mm_f)
                    {
                       // Одинаковые года
                       if (yy_s == yy_f)
                           {
                             count_mm += mm_s - mm_f;
                             mm_s     -= mm_s - mm_f;
                           }
                       else
                            {
                              // Когда года у дат разные
                              yy_s--;
                              count_mm += mm_s;
                              mm_s = 12;
                            }
                    }
                    return count_mm;
                  }
                  else
                      if (date_second < date_first) // Вторая дата меньше первой
                      {
                        while (yy_f != yy_s || mm_f != mm_s)
                        {
                          // Одинаковые года
                          if (yy_f == yy_s)
                             {
                               count_mm += mm_f - mm_s;
                               mm_f     -= mm_f - mm_s;
                             }
                         else
                              {
                                // Когда года у дат разные
                                yy_f--;
                                count_mm += mm_f;
                                mm_f = 12;
                              }
                        }
                        return -count_mm;
                    }

                } break;

       case dd: // День между двумя датами
               {
                  int day_f = date_first.day,  mm_f = date_first.month,  yy_f = date_first.year,
                      day_s = date_second.day, mm_s = date_second.month, yy_s = date_second.year,
                      count_dd = 0;

                  if (date_second > date_first) // Вторая дата больше первой
                  {
                     while (yy_s != yy_f || mm_s != mm_f || day_s != day_f) // Пока даты неравны
                     {
                        // Месяцы и года у дат одинаковые
                        if (mm_s == mm_f && yy_s == yy_f)
                        {
                            count_dd += day_s - day_f;
                            day_s    -= day_s - day_f;

                        }
                        else
                        {
                            count_dd += day_s;
                            mm_s--;

                            if (0 == mm_s)
                            {
                               mm_s = 12;
                               yy_s--;
                            }
                            //Находим Max день в месяце
                            Date::MaxDayOfMonth(mm_s, day_s,yy_s);
                        }
                     }
                 }
                 else
                 if (date_second < date_first) // Вторая дата меньше первой
                 {
                     while (yy_f != yy_s || mm_f != mm_s || day_f != day_s) // Пока даты неравны
                     {
                        // Месяцы и года у дат одинаковые
                        if (mm_f == mm_s && yy_f == yy_s)
                        {
                            count_dd = (day_s - day_f) - count_dd;
                            day_f   -= day_f - day_s;

                        }
                        else
                        {
                            count_dd += day_f;
                            mm_f--;

                            if (0 == mm_f)
                            {
                               mm_f = 12;
                               yy_f--;
                            }
                            //Находим Max день в месяце
                            Date::MaxDayOfMonth(mm_f, day_f,yy_f);
                        }
                     }
                 }

               return count_dd;

               }break;

     //default: throw Bad_date(4);
   }
}

//================================================================================

#endif // __MAIN_H__