#include "stdafx.h"
#include <iostream>
#include <string>
#include <deque>
#include <fstream>
#include <conio.h>

struct book
{
public:
    std::string surname;
    std::string name;
    std::string title;
    std::string discipline;    
    int page_num;
    int chap_num;
    int pub_year;
    book():surname("N/A"),name("N/A"),title("N/A"),discipline("N/A"),page_num( 0 ),chap_num( 0 ),pub_year( 1980 ){}
    book(std::string _surname,std::string _name,std::string _title, std::string _discipline, int _page_num, int _chap_num, int _pub_year):surname(_surname),name(_name),title(_title),discipline(_discipline),page_num(_page_num),chap_num(_chap_num),pub_year(_pub_year){}
};

class manager
{
private:
    std::deque<book*> m_BookBase; 
    std::string m_path;
    bool m_isСhanged;
public:
    void display_all()const;
    void display_spec()const;
    void add();
    void open();
    void save();
    void save_as();    
    const bool are_changes()const;
    manager();
    ~manager();
};
//////////////////////////////////////
///Отобразить все записи
void manager::display_all()const
{
    //Выводим на экран
    for (int i= 0 ;i<m_BookBase.size();++i)
    {
        std::cout << "\n--------------------------------\n";
        std::cout << "Position: " << i << std::endl;
        std::cout << "Name: " << m_BookBase[i]->name << std::endl;
        std::cout << "Surname: " << m_BookBase[i]->surname << std::endl;
        std::cout << "Title: " << m_BookBase[i]->title << std::endl;
        std::cout << "Discipline: " << m_BookBase[i]->discipline << std::endl;
        std::cout << "Page number: " << m_BookBase[i]->page_num << std::endl;
        std::cout << "Chapter number: " << m_BookBase[i]->chap_num << std::endl;
        std::cout << "Publishment`s year: " << m_BookBase[i]->pub_year << std::endl;
        std::cout << "--------------------------------";
    }
}
//////////////////////////////////////
///Отобразить записи с заданной дисциплиной
void manager::display_spec()const
{
    bool flag=false;//Флаг c заданной дисциплиной
    std::string discipline;
    std::cout << "Enter discipline: ";
    std::cin >> discipline;
    for (int i= 0 ;i<m_BookBase.size();++i)
    {
        if (std::strcmp(m_BookBase[i]->discipline.c_str(),discipline.c_str())) continue;
        std::cout << "\n--------------------------------\n";
        std::cout << "Position: " << i << std::endl;
        std::cout << "Surname: " << m_BookBase[i]->surname << std::endl;
        std::cout << "Title: " << m_BookBase[i]->title << std::endl;
        std::cout << "Page number: " << m_BookBase[i]->page_num << std::endl;
        std::cout << "--------------------------------";
        flag=true;
    }
    if (flag==false) std::cout << "The are no books of such a discipline";
}
//////////////////////////////////////
///Вставка записи
void manager::add()
{
    std::string surname;
    std::string name;
    std::string title;
    std::string discipline;    
    int page_num;
    int chap_num;
    int pub_year;
    std::cout << "--------------------------------\n";
    std::cout << "Enter name: ";
    std::getline(std::cin,name);
    std::cout << "Enter surname: ";
    std::getline(std::cin,surname);
    std::cout << "Enter title: ";
    std::getline(std::cin,title);
    std::cout << "Enter Discipline: ";
    std::getline(std::cin,discipline);
    std::cout << "Enter page number: ";
    std::cin >> page_num;
    std::cout << "Enter chapters number: ";
    std::cin >> chap_num;
    std::cout << "Enter a year of publishment: ";
    std::cin >> pub_year;
    m_BookBase.push_back(new book(surname,name,title,discipline,page_num,chap_num,pub_year));
    _flushall();
}
//////////////////////////////////////
///Сохранение изменений
void manager::save()
{
    std::ofstream file;
    if (m_path.size()== 0 )//Если данный проект не связан с каким-то файлом (мы не открывали файла и еще не сохраняли
    {
        std::cout << "Enter path to file: ";
        _flushall();
        std::getline(std::cin,m_path);
    }
    file.open(m_path.c_str(),std::ios::binary);
    if(!file)
    {
        throw ("Could not open path");
    }
    std::cout << "Saving base ";
    for (int i= 0 ;i<static_cast<int>(m_BookBase.size());i++)
    {
        std::cout << ".";
        //Сохраняем размер и строку поля Name
        int tmp_size = m_BookBase[i]->name.size();
        file.write(reinterpret_cast<char*>(&tmp_size),sizeof(int));
        file.write(m_BookBase[i]->name.c_str(),sizeof(char)*tmp_size);
        //Сохраняем размер и строку поля Surname
        tmp_size = m_BookBase[i]->surname.size();
        file.write(reinterpret_cast<char*>(&tmp_size),sizeof(int));
        file.write(m_BookBase[i]->surname.c_str(),sizeof(char)*tmp_size);
        //Сохраняем размер и строку поля Title
        tmp_size = m_BookBase[i]->title.size();
        file.write(reinterpret_cast<char*>(&tmp_size),sizeof(int));
        file.write(m_BookBase[i]->title.c_str(),sizeof(char)*tmp_size);
        //Сохраняем размер и строку поля Discipline
        tmp_size = m_BookBase[i]->discipline.size();
        file.write(reinterpret_cast<char*>(&tmp_size),sizeof(int));
        file.write(m_BookBase[i]->discipline.c_str(),sizeof(char)*tmp_size);
        //Сохраняем поля Page Number, Chapter Number, Publishment year
        file.write(reinterpret_cast<char*>(&m_BookBase[i]->page_num),sizeof(int));
        file.write(reinterpret_cast<char*>(&m_BookBase[i]->chap_num),sizeof(int));
        file.write(reinterpret_cast<char*>(&m_BookBase[i]->pub_year),sizeof(int));
    }
    file.close();
    m_isСhanged=false;//Теперь в нашем файле тоже самое, что и было в памяти, следовательно изменений нет
    std::cout << " Ok\n";
}
//////////////////////////////////////
///Сохранить как
void manager::save_as()
{
    std::cout << "Enter path to file: ";
    _flushall();
    std::getline(std::cin,m_path);
    save();
}
//////////////////////////////////////
///Открытие файла
void manager::open()
{
    std::fstream file;
    if (m_isСhanged==true) //Проверяем есть ли что-нибудь в памяти (изменены данные ранее открытого файла или просто в памяти уже присуствует какая-либо база
    {
        std::cout << "Do you want to save changes before closing file? y/n";
        char choice;
        std::cin >> choice;
        switch (choice)
        {
        case 'y':save();
            break;
        case 'Y':save();
            break;
        case 'n':break;
        case 'N':break;
        default:std::cout << "Incorrect choice\n";
            break;
        }
    }
    //Открываем файл
    std::cout << "Enter path to file: ";
    _flushall();
    std::getline(std::cin,m_path);
    std::cout << m_path << std::endl;
    file.open(m_path.c_str(),std::ios::binary | std::ios::in);
    std::deque<book*> temp_arr;
    if (!file)
    {
        file.clear();
        throw ("Could not open file");
    }
    std::cout << "Reading file ";
    //Чтение записей
    while (!file.eof())
    {
        std::cout << ".";
        std::string surname,name,title,discipline;    
        int size_surname,size_name,size_title,size_discipline;
        int page_num;
        int chap_num;
        int pub_year;
        //Читаем размер поля Name и пишим данные в переменную name
        file.read(reinterpret_cast<char*>(&size_name),sizeof(int));
        name.resize(size_name);
        file.read(&name[ 0 ],size_name);
        //Читаем размер поля Surname и пишим данные в переменную surname
        file.read(reinterpret_cast<char*>(&size_surname),sizeof(int));
        surname.resize(size_surname);
        file.read(&surname[ 0 ],size_surname);
        //Читаем размер поля Title и пишим данные в переменную title
        file.read(reinterpret_cast<char*>(&size_title),sizeof(int));
        title.resize(size_title);
        file.read(&title[ 0 ],size_title);
        //Читаем размер поля Discipline и пишим данные в переменную discipline
        file.read(reinterpret_cast<char*>(&size_discipline),sizeof(int));
        discipline.resize(size_discipline);
        file.read(&discipline[ 0 ],size_discipline);
        //Читаем данные поля Page Number, Chapter Number, Publishment Year и заносим в соотвествующие переменные
        file.read(reinterpret_cast<char*>(&page_num),sizeof(int));
        file.read(reinterpret_cast<char*>(&chap_num),sizeof(int)); 
        file.read(reinterpret_cast<char*>(&pub_year),sizeof(int)); 
        if(file.eof()) 
        {
            file.clear();
            break;        
        }    
        temp_arr.push_back(new book(surname,name,title,discipline,page_num,chap_num,pub_year));
    }
    file.close();
    if (m_BookBase.size()!= 0 )//Если основная база непуста - чистим ее
    {
        for (std::deque<book*>::iterator iter=m_BookBase.begin();iter!=m_BookBase.end();++iter)
        {
            delete *iter;
        }
        m_BookBase.clear();
    }
    m_BookBase.resize(static_cast<int>(temp_arr.size()));
    std::copy(temp_arr.begin(),temp_arr.end(),m_BookBase.begin());
    std::cout << " Ok\n";
}
//////////////////////////////////////
///Есть ли изменения
const bool manager::are_changes()const
{
    return m_isСhanged;
}
////Кострукторы
manager::manager():m_isСhanged(false){}
////Деструктор
manager::~manager()
{
    try
    {
        for(int i= 0 ;i<m_BookBase.size();++i) delete m_BookBase[i];
        m_BookBase.clear();
    }
    catch(...)
    {
        std::cout << "An error occuried while killing a book";
    }
}



int main(int argc, char* argv[])
{
    manager man;
    char choice;
    do
    {
        std::cout << "\nChoose action:\n"
             << "'a' - add book\n" 
             << "'e' - display book with a specified discipline\n"
             << "'d' - display all books\n"    
             << "'o' - open file\n"
             << "'s' - save changes\n" 
             << "'p' - save as\n"
             << "'q' - quit\n";    
        choice=_getch();
        try
        {
            switch(choice)
            {
            case 'a':man.add();
                break;
            case 'e':man.display_spec();
                break;
            case 'o':man.open();
                break;
            case 'd':man.display_all();
                break;
            case 's':man.save();
                break;
            case 'p':man.save_as();
                break;
            case 'q':break;
            default:std::cout << "Incorrect choice\n";
                break;
            }
        }
        catch (char* msg)
        {
            std::cout << msg;
        }
        catch (...)
        {
            std::cout << "Unhalded exception";
        }
    }while(choice!='q');
    if (man.are_changes()==true)
    {
        char choice;
        do
        {
            std::cout << "Yo have made changes to file. Do you want to save them? y/n ";
            std::cin >> choice;
            if (choice=='y' || choice=='Y')
            {
                man.save();
                break;
            }
        }while(choice!='n' && choice!='N');
    }
    std::cin.get();
    return  0 ;
}

#include <iostream>

#include <string>

#include <deque>

#include <fstream>




using std::cin;

using std::cout;

using std::endl;




namespace BookEditor

{

       using std::string;

       using std::fstream;

       using std::ofstream;

       using std::ifstream;

       using std::copy;

       using std::deque;

       using std::ios;




       struct book

       {

               string m_surname;

               string m_name;

               string m_title;

               string m_discipline;    

               int m_page_num;

               int m_chap_num;

               int m_pub_year;

               book():m_surname("N/A"),m_name("N/A"),m_title("N/A"),m_discipline("N/A"),m_page_num( 0 ),m_chap_num( 0 ),m_pub_year( 1980 ){}

               book(const string& surname, const string& name, const string& title, const string& discipline, int page_num, int chap_num, int pub_year):m_surname(surname),m_name(name),m_title(title),m_discipline(discipline),m_page_num(page_num),m_chap_num(chap_num),m_pub_year(pub_year){}

       };




       class driver

       {

               friend class manager;

               //Открыть

               void open(const string& path, deque<book*>& BookBase);

               //Сохранить

               void save(const string& path, deque<book*>& BookBase);

               driver(){};

               ~driver(){};

       };

       //////////////////////////////////////

       ///Сохранение изменений

       void driver::save(const string& path, deque<book*>& BookBase)

       {

               ofstream file(path.c_str(), ios::binary);

               if(!file.is_open()) throw ("Could not open path");

               for (int i =  0 ; i < BookBase.size(); i++)

               {

                       cout << ".";

                       //Сохраняем размер и строку поля Name

                       int tmp_size = BookBase[i]->m_name.size();

                       file.write(reinterpret_cast<char*>(&tmp_size),sizeof(int));

                       file.write(BookBase[i]->m_name.c_str(),sizeof(char)*tmp_size);

                       //Сохраняем размер и строку поля Surname

                       tmp_size = BookBase[i]->m_surname.size();

                       file.write(reinterpret_cast<char*>(&tmp_size),sizeof(int));

                       file.write(BookBase[i]->m_surname.c_str(),sizeof(char)*tmp_size);

                       //Сохраняем размер и строку поля Title

                       tmp_size = BookBase[i]->m_title.size();

                       file.write(reinterpret_cast<char*>(&tmp_size),sizeof(int));

                       file.write(BookBase[i]->m_title.c_str(),sizeof(char)*tmp_size);

                       //Сохраняем размер и строку поля Discipline

                       tmp_size = BookBase[i]->m_discipline.size();

                       file.write(reinterpret_cast<char*>(&tmp_size),sizeof(int));

                       file.write(BookBase[i]->m_discipline.c_str(),sizeof(char)*tmp_size);

                       //Сохраняем поля Page Number, Chapter Number, Publishment year

                       file.write(reinterpret_cast<char*>(&BookBase[i]->m_page_num),sizeof(int));

                       file.write(reinterpret_cast<char*>(&BookBase[i]->m_chap_num),sizeof(int));

                       file.write(reinterpret_cast<char*>(&BookBase[i]->m_pub_year),sizeof(int));

               }

               file.close();

       }

       //////////////////////////////////////

       ///Открытие файла

       void driver::open(const string& path, deque<book*>& BookBase)

       {

               ifstream file(path.c_str(),ios::binary);

               std::deque<book*> temp_arr; //Сначала загрузим данные во временную базу и если все пройдет хорошо - запишем в основную

               if (!file.is_open())

               {

                       file.clear();

                       throw ("Could not open file");

               }

               //Чтение записей

               while (!file.eof())

               {

                       cout << ".";

                       string surname,name,title,discipline;    

                       int size_surname,size_name,size_title,size_discipline;

                       int page_num, chap_num, pub_year;

                       //Читаем размер поля Name и пишим данные в переменную name

                       file.read(reinterpret_cast<char*>(&size_name),sizeof(int));

                       name.resize(size_name);

                       file.read(&name[ 0 ],size_name);

                       //Читаем размер поля Surname и пишим данные в переменную surname

                       file.read(reinterpret_cast<char*>(&size_surname),sizeof(int));

                       surname.resize(size_surname);

                       file.read(&surname[ 0 ],size_surname);

                       //Читаем размер поля Title и пишим данные в переменную title

                       file.read(reinterpret_cast<char*>(&size_title),sizeof(int));

                       title.resize(size_title);

                       file.read(&title[ 0 ],size_title);

                       //Читаем размер поля Discipline и пишим данные в переменную discipline

                       file.read(reinterpret_cast<char*>(&size_discipline),sizeof(int));

                       discipline.resize(size_discipline);

                       file.read(&discipline[ 0 ],size_discipline);

                       //Читаем данные поля Page Number, Chapter Number, Publishment Year и заносим в соотвествующие переменные

                       file.read(reinterpret_cast<char*>(&page_num),sizeof(int));

                       file.read(reinterpret_cast<char*>(&chap_num),sizeof(int)); 

                       file.read(reinterpret_cast<char*>(&pub_year),sizeof(int)); 

                       if(file.eof()) 

                       {

                               file.clear();

                               break;        

                       }    

                       temp_arr.push_back(new book(surname,name,title,discipline,page_num,chap_num,pub_year));

               }

               file.close();

               if (BookBase.size() !=  0 )//Если основная база непуста - чистим ее

               {

                       for (int i =  0 ; i < BookBase.size(); ++i)

                               delete BookBase[i];

                       BookBase.clear();

               }

               BookBase.resize(temp_arr.size());

               copy(temp_arr.begin(),temp_arr.end(),BookBase.begin());

       }




       class manager

       {

       private:

               deque<book*> m_BookBase; 

               string m_path;

               driver m_driver;

               bool m_are_changes;

       public:

               void add();

               void display_all() const;

               void display_spec() const;

               void open();

               void save();

               void save_as();

               const bool are_changes()const

               {

                       return m_are_changes;

               }

               manager():m_are_changes(false){}

               ~manager()

               {

                       try

                       {

                               for (int i =  0 ; i < m_BookBase..size(); ++i)

                                       delete m_BookBase[i];

                               m_BookBase.clear();

                       }

                       catch(...)

                       {

                               cout << "An error";

                       }

               }

       };

       //////////////////////////////////////

       ///Вставка записи

       void manager::add()

       {

               _flushall();

               string surname, name, title, discipline;    

               int page_num, chap_num, pub_year;

               cout << "--------------------------------\n";

               cout << "Enter name: ";

               getline(cin,name);

               cout << "Enter surname: ";

               getline(cin,surname);

               cout << "Enter title: ";

               getline(cin,title);

               cout << "Enter Discipline: ";

               getline(cin,discipline);

               cout << "Enter page number: ";

               cin >> page_num;

               cout << "Enter chapters number: ";

               cin >> chap_num;

               cout << "Enter a year of publishment: ";

               cin >> pub_year;

               m_BookBase.push_back(new book(surname,name,title,discipline,page_num,chap_num,pub_year));

               m_are_changes = true;

               _flushall();

       }

       //////////////////////////////////////

       ///Отобразить все записи

       void manager::display_all() const

       {

               //Выводим на экран

               for (int i =  0 ; i < m_BookBase.size(); ++i)

               {

                       cout << "\n--------------------------------\n";

                       cout << "Position: " << i << endl;

                       cout << "Name: " << m_BookBase[i]->m_name << endl;

                       cout << "Surname: " << m_BookBase[i]->m_surname << endl;

                       cout << "Title: " << m_BookBase[i]->m_title << endl;

                       cout << "Discipline: " << m_BookBase[i]->m_discipline << endl;

                       cout << "Page number: " << m_BookBase[i]->m_page_num << endl;

                       cout << "Chapter number: " << m_BookBase[i]->m_chap_num << endl;

                       cout << "Publishment`s year: " << m_BookBase[i]->m_pub_year << endl;

                       cout << "--------------------------------";

               }

       }

       //////////////////////////////////////

       ///Отобразить записи с заданной дисциплиной

       void manager::display_spec() const

       {

               bool flag = false;//Флаг c заданной дисциплиной

               string discipline;

               cout << "Enter discipline: ";

               cin >> discipline;

               for (int i =  0 ;i < m_BookBase.size(); ++i)

               {

                       if (m_BookBase[i]->m_discipline != discipline) continue;

                       cout << "\n--------------------------------\n";

                       cout << "Position: " << i << endl;

                       cout << "Surname: " << m_BookBase[i]->m_surname << endl;

                       cout << "Title: " << m_BookBase[i]->m_title << endl;

                       cout << "Page number: " << m_BookBase[i]->m_page_num << endl;

                       cout << "--------------------------------";

                       flag = true;

               }

               if (flag == false) cout << "The are no books of such a discipline";

       }

       //////////////////////////////////////

       ///Загрузка базы из файла

       void manager::open()

       {

               _flushall();

               cout << "Enter path to file: ";

               getline(cin, m_path);

               m_driver.open(m_path, m_BookBase);

               cout << " Ok\n";

       }

       //////////////////////////////////////

       ///Сохранение базы в текущий файл

       void manager::save()

       {

               m_driver.save(m_path, m_BookBase);

               m_are_changes = false;

               cout << " Ok\n";

       }

       //////////////////////////////////////

       ///Сохранение базы в иной файл

       void manager::save_as()

       {

               if (m_are_changes == true) //Проверяем есть ли что-нибудь в памяти (изменены данные ранее открытого файла или просто в памяти уже присуствует какая-либо база

               {

                       cout << "Do you want to save changes before closing file? y/n";

                       char choice;

                       cin >> choice;

                       switch (choice)

                       {

                       case 'y':save();

                               break;

                       case 'Y':save();

                               break;

                       case 'n':break;

                       case 'N':break;

                       default:cout << "Incorrect choice\n";

                               break;

                       }

               }

               //Открываем файл

               cout << "Enter path to file: ";

               _flushall();

               getline(cin,m_path);

               save();

       }

}




using BookEditor::manager;







int main(int argc, char* argv[])

{

       manager man;

    char choice = '\0';

    do

    {

               choice = '\0';

        cout << "\nChoose action:\n"

             << "'a' - add book\n" 

             << "'e' - display book with a specified discipline\n"

             << "'d' - display all books\n"    

             << "'o' - open file\n"

             << "'s' - save changes\n" 

             << "'p' - save as\n"

             << "'q' - quit\n";    

        cin >> choice;

        try

        {

            switch(choice)

            {

            case 'a':man.add();

                break;

                       case 'e':man.display_spec();

                break;

            case 'o':man.open();

                break;

                       case 'd':man.display_all( );

                break;

            case 's':man.save();

                break;

            case 'p':man.save_as();

                break;

            case 'q':break;

            default:cout << "Incorrect choice\n";

                break;

            }

        }

        catch (char* msg)

        {

                       cout << msg;

               }

        catch (...) 

        {

                       cout << "Unhalded exception";

        }

    }while(choice != 'q');

    if (man.are_changes() == true)

    {

        char choice;

        do

        {

            cout << "Yo have made changes to file. Do you want to save them? y/n ";

            cin >> choice;

            if (choice == 'y' || choice == 'Y')

            {

                man.save();

                break;

            }

        }while(choice != 'n' && choice != 'N');

    }

       cin.sync();

    cin.get();

    return  0 ;

}

#include <iostream.h>
#include <fstream.h>
#include <string.h>
#include <conio.h>
#include <iomanip.h>
#include <stdlib.h>
#define FIO  20 
#define name  20 
#define PUBLISHERS  20 
#define YEAR  4 
#define PAGES   6 
#define CHAPTER  6 
 
//--------------------------------------------------------------------------------------
struct  book
{
  char fio[ 25 ];
  char name_book [ 25 ];
  char publishers[ 25 ];
  int year_publishers;
  int pages;
  int chapter;
  char discipline[ 17 ];
};
//----------------------------------------------------------------------------------------

// прототипы функций
void sozdanie();
void prosmotr();
void vibor();
void tabl(); 
//-----------------------------------------------------------------------------------------

// Опеpация-функция  ввода с клавиатуpы
istream &operator >> (istream &in, book &x)
{
  cout<<"\nФамилия и инициалы:";
  in.seekg( 0 ,ios::end);
  in.get(x.fio,FIO- 1 ,'\n');
  cout<<" \nНазвание книги:";
  in.seekg( 0 ,ios::end);
  in.get(x.name_book,name- 1 ,'\n');
  cout<<"\nИздательство:";
  in.seekg( 0 ,ios::end);
  in.get(x.publishers,PUBLISHERS- 1 ,'\n');
  cout<<"\nГод издания:";
  in.seekg( 0 ,ios::end);
  in >>x.year_publishers,YEAR- 1 ;
  cout<<"\nКоличество страниц:";
  in.seekg( 0 ,ios::end);
  in >>x.pages, PAGES- 1 ;
  cout<<"\nКоличество глав в книге:";
  in.seekg( 0 ,ios::end);
  in>>x.chapter, CHAPTER- 1 ;
  cout<<" \nНазвание дисциплины:";
  in.seekg( 0 ,ios::end);
  in >>x.discipline;
  return in;
}
//------------------------------------------------------------------------
 
 // Опеpация-функция  вывода  на дисплей
ostream &operator << (ostream &out, book x)
{
  out.setf (ios::left);  // установка флага равнения по левому краю
  out << "|" << setw( 17 )  << x.fio << "|" << setw( 15 ) << x.name_book 
      << "|"<< setw( 11 )<< x.publishers   << "|" << x.year_publishers
      << "|" << setw( 4 )<< x.pages << "|"<< setw( 4 )<< x.chapter 
      << "|" <<setw( 16 )<< x.discipline << "|\n";
  return out;
}

// Опеpация-функция  чтения из файла
ifstream &operator >> (ifstream &in, book &x)
{
  in.getline(x.fio,FIO,'\n');
  in.getline(x.name_book, name,'\n');
  in.getline(x.publishers,PUBLISHERS,'\n');
  in>>x.year_publishers,YEAR;
  in>>x.pages, PAGES- 1 ;
  in>>x.chapter, CHAPTER- 1 ;
  in >>x.discipline;
  in.seekg (2L, ios::cur);
  return in;
}
 // Опеpация-функция  записи в файл
ofstream &operator << (ofstream &out, book &x)
{
  out << x.fio << endl
      << x.name_book << endl
      << x.publishers << endl
      << x.year_publishers << endl
      << x.pages << endl
      << x.chapter << endl
      << x.discipline << endl;
  return out;
}


//------------------------------------------------------------------------

 void main(void)
{
  char c;
  while ( 1 )
  {
    cout << endl << "1. Создание файла";
    cout << endl << "2. Просмотр содержимого";
    cout << endl << "3. Вывод на экран информации о фамилии автора," << endl;
    cout <<"   название книги и количество страниц";
    cout << endl << "4. Выход";
    cout << endl << "Ваш выбор -> ";
    cin.seekg( 0 ,ios::end);
    c = cin.get();
         switch(c)
    {                                                                                                           
      case '1':
	sozdanie();
	break;

      case '2':
	prosmotr();
	break;

      case '3':
	vibor();
	break;

      case '4':
	return;




      default:
	cout << "Вводите только цифры от 1 до 4" << endl;
    }
  }
}

 
// определение функции вывода на экран шапки таблицы
void tabl()
{
  cout << "-------------------------------------------------------------------------------\n";
  cout << "|      Ф.И.О.        |Название книги|   Изд-во  | Год|Стр.|Глав|    Дисциплина  |\n";
  cout << "|----------------|----------------|---- -----|----|-----|----|----------------|\n";
}



// определение функции создания файла
void sozdanie()
{
  char c;
  ofstream ff; // создание потока ff для записи в файл
  book s;
  ff.open( "bok.txt" );
	       // открытие файла book.txt и связывание его
	       // c потоком ff
  if ( !ff)  // проверка открытия файла
    {
      cerr << "Ошибка открытия файла bok.txt для записи\n";
      exit( 1 );     // аварийный выход
    }

    // Цикл записи элементов в файл
  do
  {
    cin >> s;    // обращение к операции-функции ввода с клавиатуpы
    ff  << s;    // обращение к операции-функции записи в файл
    cout<<"\nПpодолжить ввод?(Y/N или Д/H)";
    cin.seekg(0L, ios::end);
    c = cin.get();
  }
  while ( c == 'y' || c == 'Y' || c == 'д' || c == 'Д');
  ff.close();       // закpытие файла
}


    // определение функции вывода всей информации на экран
void prosmotr()
{
  ifstream finp; // создание потока finp для чтения из файла
  book s;
    finp.open( "bok.txt", ios::in );
		 // открытие файла bok.txt и связывание его
		 // с потоком finp

  if ( !finp )  // проверка открытия файла
    {
      cerr << "Ошибка открытия файла bok.txt для чтения\n";
      exit( 1 );     // аварийный выход
    }
  cout << "\nСписок элементов из файла\n";
  tabl();  // вывод на экран шапки таблицы
  while ( finp )
  {
    finp >> s ;   // обращение к операции-функции чтения из файла
    if ( strlen ( s.discipline) <=  0  )
		 // длина первого поля в записи меньше либо равна нулю
      break;     // выход из цикла

    cout << s;    // обращение к операции-функции вывода на экран
  }
  finp.close();      // закpытие файла
  
}

// определение функции вывода на экран информации,
// отвечеющей условию поиска
void vibor()
{
   char discipline[ 15 ];  // для ввода условия поиска
   ifstream fi;    // создание потока fi для чтения из файла
   book b;
   fi.open("bok.txt", ios::in);
		   // открытие файла bok.txt и связывание его
		   // с потоком fi

   if ( !fi )  // проверка открытия файла
    {
      cerr << "Ошибка открытия файла bok.txt для чтения\n";
      exit( 1 );     // аварийный выход
    }

   cout << "Введите название дисциплины:";
   cin.seekg( 0 ,ios::end);
   cin.get(discipline,'\n');
   cout << "Информация о книге\n";
   tabl();  // вывод на экран шапки таблицы  
   while (!fi.eof())
   {
     fi >> b;       // обращение к операции-функции чтения из файла
     if (strcmp(b.discipline,discipline)== 0 )
		    // дисциплины совпали 
       cout << b;   // обращение к операции-функции вывода на экран
   }
   fi.close();
  
}

struct  book
{
  char fio[ 25 ];
  char name_book [ 25 ];
  char publishers[ 25 ];

struct  book
{
  char fio[];
  char name_book [];
  char publishers[];

#include <iostream.h>
#include <fstream.h>
#include <string.h>
#include <conio.h>
#include <iomanip.h>
#include <stdlib.h>
#define FIO  20 
#define name  20 
#define PUBLISHERS  20 
#define YEAR  4 
#define PAGES   6 
#define CHAPTER  6 
#define Discipline   17 
//--------------------------------------------------------------------------------------
struct  book
{
  char fio[FIO];
  char name_book [name];
  char publishers[PUBLISHERS];
  int year_publishers;
  int pages;
  int chapter;
  char discipline[Discipline ];
};

#include <iostream.h>
#include <conio.h>

#include <stdlib.h>