Доработать код(Файлы)

#include <iostream>
#include<fstream>
 
using namespace std;
 
/*
запись в файл
*/
 
 
int main()
{
    //ofstream out("outFile.txt");       // если указываем полный путь
    //                                   // к примеру C:\Users\SOTRUDNIK\Desktop\Labirint\Labirint\Labirint
    //                                   // то нужно использовать двойной \\ (двойной бэкслеш)
    //                                   // так как \ (одинарный) сам по себе специальный символ
 
    //out << "Bla bla bla" << endl;
 
    //out.close();
 
    ifstream in("inFile.txt");
 
    const int ARR_SIZE = 100;
    int arr[ARR_SIZE] = { 0 };
 
    int n = 0;
    in >> n;
 
    for (int i = 0; i < n; ++i)
    {
        in >> arr[i];
    }
 
    in.close();
 
    ofstream out("outFile.txt");
 
    for (int i = n - 1; i >= 0; --i)
    {
        out << arr[i] << ' ';
    }
    out << endl;
    out.close();
    
    return 0;
}

#include <iostream>
#include <fstream>
 
 
using namespace std;
 
    
 
int main(int argc, char** argv)
{
    setlocale(LC_ALL, "rus");
 
    ifstream f("file.txt");  // считываение из файла
    //ofstream f("ofile.txt");   // запись в файл
 
    /*for (int i = 0; i < 10; i++)
    {
        int v;
        cin >> v;
        f << v << endl;
         
    }*/
     
    while (true)
    {
        int v;
        f >> v;
        if (!f.eof())
            cout << v << endl;
        else
            break;
    }
    
    
    return 0;
}

#include <iostream>
#include <string>
#include <fstream>
 
using namespace std;
 
 
int main(int argc, char* argv[])
{
    setlocale(LC_ALL, "rus");
 
    string path = "myFile.txt";
 
    ifstream fin;
 
    fin.open(path);
 
    if (!fin.is_open())
    {
        cout << "ќшибка открыти¤ файла!" << endl;
    }
    else
    {
        cout << "‘айл открыт!" << endl;
 
        // посимвольное чтение из файла ------------------
        /*char ch;
        while (fin.get(ch)) // метод get() считывает по-символьно
        {
            cout << ch;
        }*/
 
        //--------------------------------------------------------------------
 
    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        Вот это - халтура:
        while(!load.eof())
        Потому что eof() = false только после первого неудачного чтения. Ставь считывание в само условие.
        скорее всего надо как то так: while (fin.read((char*)&pnt, sizeof(Point)))
    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        
        // "пословное" чтение из файла
        //string str;       
        //while (!fin.eof()) // eof() - конец файла  
        //{
        //  str = "";
        //  fin >> str;
        //  cout << str << endl;
        //}
 
        // построчное считывание из файла
        //string str;
        //while (!fin.eof()) // eof() - конец файла  
        //{
        //  str = "";
        //  getline(fin, str);   // первый параметр фун-ии объект из которого считываем,
        //                       // второй - переменна¤, в которую будем записывать 
        //  cout << str << endl;
        //}
 
 
        // построчное считывание из файла методом getline() объекта fin
        char arr[50];
        while (!fin.eof()) // eof() - конец файла  
        {
            fin.getline(arr, 50); // у объекта fin есть свой getline() но ему нужен массив char
                                  // первым аргументом и точное кол-во считываемых символов вторым аргументом 
            cout << arr << endl;
        }
    }
 
    fin.close();    
        
    return 0;
}

#include <fstream>
#include <vector>
using namespace std;
 
class TextFile
{
private:
    vector<string> Text;// Стек строк для хранения текста
    string FileAddress;// Адрес файла
public:
    bool FileIsEmpty()// Проверка наличия содержимого в файле
 
    {
        if(Text.size() == 0)
 
            return(true);
 
        else
 
            return(false);
 
    }
 
    void ReadFile(string FAdr)// Чтение файла
    {
        FileAddress = FAdr;
        Text.clear();// Чистим стек
        string CurrentString;
        ifstream CurrentFile;// Готовим файл к чтению
        CurrentFile.open(FileAddress.c_str());
        while(getline(CurrentFile, CurrentString))// Считываем строки пока это получается
            Text.push_back(CurrentString);// и добавляем их в стек
        CurrentFile.close();// Закрываем файл
    }
    
    void SaveResult()// Сохранение изменённого текста
    {
        ofstream CurrentFile;// Готовим файл к записи
        CurrentFile.open(FileAddress.c_str());
        for(int StringNum = 0; StringNum < Text.size(); StringNum++)// Пока стек не закончится записываем строки в файл
            CurrentFile << Text[StringNum] << endl;
        CurrentFile.close();// Закрываем файл
    }
 
    void Show()// Демонстрация содержимого стека
 
    {
 
        for(int StringNumber = 0; StringNumber < Text.size(); StringNumber++)
 
            cout << Text[StringNumber] << endl;
 
    }
    int FindStringByBegining(string Pattern)// Поиск первой строки начинающейся в соответствии с шаблоном
    {
        bool Coincidence;// Совпадение с шаблоном
        int StringNumber = 0;
        int CharNum;
        while(StringNumber < Text.size())// Для каждой строки
        {
            Coincidence = true;
            if(not(Pattern.length() > Text[StringNumber].length()))// Строка должна быть не меньше шаблона, чтобы соответствовать ему
            {
                for(CharNum = 0; CharNum < Pattern.length(); CharNum++)// Посимвольное сравнение
                    if(not(Pattern[CharNum] == Text[StringNumber][CharNum]))
                        Coincidence = false;
            }
            else
                Coincidence = false;
            if(not(Coincidence))// если в строке есть несоответствеи шаблону
                StringNumber++;// проверяем следующую
            else// в противном случае
                break;// прекращаем поиск - нам нужна только первая
        }
        return(StringNumber);
    }
    void ReplaceString(int StringNumber, string NewString)// Замена строки
    {
        if(StringNumber >= Text.size())// При попытке вставить строку после текста
            while(Text.size() < StringNumber)// увеличиваем длинну текста до номера вставляемой строки
                Text.push_back("");
        Text[StringNumber] = NewString;// замена строки
    }
    
    // Удаление строки будет выглядеть как-то так:
        void DeleteString(int StringNumber)
    {
        Text.erase(Text.begin() + StringNumber);
    }
};

#include <iostream>
#include <vector>
 
#include <fstream>
#include <string>
#include <sstream>
#include <clocale>
// для кириллицы в консоли
#define NOMINMAX
#include <Windows.h>
 
using namespace std;
 
#pragma region Constants
const char* A_FILE_NAME = "A.txt";
const char* B_FILE_NAME = "B.txt";
 
const unsigned int AUTHOR_COLUMN_WIDTH = 20;
const unsigned int PUBLISHER_COLUMN_WIDTH = 20;
const unsigned int NAME_COLUMN_WIDTH = 20;
const unsigned int AMOUNT_COLUMN_WIDTH = 20;
const unsigned int YEAR_COLUMN_WIDTH = 20;
 
const char DELIM = '|';
#pragma endregion
 
struct Book {
    string author;
    string publisher;
    string name;
    unsigned int amount;
    unsigned int year;
};
 
// убирает хвосты из потока ввода
void cleanInputStream()
{
    cin.clear();
    cin.ignore(numeric_limits<streamsize>::max(), '\n');
}
 
// разбивает строку на части по символу разделителю
vector<string> explode(string const& s, char delim)
{
    vector<string> result;
    istringstream iss(s);
 
    for (string token; getline(iss, token, delim); )
    {
        result.push_back(move(token));
    }
 
    return result;
}
 
// загружает книги из файла
void loadFromFile(const char* filename, vector<Book> &books)
{
    books.clear(); // очищаем список если он не пуст
 
    ifstream ifs(filename);
 
    for (string line; getline(ifs, line); )
    {
        vector<string> parts = explode(line, '|');
 
        Book book;
        book.author = parts[0];
        book.publisher = parts[1];
        book.name = parts[2];
        book.amount = atoi(parts[3].c_str());
        book.year = atoi(parts[4].c_str());
       
        books.push_back(book);
 
        parts.clear();
    }
 
    ifs.close();
}
 
// сохраняет книги в файл
void saveToFile(const char* filename, const vector<Book>& books)
{
    ofstream ofs(filename);
 
    for (auto book : books) {
        ofs << book.author << DELIM << book.publisher << DELIM << book.name << DELIM << book.amount << DELIM << book.year << endl;
    }
 
    ofs.close();
}
 
// вынесен в функции ибо используется в нескольких местах
void printTitle()
{
    cout.setf(ios::left);
    cout.width(AUTHOR_COLUMN_WIDTH);
    cout << "Автор";
    cout.width(PUBLISHER_COLUMN_WIDTH);
    cout << "Издатель";
    cout.width(NAME_COLUMN_WIDTH);
    cout << "Название";
    cout.width(AMOUNT_COLUMN_WIDTH);
    cout << "Количество";
    cout.width(YEAR_COLUMN_WIDTH);
    cout << "Год" << endl << endl;
    cout.unsetf(ios::left);
}
 
// отображает список книг
void printBooks(const vector<Book>& books)
{
    cout.setf(ios::left);
    cout << "\n- Список книг --------------------------------------------------------------------------" << endl;
 
    printTitle();
 
    for (const Book& book : books) {
        cout.width(AUTHOR_COLUMN_WIDTH);
        cout << book.author;
        cout.width(PUBLISHER_COLUMN_WIDTH);
        cout << book.publisher;
        cout.width(NAME_COLUMN_WIDTH);
        cout << book.name;
        cout.width(AMOUNT_COLUMN_WIDTH);
        cout << book.amount;
        cout.width(YEAR_COLUMN_WIDTH);
        cout << book.year << endl;
    }
    cout.unsetf(ios::left);
}
 
// добавляет книгу в список
void addBook(vector<Book>& books)
{
    cleanInputStream();
 
    Book book;
 
    cout << "\n- Добавить книгу -----------------------------------------------------------------------" << endl;
    cout << "Автор: ";
    getline(cin, book.author);
    cout << "Издатель: ";
    getline(cin, book.publisher);
    cout << "Название: ";
    getline(cin, book.name);
    cout << "Количество: ";
    cin >> book.amount;
    cout << "Год: ";
    cin >> book.year;
 
    books.push_back(book);
}
 
// удаляет книгу из списка
void removeBook(vector<Book>& books)
{
    int number;
 
    cout << "\n- Удалить книгу ------------------------------------------------------------------------" << endl;
    cout << "Введите номер книги в списке: ";
    cin >> number;
 
    number--; // индексы начинаются с ноля
 
    if ((number > 0) && (number < books.size())) {
        books.erase(books.begin() + number);
    }
    else {
        cout << "Неверный номер книги!\n";
    }
}
 
// находит книгу по критерию
void findBook(vector<Book>& books)
{
    int choice;
 
    cout << "\n- Найти книгу --------------------------------------------------------------------------" << endl;
    cout << "1) По автору.\n"
         << "2) По издателю.\n"
         << "3) По названию.\n"
         << "4) По году.\n\n"
         << "Вариант: ";
 
    cin >> choice;
    cleanInputStream();
 
    int index = -1;
    
    switch (choice)
    {
    case 1: {       // по автору
        string author;
        cout << "Введите автора: ";
        getline(cin, author);
        for (int i = 0; i < books.size(); i++) {
            if (author == books[i].author) {
                index = i;
                break;
            }
        }
        break; }
    case 2: {       // по автору
        string publisher;
        cout << "Введите издателя: ";
        getline(cin, publisher);
        for (int i = 0; i < books.size(); i++) {
            if (publisher == books[i].publisher) {
                index = i;
                break;
            }
        }
        break; }
    case 3: {
        string name;
        cout << "Введите название: ";
        getline(cin, name);
        for (int i = 0; i < books.size(); i++) {
            if (name == books[i].name) {
                index = i;
                break;
            }
        }
        break; }
    case 4: {
        int year;
        cout << "Введите год: ";
        cin >> year;
        cleanInputStream();
 
        for (int i = 0; i < books.size(); i++) {
            if (year == books[i].year) {
                index = i;
                break;
            }
        }
        break; }
    }
 
    if (index == -1) {
        cout << "\nКнига не найдена!";
    }
    else {
        cout << "\n- Найдено ------------------------------------------------------------------------------" << endl;
        cout << "\nНомер книги по списку " << index + 1 << endl;
 
        printTitle();
 
        cout.setf(ios::left);
        cout.width(AUTHOR_COLUMN_WIDTH);
        cout << books[index].author;
        cout.width(PUBLISHER_COLUMN_WIDTH);
        cout << books[index].publisher;
        cout.width(NAME_COLUMN_WIDTH);
        cout << books[index].name;
        cout.width(AMOUNT_COLUMN_WIDTH);
        cout << books[index].amount;
        cout.width(YEAR_COLUMN_WIDTH);
        cout << books[index].year << endl;
        cout.unsetf(ios::left);
    }
}
 
// выводит меню и возвращает результат
int menu()
{
    int choice = -1;
 
    cout << "\n- Меню ---------------------------------------------------------------------------------" << endl;
    cout << "1) Посмотреть книги.\n"
         << "2) Добавить книгу.\n"
         << "3) Удалить книгу.\n"
         << "4) Найти книгу.\n"
         << "5) Загрузить из файла.\n"
         << "6) Сохранить в файл.\n"
         << "0) Выйти из программы.\n\n"
         << "Вариант: ";
 
    cin >> choice;
 
    return choice;
}
 
// главная функция
int main()
{
    // для кириллицы в консоли ---------------------------------------------
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    // ---------------------------------------------------------------------
    
    // заполнить файл тестовыми данными ------------------------------------
    vector<Book> books;
    books.push_back({ "Доброт", "Дніпро", "Книга", 123, 1995 });
    books.push_back({ "Доброт2", "Дніпро", "Книга2", 173, 1891 });
    books.push_back({ "Робот", "неДніпро", "неКнига", 13, 2001 });
    books.push_back({ "Робот1", "неДніпро1", "неКнига1", 523, 2005 });
    books.push_back({ "Доброт3", "Дніпро", "Книга3", 563, 1993 });
    // ---------------------------------------------------------------------
 
    int choice;
 
    do {
        choice = menu();
 
        switch (choice)
        {
        case 0:     // выход из программы
            cout << "Выходим\n";
            break;
        case 1:     // показать книги из books
            printBooks(books);
            break;
        case 2:     // добавить книгу
            addBook(books);
            break;
        case 3:     // удалить книгу
            removeBook(books);
            break;
        case 4:     // найти книгу по притерию
            findBook(books);
            break;
        case 5:     // загрузить из файла в books
            loadFromFile(A_FILE_NAME, books);
            break;
        case 6:     // сохранить из books в файл
            saveToFile(A_FILE_NAME, books);
            break;
        default:
            cout << "Выбран неверный вариант!\n";
            continue;
            break;
        }
    } while (choice != 0);
 
    return 0;
}