Создание БД "Режим дня": дополнить код

#include "stdafx.h"
#include <fstream>
#include <iostream>
#include <iomanip>
#include<windows.h>     //Для AnsiToOem(s2,s1)
using namespace std;   //Для cin, cout
char s1[256];
char *rus(char *s2)
{AnsiToOem(s2,s1);return s1;}
const int puncts=100;//размер массива структур
const int MAX = 20;//размер поля "Действие"
 
/////////////////////////////////////////////////////////////////
struct regime       //структура базы данных
{
    char act[MAX];  //Поле "Действие"
    short hour;     //Поле "Часы"
    short min;      //Поле "Минуты"
}rg[puncts], reg;
 
/////////////////////////////////////////////////////////////////
//Функция добавления записи. 
void getData()
{
 
    do
    {
        cout<<rus("Ввод данных ")<<endl;
        cout<<rus("\nВведите часы(0 - 23): "); cin>>reg.hour;//Ввод часа 
                                                                  //структуры
        if(reg.hour>23||reg.hour<0)//проверка правильности ввода часов
        {
            cout<<rus("Ошибка!!! Повторите снова!")<<endl;
            continue;
        }
 
        cout<<rus("\nВведите минуты(0 - 59): "); cin>> reg.min;//Ввод минут 
                                                                    //структуры
        if(reg.min>59||reg.min<0)//проверка правильности ввода минут
        {
            cout<<rus("Ошибка!!! Повторите снова!")<<endl;
            continue;
        }
        cin.ignore();//очистить входной поток
        cout<<rus("\nВведите действие: "); cin.get(reg.act,MAX);//Для ввода 
                                                                      //пробелов
 
        cin.ignore();//очистить входной поток
 
    }
    while (reg.hour>23||reg.hour<0||reg.min>59||reg.min<0);//Цикл, пока не будет 
                                                          //введено верное значение
 
}
//////////////////////////////////////////////////////////////////
//Функция сортировки массива структур по времени методом пузырька 
void sortdata(regime rm[puncts])
{
 
    for(int i=0; i<puncts; i++)
    {
        regime tmp;
        // Массив просматривается с конца до
        // позиции i и "легкие элементы всплывают"
        for (int j = puncts - 1; j > i; j--)
        {
            // Если соседние структуры расположены
            // в неправильном порядке, то меняем
            // их местами
            if (rm[j].hour < rm[j - 1].hour)//Сравниваем часы
            {
                tmp=rm[j];      
                rm[j]=rm[j-1];
                rm[j-1]=tmp;
            }
 
    if ((rm[j].hour == rm[j - 1].hour)&&(rm[j].min < rm[j - 1].min))//Сравниваем
                                                                      //минуты
            {
                tmp=rm[j];      
                rm[j]=rm[j-1];
                rm[j-1]=tmp;
 
            }
        }
    }
}
/////////////////////////////////////////////////////////////////
//Функция вывода на экран одной структуры regime
void showData(regime reg)
{
    if(reg.hour<10)//Если час меньше 10,
        cout<<0;//то припишим 0
    cout<<reg.hour<<':';
 
    if(reg.min<10)//Если минуты меньше 10,
        cout<<0;//то припишим 0
    cout<<reg.min<<"  -  " ; cout<<reg.act<<endl;
 
}
 
/////////////////////////////////////////////////////////////////
//Функция вывода на экран данных в чередование один элемент с конца, один сначала
void first_last_display(int cnt)
{
    cout<<"_______________________________________________"<<endl;//Оформление 
                                                                    //таблицы
    cout<<rus("ПОЛЕ   ВРЕМЯ     ДЕЙСТВИЕ")<<endl;
    cout<<"_______________________________________________"<<endl;
 
      for(int i=puncts-cnt, j = puncts-1;i<(puncts-cnt/2), j>=(puncts-cnt/2);i++, j--)
    {
        cout<<"N"<<setw(3)<<(cnt+j+1-puncts)<<" - ";//Вывод номера элемента
        showData(rg[j]);//Вывод очередного элемента с конца
        cout<<"N"<<setw(3)<<(cnt+i+1-puncts)<<" - ";
        showData(rg[i]);//Вывод очередного элемента с начала
    }
 
    if(cnt%2!=0)//Если число полей нечетное, вывести  элемент, расположенный     
                  //посередине
    {
        cout<<"N"<<setw(3)<<(cnt/2+1)<<" - ";
        showData(rg[puncts-cnt/2]);
    }
    cout<<"_______________________________________________"<<endl;
}
/////////////////////////////////////////////////////////////////
//Функция вывода списка дел в заданный промежуток
void interval_display(regime r[])
{
    short h1, h2, m1, m2;//Для ввода времени (h1:m1 - h2:m2)
    int con=0;
    cout<<rus("Введите начальное время интервала ")<<endl;//Приглашение к вводу //временного интервала
    cout<<rus("Введите часы: "); cin>>h1;
    cout<<rus("\nВведите минуты: "); cin>>m1;
    cout<<rus("\nВведите конечное время интервала")<<endl;
    cout<<rus("Введите часы: "); cin>>h2;
    cout<<rus("\nВведите минуты: "); cin>>m2;
    cout<<rus("\nПеречень моих дел в интервале ");
    // вывод интервала в формате ЧЧ:ММ - ЧЧ:ММ
    if(h1<10)//Если час меньше 10,
        cout<<0;//то припишем 0
    cout<<h1<<':';
 
    if(m1<10)//Если час меньше 10,
        cout<<0;//то припишем 0
    cout<<m1<<"  -  " ;
    if(h2<10)
        cout<<0;
    cout<<h2<<':';
    if(m2<10)
        cout<<0;
    cout<<m2<<endl;
    //Если время начала интервала меньше времени конца интервала
    if((h1<h2)||((h1==h2)&&(m1<=m2))) 
    {                               
        for(int i=0;i<puncts;i++)
        {
            if(h1==r[i].hour)
                con++;
            if((h1<=r[i].hour)&&(m1<=r[i].min))
            {
                if(con<1||m1<r[i].min)
                    showData(r[i-1]);//Вывод на экран структуры
 
                while((r[i].hour<h2)||((r[i].hour==h2)&&(r[i].min<m2)))
                {
                    showData(r[i]);//Вывод на экран i-той структуры
                    i++;
                }
 
                i=puncts;
            }
        }
 
    }
 
    //Если время начала интервала больше времени конца интервала
    else 
    {    
        //Вывод на экран всех действий до 24:00                           
        con = 0;
        for(int i=0;i<puncts;i++)
        {
            if(h1==r[i].hour)
                con++;
            if(h1<=r[i].hour)
            {
                if(con<1||m1<r[i].min)
                    showData(r[i-1]);
 
                while(r[i].hour<24)
                {   
                    if((r[i].hour+r[i].min)!=0)//Cтруктуры со временем 
                                                    //00:00 не выводятся
                        showData(r[i]);//Вывод на экран i-той 
                                                      //структуры
                    i++;
                }
 
                i=puncts;
            }
        }
        //Вывод на экран всех действий начиная с 00:01 и до конца интервала 
             //(h2:m2)
        for(int i=0;i<puncts;i++)
        {
 
            while((r[i].hour<h2)||((r[i].hour==h2)&&(m2>r[i].min)))
            {
                if((r[i].hour+r[i].min)!=0)//Cтруктуры со временем 00:00 не 
                                                                          //выводятся
                    showData(r[i]);//Вывод на экран i-той структуры
                i++;
            }
            i=puncts;
 
        }
 
    }
 
 
}
 
//////////////////////////////////////////////////////////
int main()
{
    //Загрузка базы данных из файла "base.txt" в массив структур
    ifstream file;//Создать входной/выходной файл
    file.open("d:\\base.txt", ios::out|ios::in|ios::binary);
    if(!file)//Определение ошибки ввода/вывода
    {cerr<<rus("Невозможно открыть файл!\n"); exit(1);}
    file.seekg(0);//Установить указатель на начало файла
    file.read(reinterpret_cast<char*>(rg), sizeof(rg));//Присвоение данных массиву
                                                         //структур
    file.close();//Закрытие файла
    int count=0;//Счетчик записей
      //Подсчет непустых записей базы данных
    for(int i=0;i<puncts;i++)
        if((rg[i].hour+rg[i].min)!=0)
            count++;
    cout<<rus("В базе ")<<count; cout<<rus(" пунктов.\n");
 
    char ch;//Для y/n
    while(true)
    {
//Вывод списка вариантов действий
    cout<<rus("\n\n'a' - Добавление записи.\n 'd'-Удаление записи")<<endl;//Варианты действий
        cout<<rus("'c' - изменение записи\n 'i' - вывод действий за промежуток времени")<<endl;
        cout<<rus("'e' - вывод данных  в чередование один элемент с конца, один сначала.")<<endl;
        cout<<rus("'w'- вывод всех данных. \n 'x' - выход из программы.")<<endl;
        cin>>ch;
 
        switch(ch)//Выбор действия из предложенных выше вариантов
        {
//Добавление записи----------------------------------------------------------------
        case 'a':           
            {
                char cr=0;
                for(int i=0; (i<puncts)&&(cr!='n'); i++)
                {
                    if((rg[i].hour+rg[i].min)==0)//Если поле  пустое
                    {
                        getData();//Получение записи от пользователя
                        rg[i]=reg;//Присвоение введенного действия i-
                                                //той структуре
                        cout<<rus("\nЖелаете продолжить(y/n)? ");
                                       cin>>cr; 
                        ++count;//Счетчик непустых структур
                    }
                    if(count==puncts)
                        cout<<rus("База данных заполнена! Дальнейшее добавление записей невозможно!")<<endl;
                    if(count>puncts)
                        cout<<rus("База данных переполнена!")<<endl;
                }
 
            } break;
//Удаление записи-----------------------------------------------------------------
        case 'd': 
            {
                regime zer;//Создание нулевой структуры
                zer.hour=0;
                zer.min=0;
                short number;
                cout<<rus("Введите номер удаляемого пункта: "); 
                          cin>>number;
                rg[puncts-count+number-1] = zer;//Присвоение удаляемой 
                                          //структуре значения нулевой структуры
                cout<<rus("\nПункт № "); cout<<number<<rus(" удален!\n");
                --count;//Счетчик непустых структур
            }break;
//Изменение записи----------------------------------------------------------------
        case 'c': 
            {
                short n;
                cout<<rus("Введите номер изменяемого пункта: "); cin>>n;
                getData();//Ввод пользователем записи
                rg[puncts-count+n-1]=reg;//Присвоение изменяемой структуре
                                                  //значения новой структуры
            } break;
//Вывод действий в заданном интервале--------------------------------------------
        case 'i':          
            interval_display(rg); break;
//вывод данных в чередование один элемент с конца, один сначала-----------------
        case 'e':
            {
                sortdata(rg);//Упорядочить массив структур по времени
                first_last_display(count);
            } break;
//упорядоченный вывод всех данных-----------------------------------------------
        case 'w':         
            {
                sortdata(rg);//Упорядочить массив структур по времени
                //Вывод эллементов оформления таблицы
                cout<<"_______________________________________________"<<endl;
                cout<<rus("ПОЛЕ   ВРЕМЯ     ДЕЙСТВИЕ")<<endl;
                cout<<"_______________________________________________"<<endl;
                for(int i=0; i<puncts;i++)
 
                    if ((rg[i].hour+rg[i].min)!=0)//Cтруктуры со 
                                               //временем 00:00 не выводятся
                    {
                        cout<<"N"<<setw(3)<<(count+i+1-puncts)<<" - ";
                        showData(rg[i]);//Вывод i-той структуры
                    }
                    cin.ignore();
                    cout<<"_______________________________________________"<<endl;
            } break;
//Запись данных в файл с последующим выходом -------------------------------------
        case 'x':           
            {
                sortdata(rg);//Упорядочить массив структур по времени
                ofstream ofile;//Создать входной/выходной файл                
                ofile.open("d:\\base.txt", ios::in|ios::out|ios::binary);
                if(!ofile)//Определение ошибки ввода/вывода
                {cerr<<rus("Невозможно открыть файл!\n"); exit(1);}
                ofile.seekp(0);//Установка указателя на начало файла                     //Запись массива структур в файл
                ofile.write(reinterpret_cast<char*>(rg), sizeof(rg)); 
                ofile.close();//Закрытие файла         
            }
            exit(0);//Выход из программы
        default: cout<<rus("\nНеизвестная команда!!!");
 
        }//case
 
    }//while
    return 0;
}