Запись структуры в файл, чтение из файла и удаление (файловый ввод/вывод)

#include "stdafx.h"
#include "Person.h"
#include "my_functions.h"
 
int main()
{
    std::vector<Person> pdata;
 
    int key = 0;
    while (key != EXIT)
    {
        key = promt_user_choose_menu_operation();
        switch (key)
        {
        case ADD:
            std::cout << "\n\tAdding new student to database.\n";
            add_new_entries_to_array(pdata);
            copy_data_to_file(pdata, "Person.txt");
            break;
 
        case SHOW:
            if (!pdata.empty())
            {
                // show( pdata );
                for (const auto & elem : pdata)
                    elem.show();
                std::cout << "\n\n";
            }
            else
                std::cout << "\n\tNo entries were found!\n";
            break;
 
        case DELETE:
            if (!pdata.empty())
            {
                delete_chosen_data_from_array(pdata);
                copy_data_to_file(pdata, "Person.txt");
            }
 
            else
                std::cout << "\n\tNo entries were found!\n";
            break;
 
        case EXIT:
            key = EXIT;
            break;
 
        default:
            std::cout << "\nIt seems like wrong number. Try again.\n";
            break;
 
        } // end switch ( key )
 
    } // end while ( key != EXIT )
 
    return 0;
}

#ifndef PERSON_H
#define PERSON_H
 
#include <string>
 
struct Person
{
    std::string full_name = "Default name";
    std::string address = "Default address";
    std::string phone = "Default phone number";
    unsigned int age = 0;
 
    void show() const;
};
 
#endif // PERSON_H

#include "stdafx.h"
#include "Person.h"
 
void Person::show() const
{
    std::cout
        << "\n"
        << full_name
        << "\n"
        << address
        << "\n"
        << phone
        << "\n"
        << age
        << "\n";
}

#ifndef MY_FUNCTIONS_H
#define MY_FUNCTIONS_H
 
#include "stdafx.h"
#include "Person.h"
 
enum ChosenOperation { ADD = 1, SHOW, DELETE, EXIT };
enum SearchingCriteria { NAME = 1, ADDRESS, PHONE, AGE };
 
int promt_user_choose_menu_operation()
{
    int key = 0;
    std::cout
        << "\nMENU:\n\n"
        << "\t1 - ADD\n"
        << "\t2 - SHOW\n"
        << "\t3 - DELETE\n"
        << "\t4 - EXIT\n"
        << "\nMake your choice (press any key): ";
    std::cin >> key;
    return key;
}
 
void get_data_from_user(std::string & str)
{
    std::getline(std::cin, str);
}
 
void get_data_from_user(unsigned int & uint)
{
    std::cin >> uint;
    while (std::cin.get() != '\n') {}
}
 
size_t promt_user_input_number_of_entries()
{
    size_t number_of_entries = 0;
    std::cout << "Enter number of entries: ";
    std::cin >> number_of_entries;
    while (std::cin.get() != '\n') {}
 
    return number_of_entries;
}
 
template <typename T>
void promt_user_input_data_of_selected_field
(
    const std::string message,
    size_t number_of_entry,
    T & selected_field
)
{
    std::cout << message << " number #" << number_of_entry << ": ";
    get_data_from_user(selected_field);
}
 
template <typename T>
void promt_user_choose_deleting_criteria(T & deleting_criteria)
{
    std::cout << "\n\nSelect deleting criteria: ";
    get_data_from_user(deleting_criteria);
}
 
int promt_user_choose_searching_criteria()
{
    unsigned int searching_criteria = 0;
    std::cout
        << "\n\nSelect searching criteria:\n\n"
        << "\t1 - SEEK ENTRY BY NAME\n"
        << "\t2 - SEEK ENTRY BY ADDRESS\n"
        << "\t3 - SEEK ENTRY BY PHONE\n"
        << "\t4 - SEEK ENTRY BY AGE\n"
        << "\nMake your choice (press any key): ";
    get_data_from_user(searching_criteria);
    return searching_criteria;
}
 
void add_new_entries_to_array(std::vector<Person> & pers)
{
    auto number_of_entries = promt_user_input_number_of_entries();
 
    std::cout << "\n\tEnter all nessesary data of each entry.\n";
    Person p;
    for (unsigned int nth = 1; nth <= number_of_entries; ++nth)
    {
        promt_user_input_data_of_selected_field("Enter full name of student", nth, p.full_name);
        promt_user_input_data_of_selected_field("Enter address of student", nth, p.address);
        promt_user_input_data_of_selected_field("Enter phone number of student", nth, p.phone);
        promt_user_input_data_of_selected_field("Enter age of student", nth, p.age);
        pers.push_back(p);
        std::cout << "\n";
    }
}
 
void copy_data_to_file(const std::vector<Person> & pers, const std::string & filename)
{
    std::ofstream fout(filename.c_str());
    for (size_t i = 0; i < pers.size(); ++i)
    {
        fout
            << pers[i].full_name
            << "|"
            << pers[i].address
            << "|"
            << pers[i].phone
            << "|"
            << pers[i].age
            << "\n";
    }
    fout.close();
}
 
void delete_chosen_data_from_array(std::vector<Person> & pdata)
{
    std::string str_deleting_criteria;
    size_t int_deleting_criteria;
 
    std::cout << "\nNow you can mark entries to deleting.";
    int key = promt_user_choose_searching_criteria();
    std::cout << "\nNow you can delete selected entries.";
 
    if (key == NAME || key == ADDRESS || key == PHONE)
        promt_user_choose_deleting_criteria(str_deleting_criteria);
    else
        promt_user_choose_deleting_criteria(int_deleting_criteria);
 
    std::vector<Person>::iterator it;
    int counter;
    switch (key)
    {
    case NAME:
        counter = std::count_if(pdata.begin(), pdata.end(), [&](const Person & p) { return p.full_name == str_deleting_criteria; });
        for (int i = 0; i < counter; ++i)
        {
            it = std::find_if(pdata.begin(), pdata.end(), [&](const Person & p) { return p.full_name == str_deleting_criteria; });
            pdata.erase(it);
            std::vector<Person>(pdata).swap(pdata);
        }
        break;
 
    case ADDRESS:
        counter = std::count_if(pdata.begin(), pdata.end(), [&](const Person & p) { return p.address == str_deleting_criteria; });
        for (int i = 0; i < counter; ++i)
        {
            it = std::find_if(pdata.begin(), pdata.end(), [&](const Person & p) { return p.address == str_deleting_criteria; });
            pdata.erase(it);
            std::vector<Person>(pdata).swap(pdata);
        }
        break;
 
    case PHONE:
        counter = std::count_if(pdata.begin(), pdata.end(), [&](const Person & p) { return p.phone == str_deleting_criteria; });
        for (int i = 0; i < counter; ++i)
        {
            it = std::find_if(pdata.begin(), pdata.end(), [&](const Person & p) { return p.phone == str_deleting_criteria; });
            pdata.erase(it);
            std::vector<Person>(pdata).swap(pdata);
        }
        break;
 
    case AGE:
        counter = std::count_if(pdata.begin(), pdata.end(), [&](const Person & p) { return p.age == int_deleting_criteria; });
        for (int i = 0; i < counter; ++i)
        {
            it = std::find_if(pdata.begin(), pdata.end(), [&](const Person & p) { return p.age == int_deleting_criteria; });
            pdata.erase(it);
            std::vector<Person>(pdata).swap(pdata);
        }
        break;
 
    default:
        std::cout << "\nIt seems like wrong number. Try again.\n";
        break;
    } // end switch ( button )
 
    std::cout << "\nSelected data has been erased.\n";
}
#endif // MY_FUNCTIONS_H

// stdafx.h: включаемый файл для стандартных системных включаемых файлов
// или включаемых файлов для конкретного проекта, которые часто используются, но
// не часто изменяются
//
 
#pragma once
 
#include "targetver.h"
 
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <algorithm>
 
 
// TODO: Установите здесь ссылки на дополнительные заголовки, требующиеся для программы

#include "stdafx.h" // подключаем предкомпилированные заголовки
#include "Person.h" // подключаем объявление нашего класса (структуры)
#include "my_functions.h" // подключаем файл с нашими функциями
 
int main()
{
    // создаём динамический массив по имени pdata, в котором будут храниться объекты типа Person
    std::vector<Person> pdata; // в качестве массива используем контейнер типа std::vector
 
    int key = 0; // объявляем переменную key и инициализируем её нулём
    
    // до тех пор, пока key не равна EXIT (то есть, 4)
    while ( key != EXIT ) // то есть, пока пользователь не выбрал выход из программы
    {   // выполнять следующее:
        
        // присвоить переменной key результат работы функции promt_user_choose_menu_operation,
        // которая (функция) предлагает пользователю выбрать один из пунктов меню
        key = promt_user_choose_menu_operation();
        
        switch ( key ) // проверить значение, лежащее в переменной key
        {
        case ADD: // в случае, если key равна ADD (то есть, 1)  
            std::cout << "\n\tAdding new student to database.\n"; // вывести на консоль эту фразу
            add_new_entries_to_array( pdata ); // добавить записи в массив pdata
            copy_data_to_file( pdata, "Person.txt" ); // копировать данные (массив) в файл по имени "Person.txt"
            break; // прервать цикл while
 
        case SHOW: // в случае, если key равна SHOW (то есть, 2) 
            if ( !pdata.empty() ) // если массив pdata не пуст
            {
                for ( const auto & elem : pdata ) // для каждого элемента массива pdata выполнить
                    elem.show(); // вывод массива на консоль (экран монитора) с помощью функции-члена show
 
                std::cout << "\n\n"; // после завершения цикла for вывести на консоль две пустые строки
            }
            else // в противном случае ( то есть, если массив pdata пуст)
                std::cout << "\n\tNo entries were found!\n"; // вывести на консоль эту фразу
            break; // прервать цикл while
 
        case DELETE: // в случае, если key равна DELETE (то есть, 3) 
            if ( !pdata.empty() ) // если массив pdata не пуст
            {
                delete_chosen_data_from_array( pdata ); // удалить выбранные данные из массива pdata
                copy_data_to_file( pdata, "Person.txt" ); // копировать данные (массив) в файл по имени "Person.txt"
            }
 
            else // в противном случае ( то есть, если массив pdata пуст)
                std::cout << "\n\tNo entries were found!\n"; // вывести на консоль эту фразу
            break;
 
        case EXIT: // в случае, если key равна EXIT (то есть, 4)
            key = EXIT; // присвоить переменной key значение 4
            break; // прервать цикл while
 
        default: // вариант по умолчанию (если пользователь ввёл неправильное число)
            std::cout << "\nIt seems like wrong number. Try again.\n"; // вывести на консоль эту фразу
            break; // прервать цикл while
 
        } // end switch ( key )
 
    } // end while ( key != EXIT )
 
    return 0;
}

#ifndef MY_FUNCTIONS_H
#define MY_FUNCTIONS_H
 
#include "stdafx.h" // подключаем предкомпилированные заголовки
#include "Person.h" // подключаем объявление нашего класса (структуры)
 
// создаём перечисление (enum) по имени ChosenOperation (выбранная операция),
// в котором задаём четыре константных целочисленных элемента:
enum ChosenOperation { ADD = 1, SHOW, DELETE, EXIT };
// теперь вместо "магического числа" (то есть, числа обозначающего
// не понятно что) 1 можно использовать элемент ADD (добавить записи),
// вместо 2 - SHOW (отобразить записи), вместо 3 - DELETE (удалить записи),
// а вместо 4 - EXIT (выйти из программы)
 
// создаём перечисление (enum) по имени SearchingCriteria (критерий поиска),
// в котором задаём четыре константных целочисленных элемента:
enum SearchingCriteria { NAME = 1, ADDRESS, PHONE, AGE };
// теперь вместо "магического числа" 1 можно использовать элемент NAME (имя),
// вместо 2 - ADDRESS (адрес), вместо 3 - PHONE (телефон),
// а вместо 4 - AGE (возраст)
 
// предложить пользователю выбрать пункт меню:
int promt_user_choose_menu_operation()
{
    int key = 0;
    std::cout
        << "\nMENU:\n\n"
        << "\t1 - ADD\n"
        << "\t2 - SHOW\n"
        << "\t3 - DELETE\n"
        << "\t4 - EXIT\n"
        << "\nMake your choice (press any key): ";
    std::cin >> key; // ввод с клавиатуры целочисленного значения
 
    return key;
}
 
// получить данные от пользователя (перегруженная функция)
void get_data_from_user( std::string & str ) // передача аргумента по ссылке
{
    // получить от пользователя строку типа std::string
    std::getline( std::cin, str ); // и сохранить её в переменную str
    // для получения строки с пробельными символами обычного std::cin
    // не достаточно, поэтому используем библиотечную функцию std::getline
}
 
// получить данные от пользователя (перегруженная функция)
void get_data_from_user( unsigned int & uint ) // передача uint по ссылке
{
    std::cin >> uint; // для получения базовых типов (например, int, unsiged int,
                      // double, float, char, bool) достаточно обычного std::cin
 
    while ( std::cin.get() != '\n' ) {} // избавляемся от лишних'\n' в потоке
}
 
// предложить пользователю ввести количество записей
size_t promt_user_input_number_of_entries()
{
    size_t number_of_entries = 0;
    std::cout << "Enter number of entries: ";
    std::cin >> number_of_entries;
 
    while ( std::cin.get() != '\n' ) {} // избавляемся от лишних '\n' в потоке
 
    return number_of_entries;
}
 
// шаблонная функция применяется, когда неизвестно заранее, какого типа будут
// какого типа будут аргументы;
// предложить пользователю ввести данные выбранного поля структуры Person:
template <typename T> // шаблонная функция
void promt_user_input_data_of_selected_field
(   // тут список аргументов функции приведён в столбик, так удобнее делать,
    // когда аргументов много (более двух) и у них длинные имена типов и/или
    // собственные названия
    const std::string message,  // сообщение пользователю
    size_t number_of_entry,     // количество записей
    T & selected_field          // выбранное поле
)
 
{
    std::cout << message << " number #" << number_of_entry << ": ";
    get_data_from_user( selected_field ); // вызов перегруженной функции
    // если пользователь вводит строку, будет вызвана та версия функции
    // get_data_from_user, в которой задействована функция std::getline,
    // позволяющая получать строку с пробелами; если пользователь вводит
    // возраст (беззнаковый целочисленный тип), то будет вызвана та версия
    // функции get_data_from_user, которая использует обычный std::cin;
}
 
// предложить пользователю выбрать критерий удаления записи
template <typename T> // шаблонная функция
void promt_user_choose_deleting_criteria(T & del_criteria) // передача по ссылке
{
    std::cout
        << "\n\nSelect deleting criteria: "; // вывод на консоль этой фразы
        
    get_data_from_user( del_criteria ); //вызов перегруженной функции
}
 
// предложить пользователю выбрать критерий поиска записи
int promt_user_choose_searching_criteria()
{
    unsigned int searching_criteria = 0;
    std::cout
        << "\n\nSelect searching criteria:\n\n"
        << "\t1 - SEEK ENTRY BY NAME\n"
        << "\t2 - SEEK ENTRY BY ADDRESS\n"
        << "\t3 - SEEK ENTRY BY PHONE\n"
        << "\t4 - SEEK ENTRY BY AGE\n"
        << "\nMake your choice (press any key): ";
 
    get_data_from_user( searching_criteria ); //вызов перегруженной функции
 
    return searching_criteria;
}
 
// добавить новые записи в массив (аргумента pers передаётся в функицю по ссылке)
void add_new_entries_to_array( std::vector<Person> & pers )
{
// стандарт C++11 позволяет по-новому использовать ключевое слово auto
// теперь не надо расписывать какого типа будет переменная number_of_entries -
// компилятор сам это определит, выведя тип из возвращаемого значения функции
// promt_user_input_number_of_entries (то есть, тип переменной number_of_entries
// будет size_t (беззнаковый целочисленный тип)
    auto number_of_entries
        = promt_user_input_number_of_entries(); // присвоить переменной
// number_of_entries результат работы функции promt_user_input_number_of_entries
 
    std::cout // вывести на консоль эту строку:
        << "\n\tEnter all nessesary data of each entry.\n";
 
    Person p; // создать экземляр класса Person (объект типа Person)
 
// счётчик в цикле for назван именем nth - от формы окончаний английских
// числительных: fourth, fifth, sixth, seventh, eighth, ninth, tenth
    for ( unsigned int nth = 1; nth <= number_of_entries; ++nth )
    {
// последовательно одно за другим заполняем поля для объекта
// по имени p (объект типа Person)
        promt_user_input_data_of_selected_field
            (
                "Enter full name of student",
                nth,
                p.full_name
            );
            
        promt_user_input_data_of_selected_field
            (
                "Enter address of student",
                nth,
                p.address
            );
            
        promt_user_input_data_of_selected_field
            (
                 "Enter phone number of student",
                 nth,
                 p.phone
            );
         
        promt_user_input_data_of_selected_field
        (
            "Enter age of student",
            nth,
            p.age
        );
 
        pers.push_back( p ); // добавить в конец вектора pers значение объекта p
        std::cout << "\n"; // вывести на экран пустую строку
    }
}
 
// скопировать данные в файл
void copy_data_to_file
    (
        const std::vector<Person> & pers,
        const std::string & filename
    )
{
 
    // открыть файл для записи:
    std::ofstream fout( filename.c_str() ); // создаем объект типа std::ofstream
    // по имени fout для записи данных в файл с именем, переданным в строковой
    // переменной filename; поскольку объект fout может принимать в качестве
    // аргумента либо сишные строки (массивы типа const char), либо литералы вида
    // "some text", конвертируем строку std::string (а именно такого типа наша
    // переменная filename) в обычную сишную строку с помощью функции-члена c_str
 
    // размер вектора всегда можно узнать с помощью функции-члена size:
    for ( size_t i = 0; i < pers.size(); ++i )  
    {
        fout // записать в файл
            << pers[i].full_name // имя
            << "|" // символ-разделитель |
            << pers[i].address // адрес
            << "|" // символ-разделитель |
            << pers[i].phone // номер телефона
            << "|" // символ-разделитель |
            << pers[i].age // возраст
            << "\n"; // символ новой строки
    }
    fout.close(); // закрыть файл для записи
}
 
// удалить выбранные данные из массива:
void delete_chosen_data_from_array( std::vector<Person> & pdata )
{
    std::string str_deleting_criteria;
    size_t int_deleting_criteria;
 
    std::cout << "\nNow you can mark entries to deleting.";
    int key = promt_user_choose_searching_criteria();
    std::cout << "\nNow you can delete selected entries.";
 
    if ( key == NAME || key == ADDRESS || key == PHONE )
    {   // вызов шаблонной функции с аргументом типа std::string:
        promt_user_choose_deleting_criteria( str_deleting_criteria ); 
    }
    else
    {   // вызов шаблонной функции с аргументом типа size_t
        promt_user_choose_deleting_criteria( int_deleting_criteria ); 
    }
// итератор - специальный класс, реализующий функции умного указателя
// для заданного контейнера (в нашем случае - для вектора):
    std::vector<Person>::iterator it;   
 
    int counter; // счётчик
    switch ( key ) // проверка значения лежащего в переменной key
    {
    case NAME: // если key равна NAME (то есть, равна 1)
 
// присвоить переменной counter значение, возвращаемое библиотечной
// функцией std::count_if
        counter = std::count_if
            (
                pdata.begin(),
                pdata.end(),
             
// лябмда функция (применение [&] предоставляет доступ ко всем
// автоматическим переменным по ссылке):
                [&]
                    ( const Person & p )
                {
                    return p.full_name == str_deleting_criteria;
                } // конец лямбды                
            );
         
// Библиотечная функция std::count_if (подсчитать, если) - это стандартный
// алгоритм для подсчёта в контейнере значений, удовлетворяющих заданному
// условию. Эта функция объявлена в заголовочном файле algorithm. Она
// принимает три аргумента - итератор, обозначающий начало исследуемого
// диапазона заданной последовательности (в нашем случае, это начало вектора,
// заданное функцией-членом begin), итератор, обозначающий конец исследуемого
// диапазона заданной последовательности (в нашем случае, это конец вектора,
// заданный функцией-членом end) и,наконец, третий аргумент - так называемый
// предикат. Предикат - это функция, функциональный объект (функтор), либо,
// как в нашем случае - лямбда-функция (про лямбды, функторы и т.п. читать у
// Стивена Праты в 18 глава, стр. 1077). Предикат возвращает значение типа
// bool - либо истину, либо ложь. Именно предикат определяет соответствие условия
// - в нашем случае, равно ли full_name (имя) каждого элемента вектора значению
// переменной str_deleting_criteria. С помощью такой заковыристой конструкции мы
// посчитаем сколько элементов в нашем векторе соответствуют заданному критерию
// (например, сколько в нашем векторе записей студентов, которых зовут, скажем,
// Олег Волков).
  
        for ( int i = 0; i < counter; ++i )
        {
// Ещё одна функция из стандартной библиотеки, из того же заголовочного файла
// algorithm. Функция std::find_if (найти, если) - это стандартный алгоритм для
// поиска в контейнере значений, удовлетворяющих заданному условию. Возвращаемое
// значение - итератор (специальный класс-указатель) на первый найденный элемент,
// удовлетворяющих заданному условию. Но нам-то надо не только первый, а все,
// правда? Вот для этого мы и считали выше с помощью std::count_if сколько у нас
// таких элементов в векторе имеется, а вот теперь ко всем к ним в цикле применим
// алгоритм std::find_if
            it = std::find_if
                (
                    pdata.begin(),
                    pdata.end(),
                    [&]
                        ( const Person & p )
                    {
                        return p.full_name == str_deleting_criteria;
                    } // лямбда
                );
 
// Хитрая конструкция, использующая ещё две функции-члена класса
// вектор - функцию-член erase и функцию-член swap:
            pdata.erase(it);
            std::vector<Person>( pdata ).swap( pdata );
// Смысл этой операции подробно объяснён вот тут:
// [url]https://www.cyberforum.ru/cpp-beginners/thread552720.html#post2930756[/url]
// Ну и идея так стирать элементы из вектора тоже честно стырена оттуда
// же (большое спасибо форумчанам PointsEqual и Nick Alte).
        }
        break;
 
    case ADDRESS:
        counter = std::count_if
            (
                pdata.begin(),
                pdata.end(),
                [&]
                    ( const Person & p )
                {
                    return p.address == str_deleting_criteria;
                }
            );
            
        for ( int i = 0; i < counter; ++i )
        {
            it = std::find_if
                (
                    pdata.begin(),
                    pdata.end(),
                    [&]
                        ( const Person & p )
                    {
                        return p.address == str_deleting_criteria;
                    }
                );
                
            pdata.erase( it );
            std::vector<Person>(pdata).swap( pdata );
        }
        break;
 
    case PHONE:
        counter = std::count_if
            (
                pdata.begin(),
                pdata.end(),
                [&]
                    ( const Person & p )
                {
                    return p.phone == str_deleting_criteria;
                }
            );
        for ( int i = 0; i < counter; ++i )
        {
            it = std::find_if
                (
                    pdata.begin(),
                    pdata.end(),
                    [&]
                        ( const Person & p )
                    {
                        return p.phone == str_deleting_criteria;
                    }
                );
                
            pdata.erase( it );
            std::vector<Person>( pdata ).swap( pdata );
        }
        break;
 
    case AGE:
        counter = std::count_if
            (
                pdata.begin(),
                pdata.end(),
                [&]
                    ( const Person & p )
                {
                    return p.age == int_deleting_criteria;
                }
            );
            
        for (int i = 0; i < counter; ++i)
        {
            it = std::find_if
                (
                    pdata.begin(),
                    pdata.end(),
                    [&]
                        (const Person & p)
                    {
                        return p.age == int_deleting_criteria;
                    }
                );
                
            pdata.erase( it );
            std::vector<Person>( pdata ).swap( pdata );
        }
        break;
 
    default:
        std::cout << "\nIt seems like wrong number. Try again.\n";
        break;
    } // end switch ( button )
 
    std::cout << "\nSelected data has been erased.\n";
}
#endif // MY_FUNCTIONS_H