Создать класс для работы с одномерными массивами вещественных чисел

#include <iostream.h> // заголовочные файлы стандартных
#include <windows.h>      // библиотек
 
#define TRUE 1  // макроопределения для BOOL
#define FALSE 0
 
#define MAX_HOUR 24    // максимальное количество часов
#define MAX_MINUTE 60  // максимальное количество минут
#define MAX_SEC 60     // максимальное количество секунд
 
// объявление класса для работы со временем
class TIME
{
private:  // скрытый раздел
  unsigned Hour;  // часы
  unsigned Min;   // минуты
  unsigned Sec;   // секунды
  // скрытые функции
  long CountSec(TIME *);
  TIME SecToHMS(long sec);
  void getSystemTime();
public:  // доступный раздел
  TIME();      // конструктор без аргументов
  // конструктор с целочисленными аргументами,
  TIME(unsigned short hour,unsigned short min,
       unsigned short sec=0);
  // деструктор не выполняет ни каких действий
  ~TIME() { }
  // функция получения количества часов
  unsigned short GetHour() { return Hour; }
  // функция получения количества минут
  unsigned short GetMin() { return Min; }
  // функция получения количества секунд
  unsigned short GetSec() { return Sec; }
  // функция присвоения определенного времени
  short AssignTime(unsigned short hour,unsigned short min,
              unsigned short sec=0);
  // функция присвоения системного времени
  void AssignSystemTime();
  // функция печати времени
  void Print();
  // функция задания времени пользователем
  void Input();
  // перегрузка операторов
  void operator = (TIME &);  // присваивания значения
  BOOL operator == (TIME &); // логического равенства
  BOOL operator != (TIME &); // логического неравенства
  BOOL operator > (TIME &);  // логическое больше
  BOOL operator < (TIME &);  // логическое меньше
  void operator +=(TIME &);  // суммирования и присваивания значения
  void operator +=(long); // суммирования и
                                    // присваивания значения
  void operator -=(TIME &);  // вычитания и присваивания значения
  void operator -=(long); // вычитания
                                    // и присваивания значения
  TIME operator -(TIME &);  // вычитания
  TIME operator +(TIME &);  // суммирования
};
 
// конструктор без аргументов берет текущее время системы
TIME::TIME()
{
  getSystemTime();
}
 
// конструктор с целочисленными аргументами,
// sec==0 по умолчанию
TIME::TIME(unsigned short hour,unsigned short min,
          unsigned short sec)
{
   // проверка правильности данных
   if(hour<MAX_HOUR && min<MAX_MINUTE && sec<MAX_SEC)
   {
    Hour=hour;  // часы
    Min=min;   // минуты
    Sec=sec;   // секунды
   }  // если ошибка в данных то берем системное время
   else getSystemTime();
}
 
// функция задания времени,
// sec==0 по умолчанию
// возвращает 1 при попытке ошибочного присвоения
short TIME::AssignTime(unsigned short hour,unsigned short min,
              unsigned short sec)
{
   // проверка правильности данных
   if(hour<MAX_HOUR && min<MAX_MINUTE && sec<MAX_SEC)
   {
    Hour=hour;  // часы
    Min=min;   // минуты
    Sec=sec;   // секунды
    return 0;
   }  // если ошибка в данных то берем системное время
   getSystemTime();
   return 1;
}
 
// функция определяет системное время и присваевает его
// переменным класса
void TIME::getSystemTime()
{
SYSTEMTIME t;
   GetLocalTime(&t); // получаем системное время
   Hour=t.wHour;
   Min=t.wMinute;
   Sec=t.wSecond;
}
 
// преобразование времени в количество секунд
// получает указатель на класс TIME
long TIME::CountSec(TIME *t)
{
 return (long)t->Hour*MAX_MINUTE*MAX_SEC+t->Min*MAX_SEC+t->Sec;
}
 
// преобразование количества секунд в часы, минуты, секунды
// и запись часов, минут и секунд в переменные класса
TIME TIME::SecToHMS(long sec)
{
 TIME tmp;
 // нормализация, если количество секунд отрицательное
 while(sec<0l) sec=MAX_HOUR*MAX_MINUTE*MAX_SEC+sec;
 do {
   tmp.Hour=sec/(MAX_MINUTE*MAX_SEC);
   sec-=tmp.Hour*(MAX_MINUTE*MAX_SEC);
 } while(tmp.Hour>MAX_HOUR);
 tmp.Min=sec/(MAX_SEC);
 sec-=tmp.Min*(MAX_SEC);
 tmp.Sec=sec;
 return tmp;
}
 
// функция определяет системное время и присваевает его
// переменным класса
// функция реализована как подставляемая (inline)
inline void TIME::AssignSystemTime()
{
  getSystemTime();
}
 
// функция печати времени
// функция реализована как подставляемая (inline)
inline void TIME::Print()
{
  cout<<Hour<<":"<<Min<<":"<<Sec<<endl;
}
 
// функция задания времени пользователем
void TIME::Input()
{
 // вводим часы с контролем ошибки
 do { cout<<"\nHour: ";
      cin>>Hour;
 } while(Hour>=MAX_HOUR);
 // вводим минуты с контролем ошибки
 do { cout<<"\nMin: ";
      cin>>Min;
 } while(Min>=MAX_MINUTE);
 // вводим секунды с контролем ошибки
 do { cout<<"\nSec: ";
      cin>>Sec;
 } while(Sec>=MAX_SEC);
}
 
// перегруженный оператор присваивания значения
void TIME::operator = (TIME &t)
{
 if(this==&t) return; // попытка присвоить самого себя
 Hour=t.Hour;  // присваивание
 Min=t.Min;
 Sec=t.Sec;
}
 
// перегруженный оператор логического равенства
BOOL TIME::operator == (TIME &t)
{
 if(this==&t) return TRUE; // сам себе равен
 // проверяем равенство
 return (Hour==t.Hour && Min==t.Min && Sec==t.Sec);
}
 
// перегруженный оператор логического равенства
BOOL TIME::operator != (TIME &t)
{
 if(this==&t) return FALSE; // сам себе равен
 // проверяем неравенство
 return (Hour!=t.Hour || Min!=t.Min || Sec!=t.Sec);
}
 
// перегруженный оператор логическое больше
BOOL TIME::operator > (TIME &t)
{
 if(this==&t) return FALSE; // сам себе равен
 // определяем, какое время больше
 if(Hour>t.Hour) return TRUE;  // сравниваем часы
 else if(Hour<t.Hour) return FALSE;
 else    // часы равны
 {
   if(Min>t.Min) return TRUE;    // сравниваем минуты
   else if(Min<t.Min) return FALSE;
   else          // минуты равны
   {
     if(Sec>t.Sec) return TRUE;   // сравниваем секунды
     else return FALSE;
   }
 }
}
 
// перегруженный оператор логическое меньше
BOOL TIME::operator < (TIME &t)
{
 if(this==&t) return FALSE; // сам себе равен
 // определяем, какое время больше
 if(Hour<t.Hour) return TRUE;  // сравниваем часы
 else if(Hour>t.Hour) return FALSE;
 else    // часы равны
 {
   if(Min<t.Min) return TRUE;    // сравниваем минуты
   else if(Min>t.Min) return FALSE;
   else          // минуты равны
   {
     if(Sec<t.Sec) return TRUE;   // сравниваем секунды
     else return FALSE;
   }
 }
}
 
// перегруженный оператор суммирования и присваивания значения
// прибавляется часы, минуты и секунды
void TIME::operator += (TIME &t)
{
 *this=SecToHMS( CountSec(this) + CountSec(&t) );
}
 
// перегруженный оператор суммирования и присваивания значения
// прибавляется количество секунд
void TIME::operator += (long sec)
{
 *this=SecToHMS( CountSec(this) + sec );
}
 
// перегруженный оператор вычитания и присваивания значения
void TIME::operator -= (TIME &t)
{
 *this=SecToHMS( CountSec(this) - CountSec(&t) );
}
 
// перегруженный оператор вычитания и присваивания значения
// вычитает количество секунд
void TIME::operator -= (long sec)
{
 *this=SecToHMS( CountSec(this) - sec );
}
 
// перегруженный оператор вычитания
// результат часы, минуты, секунды
TIME TIME::operator - (TIME &t)
{
 return SecToHMS( CountSec(this) - CountSec(&t) );
}
 
// перегруженный оператор сложения
TIME TIME::operator + (TIME &t)
{
 return SecToHMS( CountSec(this) + CountSec(&t) );
}
 
// пример использования класса TIME
void main()
{
TIME t1; // объявление класса TIME: вызывается конструктор
        // без аргументов
TIME t3(10,20); // объявление класса TIME: вызывается конструктор
        // с аргументами, секунды по уолчанию == 0
TIME t4(5,15,30),t5(5,16,31); // объявление 2-х классов TIME:
        // вызываются конструкторы с аргументами
TIME *t2=new TIME; // объявление указателя на класс TIME и
        // отведение памяти под класс, после отведения памяти
        // вызывается конструктор без аргументов
TIME *t6; // объявление указателя на класс TIME
 
  t6=new TIME(23,5,18); // отведение памяти под класс,
          // после отведения памяти
          // вызывается конструктор с аргументами
  // проверка отведения памяти под класс, на который указывает t6
  if(t6==NULL)
  {
    cerr<<"Ошибка выделения памяти!"<<endl;
    return;
  }
 
  // печать начальных значений переменных
  cout<<endl<<"Начальные значения переменных:"<<endl;
  t1.Print(); t2->Print(); // напечатает системное время
  t3.Print();              // напечатает 10:20:0
  t4.Print();              // напечатает 5:15:30
  t5.Print();              // напечатает 5:16:31
  t6->Print();             // напечатает 23:5:18
 
  // арифметические действия с переменными
  t1=t5-t4;
  cout<<"t1=t5-t4 : "; t1.Print();
  *t2=t3+t4;
  cout<<"t2=t3+t4 : "; t2->Print();
  *t6-=t3;
  cout<<"t6-=t3 : "; t6->Print();
  t5+=*t2;
  cout<<"t5+=t2 : "; t5.Print();
  *t6+=42L;
  cout<<"t6+=42 : "; t6->Print();
  t5-=1L;
  cout<<"t5-=1 : "; t5.Print();
 
  // ввод значений переменных пользователем
  cout<<"Введите время"<<endl;
  t1.Input();  t1.Print();
  t2->AssignTime(12,0); // присвоение времени - полдень
  t2->Print();
 
  // логические операции
  if(t1==*t2)
    cout<<"Введенное время - полдень."<<endl;
  else if(t1>*t2)
    cout<<"Введенное время больше полудня."<<endl;
  else
    cout<<"Введенное время меньше полудня."<<endl;
  t3.AssignSystemTime(); // присвоение времени равного
                         // текущему системному времени
  cout<<"Текущее время в системе:";
  t3.Print();
  if(t3>t1)
 cout<<"Введенное время меньше текущего."<<endl;
  else if(t3<t1)
    cout<<"Введенное время больше текущего."<<endl;
  else
    cout<<"Введенное время равно текущему."<<endl;
 
  // печать количества часов
  cout<<"Количество часов текущего времени : "<<t3.GetHour();
 
  delete t2;  // освобождение памяти
  delete t6;
}