Найти и сохранить в каждой строке только те слова, которые удовлетворяют условию (файловый ввод/вывод)

//Программа создает файл строк. Признак окончания ввода -
//пустая строка. Затем файл построчно читается,
//и программа удаляет из каждой строки, содержащей слова,
//разделенные произвольным количеством пробелов, все слова с чётным номером.
//Обработанная строка записывается в новый файл
 
 
#include <stdio.h>
#include <conio.h>
#include <iostream>
#include <string.h>
#include <stdlib.h>
#define FNAME_I "D:\\st_i.txt\0" //имя исх. файла задано константной строкой
#define FNAME_R "D:\\st_r.txt\0" //имя рез. файла задано константной строкой
const int RAZ = 80;              //максимальная длина строки
const char PR_R[] = "r";         //признак открытия файла на чтение
const char PR_W[] = "w";         //признак открытия файла на запись
void make_file(char *fname);    //функция создания файла
int proverka_file(char *fname, const char *);   //проверка наличия файла
void obrabotka_file(char *, char *);        //обработка содержимого
void vivod_file(char*);      //вывод содержимого файла на печать
 
using namespace std;
 
int main()
{
    
    char fname_i[20] = FNAME_I;
    char fname_r[20] = FNAME_R;
    //создаем исходный файл
    make_file(fname_i);
    //выводим его содержимое
    if (!proverka_file(fname_i, PR_R))
    {
        cout << "Ошибка открытия файла " << fname_i << " на чтение" << endl;
        cout << "Нажмите <Enter>" << endl;
        getchar();
        return 0;   //если исходный файл не создан
    }
    cout << "Содержимое исходного файла:" << endl;
    vivod_file(fname_i);
 
    //обрабатываем файл
    obrabotka_file(fname_i, fname_r);
 
    //выводим содержимое результата
    if (!proverka_file(fname_r, PR_R))
    {
        cout << "Ошибка открытия файла " << fname_r << " на чтение" << endl;
        cout << "Нажмите <Enter>" << endl;
        getchar();
        return 0;   //если результирующий файл не создан
    }
    cout << "Результат (в каждой строке удалены слова с чётным номером):\n";
    vivod_file(fname_r);
 
    cout << endl << "Для завершения нажмите <Enter>";
    getchar();
    return 0;
}
//main_End________________________________________________________________
//make_file_ Begin________________________________________________________
void make_file(char *fname_i)
{
    char st[RAZ];       //исходная строка
    FILE *in;             //текстовый файл
    char otv;       //ответ пользователя
                    //Открываем файл в режиме чтения (r)
                    //Если файл с таким именем уже есть, то либо пользователь вводит
                    //новое имя, либо новые записи будут дописаны поверх старых
    while (proverka_file(fname_i, PR_R))
    {
        cout << "Такой файл уже есть! Зададите новое имя Y/N?" << endl;
        cin.get(otv);
        if (otv == 'Y' || otv == 'y')
        {
            cout << "Введите новое имя:" << endl;
            cin >> fname_i;
            cin.get();  //убираем символ '\n' из потока
        }
        else {
            cin.get();  //убираем символ '\n' из потока
            break;
        }
    }
    //проверяем возможность открытия файла для записи
    //поскольку полное имя файла могло быть задано с ошибкой
    if (!proverka_file(fname_i, PR_W))
    {
        cout << "Ошибка открытия файла " << fname_i << " на запись" << endl;
        cout << "Нажмите <Enter>" << endl;
        getchar();
        exit(0);
    }
    //Открываем файл в режиме записи (w) текста (по умолчанию)
    //Если файл с таким именем уже есть, то новые данные
    //будут дописаны поверх старых
    in = fopen(fname_i, PR_W);
    cout << "Создание файла." << endl;
    cout << "Признак окончания ввода - ввод пустой строки" << endl;
    cout << "Введите строку и нажмите <Enter>" << endl;
    cout << "->";
    cin.getline(st, RAZ); //функция вводит строку целиком, включая
                          //пробелы и символ \n
    while (strlen(st))
    {
        fprintf(in, "%s\n", st);
        cout << "Введите строку и нажмите <Enter>" << endl;
        cout << "->";
        otv++;
        cin.getline(st, RAZ);
    }
    fclose(in);         //закрываем файл
}
//make_file_End___________________________________________________________
 
//proverka_file_Begin_____________________________________________________
//проверка наличия файла
int proverka_file(char *fname, const char *pr)
{
    //Открываем файл
    if ((fopen(fname, pr)) == NULL) //файл не существует
        return(0);
    return(1);
}
//proverka_file_End_______________________________________________________
 
//obrabotka_file_Begin____________________________________________________
//обработка содержимого файла
void obrabotka_file(char *fname_i, char *fname_r)
{
    FILE *in, *out;     //исходный и результирующий файлы (потоки)
    char st[RAZ];           //исходная строка
    char sr[RAZ];           //результирующая строка
    char pr[RAZ];           //обрабатываемое слово
    int i, j, k;            //номер обрабатываемого символа
    int flag;                   //признак четного номера слова
    int n;                      //длина результирующей строки
    in = fopen(fname_i, PR_R); //открываем файл на чтение
    out = fopen(fname_r, PR_W); //открываем файл на запись
    fgets(st, RAZ, in);     //читаем строку из файла in
    while (!feof(in))
    {
        i = 0;
        n = 0;
        flag = 1;
        sr[i] = '\0';
        while (st[i])
        {
            k = 0;
            while (st[i] == ' ')    //удаляем в строке ведущие пробелы
                i++;
            while (st[i] != ' ' && st[i + 1])   //выделяем очередное слово
            {
                pr[k] = st[i];
                k++;
                i++;
            }
            if (flag)                //если у слова нечетный номер -
            {
                flag = 0;             //заносим в результирующую строку
                for (j = 0; j < k; j++, n++)
                    sr[n] = pr[j];
                if (st[i])
                    sr[n] = ' ';
                n++;
            }
            else flag = 1;
            i++;
        }
        sr[n++] = '\0';         //закрываем результирующую строку
        fprintf(out, "%s\n", sr);  //записываем обработанную строку в новый файл
        fgets(st, RAZ, in);     //считываем новую строку из файла
    }
    fclose(in); fclose(out);     //Закрываем файлы in и out 
}
//obrabotka_file_End______________________________________________________
//vivod_file_Begin________________________________________________________
//вывод содержимого файла на экран
void vivod_file(char *fname)
{
    FILE *in_out;
    char st[RAZ];               //считанная строка
    in_out = fopen(fname, PR_R);  //открываем файл на чтение
    fgets(st, RAZ, in_out);     //читаем строку из файла in_out
    while (!feof(in_out))
    {
        cout << st;             //выводим очередную строку на экран
        fgets(st, RAZ, in_out);
    }
    fclose(in_out);
}
//vivod_file_End__________________________________________________________

#include <iostream>
#include <ctype.h>
#include <string>
#include <fstream>
#include <unistd.h>
#include <sstream>
#include <vector>
#include <random>
#include <chrono>
 
using namespace std;
 
vector<string> str_in;  //для создания файла
vector<string> str_out; //для обработки файла
vector<string> words;   //для слов
 
inline bool GenerateFile(int sum_strok, int sum_char,const string &filename, const bool rewrite, const char view );
inline bool FillDataOutFiles();
inline bool checkWord(string const & word);
inline bool SaveAnstoFile(const string &filename, const string Word, const bool rewrite);
 
 
int main()
{
    //Генерируем файл in.txt
    if (GenerateFile(6,80,"in.txt",true,' ')) cout << "Файл заполнен\n";
    //Читаем файл in.txt
    if (FillDataOutFiles()) cout << "Файл считан\n";
    //разбиваем на слова
    for (unsigned int i=0; i<str_out.size(); ++i)
    {
        istringstream ist(str_out[i]);
        string tmp;
        while ( ist >> tmp )
            {
                words.push_back(tmp);
            }
    }
    //ghjdthztv и пишем в файл outfile.txt
    for (auto &el : words)
        if(checkWord(el)) SaveAnstoFile("outfile.txt",el,false);
   
    return EXIT_SUCCESS;
}
 
 
inline bool GenerateFile(int sum_strok, int sum_char,const string &filename, const bool rewrite, const char view )
{
    string tmp;
    tmp.clear();
    for (int i=0;i<sum_strok; ++i)
    {
        for (int ii=0; ii<sum_char;++ii)
        {
            default_random_engine g(chrono::system_clock::now().time_since_epoch().count()+ii);
            uniform_int_distribution<int> distribution(97, 123);
            int roll=distribution(g);
            if (roll==123) roll=32;
            tmp+=(char)roll;
        }
        str_in.push_back(tmp);
        tmp.clear();
    }
 
    ofstream outFile (filename, rewrite ? ios::out : ios::app);
    if (!outFile.is_open()) //проверить открыт ли файл
    {
       cout << "Unable to write " << endl;
       return false;
    }
    for (int i=0;i<sum_strok; ++i)
        outFile << str_in[i] << "\n";
    outFile.close();
    str_in.erase(str_in.begin(), str_in.end());
    if (view=='v')
        for (auto &el : str_in)
            cout << el << endl;
    return true;
}
inline bool FillDataOutFiles()
{
    ifstream inFile ("in.txt"); //создать поток
    if (!inFile.is_open()) //проверить открыт ли файл
    {
        cout << "File not read\n";
        return false;
    }
    string line;
    while (getline(inFile, line)) //прочитать строку
    {
        str_out.push_back(line);
    }
    inFile.close();
    for (auto &el : str_out)
        cout << el << endl;
    return true;
}
inline bool checkWord(string const & word)
{
    static const char * words[] = {
        "zyxwvutsrqponmlkjihgfedcba",
        "zyxwvutsrqponmlkjihgfedcb",
        "zyxwvutsrqponmlkjihgfedc",
        "zyxwvutsrqponmlkjihgfed",
        "zyxwvutsrqponmlkjihgfe",
        "zyxwvutsrqponmlkjihgf",
        "zyxwvutsrqponmlkjihg",
        "zyxwvutsrqponmlkjih",
        "zyxwvutsrqponmlkji",
        "zyxwvutsrqponmlkj",
        "zyxwvutsrqponmlk",
        "zyxwvutsrqponml",
        "zyxwvutsrqponm",
        "zyxwvutsrqpon",
        "zyxwvutsrqpo",
        "zyxwvutsrqp",
        "zyxwvutsrq",
        "zyxwvutsr",
        "zyxwvuts",
        "zyxwvut",
        "zyxwvu",
        "zyxwv",
        "zyxw",
        "zyx",
        "zy",
        "z"
    };
    for(char const * curWord : words)
        if(word == curWord)
            return true;
    return false;
}
inline bool SaveAnstoFile(const string &filename, const string Word, const bool rewrite)
{
    ofstream outFile (filename, rewrite ? ios::out : ios::app);
    if (!outFile.is_open()) //проверить открыт ли файл
    {
       cout << "Unable to write " << endl;
       return false;
    }
    outFile << Word << "\n";
    outFile.close();
    return true;
}

#include <unistd.h>

uniform_int_distribution<int> distribution(97, 123);

inline bool ManualFile(int sum_strok, const string &filename, const bool rewrite);

system ("clear");
    cout << "Как будем создавать файл?\n";
    int answen=0;
    cout << "Автогенерация файла .......... ( 1 )\n";
    cout << "Ручное заполнение ............ ( 2 )\n";
    cin >> answen;
    if (answen==1)
    {
        if (GenerateFile(6,80,"in.txt",true,' ')) cout << "Файл заполнен автоматически\n";
    } else
    {
        int sum_strok;
        cout << "Ручной режим заполнения \n" << "Введите количество строк в файле = ";cin >>sum_strok;
        ManualFile(sum_strok, "in.txt", false);
    }

inline bool ManualFile(int sum_strok, const string &filename, const bool rewrite)
{
    string tmp;
    tmp.clear();
    for (int i=0;i<sum_strok; ++i)
    {
        cout << "введите строку не превышающею 80 символов\n";
        cin >> tmp;
        if (tmp.size()==80)
        {
            cout << "Строка принята\n";
        } else if (tmp.size()<=80)
            {
                cout << "Оптимальная размерность строки не достигнута, не хватает: "
                << 80-tmp.size() << "символов\n";
            } else
            {
                cout << "размерность строки превышена, строка обрезана\n";
                tmp=tmp.substr(0,80);
            }
        str_in.push_back(tmp);
        tmp.clear();
    }
 
    ofstream outFile (filename, rewrite ? ios::out : ios::app);
    if (!outFile.is_open()) //проверить открыт ли файл
    {
       cout << "Unable to write " << endl;
       return false;
    }
    for (int i=0;i<sum_strok; ++i)
        outFile << str_in[i] << "\n";
    outFile.close();
    str_in.erase(str_in.begin(), str_in.end());
    return true;
}