База автосервиса

#include <fstream.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <iomanip.h>
const int l_name = 20, l_model = 20, l_work = 80;
struct Order {
  char name[l_name], model[l_model], work[l_work];
  time_t time;
  float price;
  Order* next;
};
Order* add(Order* end, const Order& order);
Order* first(const Order& order);
Order* get(Order* beg);
int    get_type();
Order  input_Order();
int    menu();
void   print(const Order& order);
void   print_dbase(Order* beg);
int    read_dbase(char* filename, Order** beg, Order** end);
int    write_dbase(char* filename, Order* pv);
 
//----------------------------------------Main function
int main(){
  Order* beg_body = 0, *end_body = 0,
       *beg_engine = 0, *end_engine = 0;
 char *file_body = "order_body.txt",
       *file_engine="order_engine.txt";
 
 
read_dbase(file_body, &beg_body, &end_body);
read_dbase(file_engine, &beg_engine, &end_engine);
while (true) { //Здесь возникает ошибка
  switch (menu()) {
    case 1: if (beg_body) end_body = add(end_body,
      input_Order());
    else {
      beg_body = first(input_Order());
      end_body = beg_body;
     }
     break;
    case 2: if (beg_engine) end_engine = add(end_engine,
      input_Order());
    else {
      beg_engine = first(input_Order());
      end_engine = beg_engine;
    }
    break;
    }
    break;
   case 3:    //Output applications on screen
     switch (get_type()) {
       case 1: beg_body = get(beg_body);     break;
       case 2: beg_engine = get(beg_engine); break;
       }
      break;
   case 4:   //Output applications in file
     switch (get_type()) {
       case 1:print_dbase (beg_body);        break;
       case 2:print_dbase (beg_engine);      break;
     }
     break;
   case 5:
     write_dbase(file_body, beg_body);
     write_dbase(file_engine, beg_engine);
     break;
   case 6:   //exit
     return 0;
   default:
     cout<<"Need to input number from 1 to 5"<<endl;
     break;
    }
   return 0;
   }
 //-------------------------------------Add application
 Order* add(Order* end, const Order& order) {
   Order* pv = new Order;
   *pv = order;   //Copy element
   pv->next = 0;
   end->next = pv;
   end = pv;
   return end;
  }
  //----------------------------------Beginning of queue
  Order* first(const Order& order) {
    Order* beg = new Order;
    *beg = order;             //Copy element
    beg->time = time(0);
    beg->next = 0;
    return beg;
   }
   //--------------------------------Sample queue
   Order* get(Order* beg) {
     if (!beg) {cout<< "Queue is empty"<<endl; return 0;}
     Order*pv = beg;
     print (*beg);
     beg = beg->next;
     delete pv;
     return beg;
   }
   //---------------------------------determination type of works
   int get_type() {
     int type;
     char buf[10];
     do{
       cout << "Input type of work: 1 - body, 2 - engine' " <<
     endl;
       cin >> buf;
       type = atoi(buf);
     }
     while (type != 1 && type !=2);
     cin.get();
     return type;
    }
    //-------------------------------------------Input application
    Order input_Order() {
      Order order; char buf[10];
      cout << "Input name surname " << endl;
      cin.getline(order.name, l_name);
      cout << "Input model a/m "<<endl;
      cin.getline(order.model, l_model);
      cout<<"Input describe of works "<<endl;
      cin.getline(order.work, l_work);
      do {
    cout << "Input price "<< endl;
    cin >> buf;
      }
      while (!(order.price = (float)atof(buf)));
      order.time = time(0);
      return order;
      }
      //--------------------------------------Output menu
      int menu() {
    char buf[10];
    int option;
    do {
       cout << "============================" << endl;
       cout << "1 - add application" << endl;
       cout << "2 - print check" << endl;
       cout << "3 - Output applications on screen" << endl;
       cout << "4 - Output applications on file" << endl;
       cout << "5 - exit" <<endl;
       cin >> buf;
       option = atoi(buf);
      }
      while (!option);
      return option;
     }
 
       //------------------------------------Print check
       void print(const Order& order) {
     tm t = *(localtime(&order.time));
     cout << "Surname: " << setiosflags(ios::left) << setw(l_name) <<
          order.name;
     cout << "Mark a/m: " << order.model << endl;
     cout << "Type of works: " << order.work << endl;
     cout << "Date of addmissin: " <<
         t.tm_mday << '.'<< t.tm_mon + 1 << '.' << 1900 + t.tm_year;
     time_t now = time(0);
     t = *(localtime(&now));
     cout << " Date of performance: "<<
         t.tm_mday << '.' << t.tm_mon + 1 << '.' << 1900 + t.tm_year;
     cout << "\t\t\t\t\tPrice: " << order.price <<endl;
    }
    //----------------------------------Print list of applications
    void print_dbase(Order* beg) {
      if (!beg) { cout << "List is empty"<<endl; return; }
      Order* pv = beg;
      cout << "=============================="<<endl;
       while (pv) {
         print(*pv);
         pv = pv->next;
        }
       }
      //--------------------------------------Reading base from file
      int read_dbase(char* filename, Order** beg, Order** end) {
        ifstream fin(filename, ios::in | ios::nocreate);
        if (!fin) {cout << "Net faila "<<filename<<endl; return 1; }
 
        Order order;
        *beg = 0;
        while (fin.getline(order.name, l_name)) {
          fin.getline(order.model, l_model);
          fin.getline(order.work, l_work);
          fin >> order.time >> order.price;
          fin.get();
          if (*beg) *end = add(*end, order);
          else {*beg = first(order); *end = *beg; }
         }
         return 0;
        }
        //--------------------------------------Output base to file
        int write_dbase(char* filename, Order* pv) {
 
          ofstream fout(filename);
          if (!fout) { cout << "Error during opening of file" << endl; return 1; }
 
          while (pv) {
        fout << pv->name << endl;
        fout << pv->model << endl;
        fout << pv->work << endl;
        fout << pv->time << ' '<<pv->price << endl;
        pv = pv->next;
           }
           return 0;
          }

enum Bool
{
  False,
  True
};
//...
Bool ok = False;