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

#include <iostream>
#include <fstream>
 
enum ChosenOperation { ADD = 1, SHOW, DELETE, EXIT };
 
enum SearchingCriteria { NAME = 1, ADDRESS, PHONE, AGE };
 
struct Human
{
    std::string full_name;  // фамилия имя отчество
    std::string address;    // домашний адрес
    std::string phone;      // телефон
    unsigned int age;       // возраст
};
 
void add_new_entry_to_file( std::string filename )
{
    std::cout << "\n\n\tAdding new student to database.\n\n";
 
    std::cout << "Enter number of entries: ";
    unsigned int number_of_entries;
    std::cin >> number_of_entries;
 
    std::cout << "\n\n\tEnter all nessesary data of each entry.\n\n";
    struct Human* human = new struct Human[number_of_entries];
 
    for ( unsigned int i = 0, nth; i < number_of_entries; ++i )
    {
        nth = i + 1;
        while ( std::cin.get() != '\n' );
 
        std::cout
            << "Enter full name of "
            << nth
            << " student: ";
        std::getline( std::cin, human[i].full_name );
 
        std::cout
            << "Enter address of "
            << nth
            << " student: ";
        std::getline( std::cin, human[i].address );
 
        std::cout
            << "Enter phone number of "
            << nth
            << " student: ";
        std::getline( std::cin, human[i].phone );
 
        std::cout
            << "Enter age of "
            << nth
            << " student: ";
        std::cin >> human[i].age;
        std::cout << "\n";
    }
 
    std::ofstream fout( filename.c_str() );
    for ( unsigned int i = 0; i < number_of_entries; ++i )
    {
        fout
            << human[i].full_name
            << "|"
            << human[i].address
            << "|"
            << human[i].phone
            << "|"
            << human[i].age
            << "\n";
    }
    fout.close();
 
    delete [] human;
}
 
void show_data( std::string filename )
{
    // TODO
}
 
void delete_data_in_file( std::string filename, int searching_criteria )
{
    // TODO
}
 
int main()
{
    int key = 0;
    while ( key != ChosenOperation::EXIT )
    {
        std::cout
            << "MENU:\n\n"
            << "\t1 - ADD\n"
            << "\t2 - SHOW\n"
            << "\t3 - Delete\n"
            << "\t4 - EXIT(Esc)\n\n"
            << "Press any key: ";
 
        std::cin >> key;
 
        switch ( key )
        {
            case ChosenOperation::ADD :
                add_new_entry_to_file( "Person.txt" );
 
            case ChosenOperation::SHOW :
                show_data( "Person.txt" );
 
            case ChosenOperation::SEARCH :
                delete_data_in_file( "Person.txt", SearchingCriteria::NAME );
 
            case ChosenOperation::EXIT :
                key = ChosenOperation::EXIT;
        }
    }
 
    return 0;
}

#include "stdafx.h"
 
enum ChosenOperation
{
    ADD = 1,
    READ,
    SHOW,
    DELETE,
    EXIT
};
 
enum SearchingCriteria
{
    NAME = 1,
    ADDRESS,
    PHONE,
    AGE
};
 
struct Person
{
    std::string full_name = "name is not specified";        // фамилия имя отчество
    std::string address = "address is not specified";       // домашний адрес
    std::string phone = "phone number is not specified";    // телефон
    unsigned int age = 0;                                   // возраст
 
    void show() const
    {
        std::cout
            << "\n"
            << full_name
            << "\n"
            << address
            << "\n"
            << phone
            << "\n"
            << age
            << "\n";
    }
};
 
int promt_user_choose_menu_operation()
{
    int key = 0;
    std::cout
        << "\nMENU:\n\n"
        << "\t1 - ADD\n"
        << "\t2 - READ\n"
        << "\t3 - SHOW\n"
        << "\t4 - DELETE\n"
        << "\t5 - 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_from_file(std::vector<Person> & pers, const std::string & filename)
{
    std::ifstream fin;
    fin.open(filename.c_str());
    if (fin.is_open())
    {
        pers.clear();
        Person p;
        while(fin.good())
        {
            std::getline(fin, p.full_name, '|');
            std::getline(fin, p.address, '|');
            std::getline(fin, p.phone, '|');
            fin >> p.age;
 
            pers.push_back(p);
        }
    }
    else
    {
        std::cout << "\nCould not open the file " << filename << "\n";
    }
    fin.close();
}
 
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;
    }
 
    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";
}
 
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 READ:
            std::cout << "\n\tReading data from database.\n";
            copy_data_from_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;
}

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