Разработать схемы алгоритмов, структуру и текст программы для обработки структурных данных текстового и бинарного файлов

#include <iostream>
#include <iomanip>
#include <fstream>
#include <conio.h>
#include <cstring>
#include <string>
#include <stdio.h>
 
using namespace std;
 
// объявление структурного типа
struct stud {
    char fio[20];
    char gr[7];
    int no;
    double rs;
};
 
// внешняя структура
stud st;
 
// объявление файловых потоков
ifstream fin;
ofstream fout;
fstream fbin;
 
const int FIO_FIELD = 0;
const int GR_FIELD = 1;
const int NO_FIELD = 2;
const int RS_FIELD = 3;
const int CONTROL_FIELD = FIO_FIELD;
 
char* getField(stud* st, int field) {
    static char empty[] = " ";
    switch (field) {
    case FIO_FIELD:
        return st->fio;
    case GR_FIELD:
        return st->gr;
    case NO_FIELD:
        return (char*)&st->no;
    case RS_FIELD:
        return (char*)&st->rs;
    default:
        return empty;
    }
}
 
void setField(stud* st, int field, const char* value) {
    switch (field) {
    case FIO_FIELD:
        strncpy_s(st->fio, value, sizeof(st->fio));
        break;
    case GR_FIELD:
        strncpy_s(st->gr, value, sizeof(st->gr));
        break;
    case NO_FIELD:
        st->no = atoi(value);
        break;
    case RS_FIELD:
        st->rs = atof(value);
        break;
    default:
        break;
    }
}
//функция, которая удаляет пробельные символы в начале и конце строки
void trim(string& str) {
    // удаляем пробелы и символы табуляции в начале строки
    size_t startpos = str.find_first_not_of(" \t");
    if (startpos != string::npos) {
        str.erase(0, startpos);
    }
    // удаляем пробелы и символы табуляции в конце строки
    size_t endpos = str.find_last_not_of(" \t");
    if (endpos != string::npos) {
        str.erase(endpos + 1);
    }
}
// функция удаления пробелов в строке
void filtr(char* str) {
    int i = 0;
    while (str[i] == ' ') {
        i++;
    }
    if (i > 0) {
        memmove(str, str + i, strlen(str) + 1 - i);
    }
    i = strlen(str) - 1;
    while (i >= 0 && str[i] == ' ') {
        str[i] = '\0';
        i--;
    }
}
 
// перегрузка операции вывода структурных данных в поток
ostream& operator<<(ostream& out, stud& st) {
    out.setf(ios::left, ios::adjustfield);
    out << setw(20) << st.fio << setw(7) << st.gr << setw(8) << st.no << setw(7) << setprecision(2) << fixed << st.rs << endl;
    return out;
}
 
// перегрузка операции ввода структурных данных из потока
istream& operator>>(istream& in, stud& st) {
    in.getline(st.fio, 21);
    filtr(st.fio);
    in.getline(st.gr, 8);
    filtr(st.gr);
    in >> st.no >> st.rs;
    in.ignore(80, '\n');
    return in;
}
 
void fix_file(char* bin_file) {
    // открываем бинарный файл с записями структурных данных в режиме чтения-записи
    fstream bfile(bin_file, ios::in | ios::out | ios::binary);
    if (!bfile.is_open()) {
        cout << "Error opening binary file" << endl;
        return;
    }
    // создаем новый рабочий файл для записи данных в бинарном режиме
    fstream wfile("temp1.bin", ios::binary);
    if (!wfile.is_open()) {
        cout << "Error creating temp file" << endl;
        return;
    }
    // организуем цикл, в котором считываем по одной записи из бинарного файла в структуру st
    while (bfile.read((char*)&st, sizeof(st))) {
        // если значение контрольного поля в структуре st отличается от характерного значения (пустой строки), записываем структуру в рабочий файл
        if (strcmp("", getField(&st, CONTROL_FIELD)) != 0) {
            wfile.write((char*)&st, sizeof(st));
        }
    }
    // устанавливаем указатель в бинарном файле на начало
    bfile.seekg(0, ios::beg);
    // очищаем файл
    bfile.close();
    bfile.open(bin_file, ios::out | ios::trunc | ios::binary);
    bfile.close();
    bfile.open(bin_file, ios::in | ios::out | ios::binary);
    // копируем данные из рабочего файла в бинарный файл
    wfile.seekg(0, ios::beg);
    while (wfile.read((char*)&st, sizeof(st))) {
        bfile.write((char*)&st, sizeof(st));
    }
    // закрываем файлы
    bfile.close();
    wfile.close();
    // удаляем рабочий файл
    remove("temp1.bin");
}
// функция создания текстового файла данных
void sozdat(char* file) {
    fout.open(file);
    while (true) {
        cout << "Введите данные одной структуры" << endl;
        cin >> st;
        fout << st;
        cout << "Нажмите любую клавишу, если хотите продолжить запись и 0 – , если нет" << endl;
        char c = _getch();
        if (c == '0') {
            break;
        }
    }
    fout.close();
}
 
void createfile(const char* file) {
    fout.open(file);
    cout << "Введите данные поиска:" << endl;
    cin >> st;
    fout << st;
    cout << "Файл поиска создан";
    fout.close();
}
 
// функция создания бинарного файла
void create_binary(char* text_file, char* bin_file) {
    fin.open(text_file);
    fbin.open(bin_file, ios::out | ios::binary);
    while (fin >> st) {
        fbin.write((char*)&st, sizeof(st));
    }
    fin.close();
    fbin.close();
}
 
// функция удаления структур из бинарного файла по заданному полю
void delete_structures(char* bin_file, char* search_file) {
    // открываем файл с данными для удаления в режиме чтения
    ifstream sfile(search_file);
    if (!sfile.is_open()) {
        cout << "\nError opening search file" << endl;
        return;
    }
    // открываем бинарный файл с записями структурных данных в режиме чтения-записи
    fstream bfile(bin_file, ios::in | ios::out | ios::binary);
    if (!bfile.is_open()) {
        cout << "\nError opening binary file" << endl;
        return;
    }
    // создаем новый рабочий файл для записи данных в бинарном режиме
    ofstream wfile("temp.bin", ios::binary);
    if (!wfile.is_open()) {
        cout << "Error creating temp file" << endl;
        return;
    }
    // объявляем переменную, в которую будут читаться данные для удаления
    string search_value;
    // организуем цикл, пока не будет достигнут конец файла данных для удаления
    while (getline(sfile, search_value)) {
        // удаляем из строки пробелы, ведущие и замыкающие
        trim(search_value);
        // если значение для удаления отсутствует, переходим к следующей итерации цикла
        if (search_value.empty()) {
            cout << "\nNo search value provided" << endl;
            continue;
        }
        // устанавливаем указатель в бинарном файле с записями на начало файла
        bfile.seekg(0, ios::beg);
        // организуем вложенный цикл до конца бинарного файла
        while (bfile.read((char*)&st, sizeof(st))) {
            // проверяем совпадение контрольного поля структуры st со значением для удаления
            if (strcmp(search_value.c_str(), getField(&st, CONTROL_FIELD)) == 0) {
                // присваиваем этому полю структуры st характерное значение
                setField(&st, CONTROL_FIELD, "");
                // перезаписываем откорректированную структуру на старое место в бинарный файл
                bfile.seekp(sizeof(st), ios::cur);
                bfile.write((char*)&st, sizeof(st));
            }
        }
        // выводим фразу, что таких данных в бинарном файле нет, если по завершению внутреннего цикла совпадение полей не обнаружилось
        cout << "\nNo matching records found" << endl;
    }
    // устанавливаем указатель в бинарном файле на начало
    bfile.seekg(0, ios::beg);
    // организуем цикл, в котором считываем по одной записи из бинарного файла в структуру st
    while (bfile.read((char*)&st, sizeof(st))) {
        // если значение контрольного поля в структуре st отличается от характерного значения (пустой строки), записываем структуру в рабочий файл
        if (strcmp("", getField(&st, CONTROL_FIELD)) != 0) {
            wfile.write((char*)&st, sizeof(st));
        }
    }
    // закрываем файлы
    sfile.close();
    bfile.close();
    wfile.close();
    // удаляем бинарный файл с диска
    remove(bin_file);
    // переименовываем рабочий файл в бинарный файл
    rename("temp.bin", bin_file);
    // вызываем функцию коррекции файла данных
    fix_file(bin_file);
}
 
int main() {
    setlocale(LC_ALL, "Russian");
    char file[] = "data";
    char binaryFile[] = "data.bin";
    char filename[] = "delete.txt";
    // создание текстового файла данных
    sozdat(file);
 
    // создание бинарного файла данных
    create_binary(file, binaryFile);
 
    createfile(filename);
    // чтение значения поля последней структуры из файла для удаления
    fin.open("delete.txt");
    char search_field[40];
    fin.getline(search_field, 40);
    fin.close();
 
    // удаление структур из бинарного файла
    delete_structures(binaryFile, filename);
 
    return 0;
}

struct stud { char fio [20]; char gr [7]; unsigned int no ; float rs; } st;

// перегрузка операции  вывода структурных данных в стандартный 
//выходной поток и во все  выходные потоки производных типов (напр., //файловые)
#include <iostream>
#include <iomanip>
using namespace std;
…
ostream &     operator <<    ( ostream & out , stud &st) { out.setf(ios::left,ios::adjustfield);    //сбросили правое выравнивание
                                                          //установили  левое
out << setw(20) << st.fio << setw(7) << 
st.gr << setw(8) <<st.no   << setw(7)<< setprecision(2) << st.rs<<endl;
return out;
 }
//--------------------------------------------------------------------------------------
// перегрузка операции ввода данных (“>>”) из стандартного потока, 
// наследуемая и файловыми входными потоки
istream &   operator >>   (istream & in , stud &st ) {  
char T[80]; 
in.getline (st.fio, 21);  filtr( st.fio); 
in.getline ( st.gr, 8) ;  filtr(st.gr ); 
in >> st.no >>st.rs ;
in.getline (T, 80);
return in; 
 }

void sozdat (char*file) { 
fout.open(file) ;                  // fout- файловый выходной поток
m: cout<< "введите данные одной структуры"<<endl ;
cin>> st;    fout<<st;
cout<<"Нажмите любую клавишу, если хотите продолжить запись и  " 
   " 0 – , если нет" <<endl
char c ;    c=getch();
 if(c=='0') {fout.close(); return;}
else  goto m; 
 }