Ошибка при взаимодействии с файлом c

It is quite common that errors may occur while reading data from a file in C++ or writing data to a file. For example, an error may arise due to the following:

• When trying to read a file beyond indicator.
• When trying to read a file that does not exist.
• When trying to use a file that has not been opened.
• When trying to use a file in an inappropriate mode i.e., writing data to a file that has been opened for reading.
• When writing to a file that is write-protected i.e., trying to write to a read-only file.

Failure to check for errors then the program may behave abnormally therefore an unchecked error may result in premature termination for the program or incorrect output.

Below are some Error handling functions during file operations in C/C++:

ferror():

In C/C++, the library function ferror() is used to check for the error in the stream. Its prototype is written as:

 int ferror (FILE *stream);

The ferror() function checks for any error in the stream. It returns a value zero if no error has occurred and a non-zero value if there is an error. The error indication will last until the file is closed unless it is cleared by the clearerr() function. 

Below is the program to implement the use of ferror():

Output:

Explanation: After executing this code “Provide feedback on this article:“ will be displayed on the screen and after giving some feedback “Process exited after some seconds with return value 0″ will be displayed on the screen.

clearerr():

The function clearerr() is used to clear the end-of-file and error indicators for the stream. Its prototype can be given as:

void clearerr(FILE *stream);

The clearerr() clears the error for the stream pointed by the stream. The function is used because error indicators are not automatically cleared. Once the error indicator for a specific stream is set, operations on the stream continue to return an error value until clearerr(), fseek(), fsetpos(), or rewind() is called.

Below is the program to implement the use of clearerr():

Output:

The function perror() stands for print error. In case of an error, the programmer can determine the type of error that has occurred using the perror() function. When perror() is called, then it displays a message describing the most recent error that occurred during a library function call or system call. Its prototype can be given as:

void perror (char*msg);

• The perror() takes one argument which points to an optional user-defined message the message is printed first followed by a colon and the implementation-defined message that describes the most recent error.
• If a call to perror() is made when no error has actually occurred then ‘No error’ will be displayed.
• The most important thing to remember is that a call to perror() and nothing is done to deal with the error condition, then it is entirely up to the program to take action. For example, the program may prompt the user to do something such as terminate the program.
• Usually, the program’s activities will be determined by checking the value of errno and the nature of the error.
• In order to use the external constant errno, you must include the header file ERRNO.H

Below is the program given below illustrates the use of perror(). Here, assume that the file “file.txt” does not exist.

Output:

Last Updated :
10 Jan, 2022

Like Article

Save Article

It is quite common that errors may occur while reading data from a file in C++ or writing data to a file. For example, an error may arise due to the following:

• When trying to read a file beyond indicator.
• When trying to read a file that does not exist.
• When trying to use a file that has not been opened.
• When trying to use a file in an inappropriate mode i.e., writing data to a file that has been opened for reading.
• When writing to a file that is write-protected i.e., trying to write to a read-only file.

Failure to check for errors then the program may behave abnormally therefore an unchecked error may result in premature termination for the program or incorrect output.

Below are some Error handling functions during file operations in C/C++:

ferror():

In C/C++, the library function ferror() is used to check for the error in the stream. Its prototype is written as:

 int ferror (FILE *stream);

The ferror() function checks for any error in the stream. It returns a value zero if no error has occurred and a non-zero value if there is an error. The error indication will last until the file is closed unless it is cleared by the clearerr() function. 

Below is the program to implement the use of ferror():

Output:

Explanation: After executing this code “Provide feedback on this article:“ will be displayed on the screen and after giving some feedback “Process exited after some seconds with return value 0″ will be displayed on the screen.

clearerr():

The function clearerr() is used to clear the end-of-file and error indicators for the stream. Its prototype can be given as:

void clearerr(FILE *stream);

The clearerr() clears the error for the stream pointed by the stream. The function is used because error indicators are not automatically cleared. Once the error indicator for a specific stream is set, operations on the stream continue to return an error value until clearerr(), fseek(), fsetpos(), or rewind() is called.

Below is the program to implement the use of clearerr():

Output:

The function perror() stands for print error. In case of an error, the programmer can determine the type of error that has occurred using the perror() function. When perror() is called, then it displays a message describing the most recent error that occurred during a library function call or system call. Its prototype can be given as:

void perror (char*msg);

• The perror() takes one argument which points to an optional user-defined message the message is printed first followed by a colon and the implementation-defined message that describes the most recent error.
• If a call to perror() is made when no error has actually occurred then ‘No error’ will be displayed.
• The most important thing to remember is that a call to perror() and nothing is done to deal with the error condition, then it is entirely up to the program to take action. For example, the program may prompt the user to do something such as terminate the program.
• Usually, the program’s activities will be determined by checking the value of errno and the nature of the error.
• In order to use the external constant errno, you must include the header file ERRNO.H

Below is the program given below illustrates the use of perror(). Here, assume that the file “file.txt” does not exist.

Output:

It is quite common that errors may occur while reading data from a file in C++ or writing data to a file. For example, an error may arise due to the following:

• When trying to read a file beyond indicator.
• When trying to read a file that does not exist.
• When trying to use a file that has not been opened.
• When trying to use a file in an inappropriate mode i.e., writing data to a file that has been opened for reading.
• When writing to a file that is write-protected i.e., trying to write to a read-only file.

Failure to check for errors then the program may behave abnormally therefore an unchecked error may result in premature termination for the program or incorrect output.

Below are some Error handling functions during file operations in C/C++:

ferror():

In C/C++, the library function ferror() is used to check for the error in the stream. Its prototype is written as:

 int ferror (FILE *stream);

The ferror() function checks for any error in the stream. It returns a value zero if no error has occurred and a non-zero value if there is an error. The error indication will last until the file is closed unless it is cleared by the clearerr() function. 

Below is the program to implement the use of ferror():

Output:

Explanation: After executing this code “Provide feedback on this article:“ will be displayed on the screen and after giving some feedback “Process exited after some seconds with return value 0″ will be displayed on the screen.

clearerr():

The function clearerr() is used to clear the end-of-file and error indicators for the stream. Its prototype can be given as:

void clearerr(FILE *stream);

The clearerr() clears the error for the stream pointed by the stream. The function is used because error indicators are not automatically cleared. Once the error indicator for a specific stream is set, operations on the stream continue to return an error value until clearerr(), fseek(), fsetpos(), or rewind() is called.

Below is the program to implement the use of clearerr():

Output:

The function perror() stands for print error. In case of an error, the programmer can determine the type of error that has occurred using the perror() function. When perror() is called, then it displays a message describing the most recent error that occurred during a library function call or system call. Its prototype can be given as:

void perror (char*msg);

• The perror() takes one argument which points to an optional user-defined message the message is printed first followed by a colon and the implementation-defined message that describes the most recent error.
• If a call to perror() is made when no error has actually occurred then ‘No error’ will be displayed.
• The most important thing to remember is that a call to perror() and nothing is done to deal with the error condition, then it is entirely up to the program to take action. For example, the program may prompt the user to do something such as terminate the program.
• Usually, the program’s activities will be determined by checking the value of errno and the nature of the error.
• In order to use the external constant errno, you must include the header file ERRNO.H

Below is the program given below illustrates the use of perror(). Here, assume that the file “file.txt” does not exist.

Output:

Довольно часто ошибки могут возникать при чтении данных из файла на C ++ или записи данных в файл. Например, ошибка может возникнуть по следующим причинам:

• При попытке прочитать файл за пределами индикатора.
• При попытке прочитать несуществующий файл.
• При попытке использовать файл, который не был открыт.
• При попытке использовать файл в соответствующем режиме, т. Е. При записи данных в файл, который был открыт для чтения.
• При записи в файл, защищенный от записи, т. Е. При попытке записи в файл, доступный только для чтения.

Если не выполнить проверку на наличие ошибок, программа может вести себя ненормально, поэтому непроверенная ошибка может привести к преждевременному завершению программы или неправильному выводу.

Ниже приведены некоторые функции обработки ошибок во время файловых операций в C / C ++:

феррор ():

В C / C ++ библиотечная функция ferror () используется для проверки наличия ошибки в потоке. Его прототип записывается так:

 int ferror (FILE *stream);

Функция ferror () проверяет наличие ошибок в потоке. Он возвращает нулевое значение, если ошибок не произошло, и ненулевое значение, если ошибка есть. Индикация ошибки будет длиться до тех пор, пока файл не будет закрыт, если он не будет очищен функцией clearerr () .

Ниже приведена программа для реализации использования ferror () :

Выход:

Объяснение: После выполнения этого кода на экране будет отображаться сообщение «Предоставьте отзыв об этой статье:», а после предоставления некоторой обратной связи на экране отобразится сообщение «Процесс завершился через несколько секунд с возвращаемым значением 0».

clearrr ():

Функция clearerr () используется для очистки индикаторов конца файла и ошибок для потока. Его прототип можно представить как:

void clearerr(FILE *stream);

Clearerr () очищает ошибку для потока, на который указывает поток. Функция используется, потому что индикаторы ошибок не очищаются автоматически. После того, как индикатор ошибки для конкретного потока устанавливается, операции на потоке продолжают возвращаться значение ошибки до clearerr (), FSEEK (), fsetpos () или перемотки назад () вызывается.

Ниже приведена программа для реализации использования clearerr () :

Выход:

Функция perror () означает ошибку печати. В случае ошибки программист может определить тип возникшей ошибки с помощью функции perror () . Когда вызывается perror () , он отображает сообщение, описывающее самую последнюю ошибку, которая произошла во время вызова библиотечной функции или системного вызова. Его прототип можно представить как:

void perror (char*msg);

• Perror () принимает один аргумент, который указывает на необязательное определяемое пользователем сообщение, сообщение печатается первым, за которым следует двоеточие и сообщение, определяемое реализацией, которое описывает самую последнюю ошибку.
• Если вызов perror () выполняется, когда на самом деле ошибок не было, то отображается сообщение «Нет ошибки».
• Самая важная вещь, о которой следует помнить, — это то, что при вызове perror () ничего не делается для исправления состояния ошибки, тогда принятие мер полностью зависит от программы. Например, программа может предложить пользователю что-то сделать, например, завершить программу.
• Обычно действия программы определяются путем проверки значения errno и характера ошибки.
• Чтобы использовать внешнюю константу errno , вы должны включить заголовочный файл ERRNO.H

Ниже приведенная ниже программа иллюстрирует использование perror () . Предположим, что файл «file.txt» не существует.

Выход:

Хотите учиться на лучших видео и практических задачах, ознакомьтесь с Базовым курсом C для базового и продвинутого C.

Признак достижения конца файла выставляется только после неудачной попытки чтения за его концом. Поэтому, если в теле цикла нет проверки, успешно ли выполнено чтение из файла — последнее чтение окажется именно тем неудачным чтением, которое выставит признак достигнутого конца файла (а для вас это будет выглядеть как, например, еще раз считанная последняя строка, если она находилась в буфере для чтения).

Лучше в заголовке цикла while выполнять само чтение с проверкой — например, в программе на C это могло бы выглядеть как

while(fread(&data,sizeof(data),1,file)==1)
{
    // Обработка считанных данных
}

/* Или, скажем,
while(fgets(buf, bufsize, file)) { .... }
*/


if (feof(file)) // Достигнут конец файла
    puts("Ошибка чтения: достигнут конец файла");
else if (ferror(file)) {
    puts("Ошибка чтения файла");

или на C++ — наподобие

for(int n; file >> n; ) 
{
   // Обработка считанного значения n
}

if (file.bad())
    std::cout << "Ошибка ввода-вывода при чтенииn";
else if (file.eof())
    std::cout << "Достигнут конец файлаn";
else if (file.fail())
    std::cout << "Неверный формат данныхn";

Долго я пытался решить проблему самостоятельно, а так же и искал ответы на форумах. Но в итоге не смог решить свою проблему.

Проблема в том, что я сохраняю свой класс в файл, и потом после перезапуска программы, когда в файле уже есть данные, то при компиляции идет логическая ошибка при чтении файла.

#include<iostream>
#include<windows.h>
#include<fstream>
#include<conio.h>

using namespace std;       

class Player{
public:
    Player(){
        age =  exp = 0;
        name = "player";
        level = 1;
        balance = 3000;
        HP = 100;
        nxtLvl = 500;
        damage = 150;
    }
    Player(int age, string name):Player(){
        this->age = age;
        this->name = name;
    }
    Player(const Player &obj){
        age = obj.age;
        name = obj.name;
        level = obj.level;
        balance = obj.balance;
        HP = obj.HP;
        nxtLvl = obj.nxtLvl;
        damage = obj.damage;
        exp = obj.exp;
    }
    string getName(){return name;}
    int getAge(){return age;}
    int getLevel(){return level;}
    int getHP(){return HP;}
    int getBalance(){return balance;}
    int getNxt(){return nxtLvl;}
    int getDamage(){return damage;}
    void printHero(){
        cout << name << " " << age << " лет.n" << level << " lvl.n"
        << "Бабки: " << balance << "$nЗдоровье: " << HP << " ХПn" << "Сила удара: максимум " << damage << "nОпыт: " << exp << "/" <<nxtLvl << "n";
    }
    void upLevel(){
        ++level;
        nxtLvl = nxtLvl * 2 + (nxtLvl/2);
        damage += (damage/10);
        }
    void addExp(int exp){this->exp += exp;}
    void addHealth(int health){HP += health;}
    void remHealth(int health){HP -= health;}
    void addDamage(int damage){this->damage += damage;}
private:
    int age, level, balance, HP, exp, nxtLvl, damage;
    string name;
};

void Arena();
void myHero();
void Shop();
main(){
    setlocale(LC_ALL, "rus");

    Player me;

    string path = "game_saves.txt";
    ofstream fout;
    fout.open(path, ofstream::app);
    fout.close();

    ifstream fin;
    fin.open(path);

    if(!fin.read((char*)&me, sizeof(Player))){
        cout << "Введите ваше имя:n";
        string name;
        cin >> name;
        system("cls");
        cout << "Введите сколько вам лет:n";
        int age;
        cin >> age;
        me = Player(age, name);
        ofstream fout;
        fout.open(path);
        fout.write((char*)&me, sizeof(Player));
        fout.close();
    }
    fin.close();
    system("cls");
     //int l; cin >> l;
    cout << "Hello " << me.getName() << "!n";

    cout << ">Новая играn Продолжить игруn";
    char c;
    int choose = 1;
    while(c != 13){
        c = _getch();
        if(c == 72){
            system("cls");
            cout << "Hello " << me.getName() << "!n";
            cout << ">Новая играn Продолжить игруn";
            choose = 1;
        }
        if(c == 80){
            system("cls");
            cout << "Hello " << me.getName() << "!n";
            cout << " Новая играn>Продолжить игруn";
            choose = 2;
        }
    }
    if(choose == 1){
        system("cls");
        cout << "Введите ваше имя:n";
        string name;
        cin >> name;

        cout << "Введите сколько вам лет:n";
        int age;
        cin >> age;
        ofstream fout;
        fout.open(path);
        fout.write((char*)&me, sizeof(Player));
        fout.close();
    }
    else{
        system("cls");
        cout << ">Аренаn Мой геройn Магазинn";
        char k='a';
        char vote = 1;
        while(k != 13){
            k = _getch();
            if(k == 72){
                system("cls");
                if(vote == 2){
                    cout << ">Аренаn Мой геройn Магазинn";
                    vote = 1;
                }
                if(vote == 3){
                    cout << " Аренаn>Мой геройn Магазинn";
                    vote = 2;
                }
            }
            if(k == 80){
                system("cls");
                if(vote == 1){
                    cout << " Аренаn>Мой геройn Магазинn";
                    vote = 2;
                }
                else{
                    cout << " Аренаn Мой геройn>Магазинn";
                    vote = 3;
                }
            }
        }
      /* if(vote == 1) Arena();
        if(vote == 2) myHero();
        if(vote == 3) Shop();*/    
    }    
}

void Arena(){    
}

Буду рад помощи. Прошу не ругаться, я начал изучать ООП и работу с файлами только позавчера.

Большинство компьютерных программ работают с файлами, и поэтому возникает необходимость создавать, удалять, записывать читать, открывать файлы. Что же такое файл? Файл – именованный набор  байтов, который может быть сохранен на некотором накопителе. Ну, теперь ясно, что под файлом понимается некоторая последовательность байтов, которая имеет своё, уникальное имя, например файл.txt. В одной директории  не могут находиться файлы с одинаковыми именами. Под именем файла понимается не только его название, но и расширение, например: file.txt  и file.dat — разные файлы, хоть и имеют одинаковые названия. Существует такое понятие, как полное имя файлов – это полный адрес к директории файла с указанием имени файла, например: D:docsfile.txt. Важно понимать эти базовые понятия, иначе сложно будет работать с файлами.

Для работы с файлами необходимо подключить заголовочный файл <fstream>. В <fstream> определены несколько классов и подключены заголовочные файлы <ifstream> — файловый ввод и  <ofstream>  — файловый вывод.

Файловый ввод/вывод аналогичен стандартному вводу/выводу, единственное отличие – это то, что ввод/вывод выполнятся не на экран, а в файл. Если ввод/вывод на стандартные устройства выполняется с помощью объектов cin и cout, то для организации файлового ввода/вывода достаточно создать собственные объекты, которые можно использовать аналогично операторам cin и cout.

Например, необходимо создать текстовый файл и записать в него строку Работа с файлами в С++. Для этого необходимо проделать следующие шаги:

1. создать объект класса ofstream;
2. связать объект класса с файлом, в который будет производиться запись;
3. записать строку в файл;
4. закрыть файл.

Почему необходимо создавать объект класса ofstream, а не класса ifstream? Потому, что нужно сделать запись в файл, а если бы нужно было считать данные из файла, то создавался бы объект класса ifstream.

// создаём объект для записи в файл
ofstream /*имя объекта*/; // объект класса ofstream

Назовём объект – fout, Вот что получится:

ofstream fout;

Для чего нам объект? Объект необходим, чтобы можно было выполнять запись в файл. Уже объект создан, но не связан с файлом, в который нужно записать строку.

fout.open("cppstudio.txt"); // связываем объект с файлом

Через операцию точка получаем доступ к методу класса open(), в круглых скобочках которого указываем имя файла. Указанный файл будет создан в текущей директории с программой. Если файл с таким именем существует, то существующий файл будет заменен новым. Итак, файл открыт, осталось записать в него нужную строку. Делается это так:

fout << "Работа с файлами в С++"; // запись строки в файл

Используя операцию передачи в поток совместно с объектом fout строка Работа с файлами в С++ записывается в файл. Так как больше нет необходимости изменять содержимое файла, его нужно закрыть, то есть отделить объект от файла.

fout.close(); // закрываем файл

Итог – создан файл со строкой Работа с файлами в С++.

Шаги 1 и 2 можно объединить, то есть в одной строке создать объект и связать его с файлом. Делается это так:

ofstream fout("cppstudio.txt"); // создаём объект класса ofstream и связываем его с файлом cppstudio.txt

Объединим весь код и получим следующую программу.

// file.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <fstream>
using namespace std;

int main(int argc, char* argv[])
{
    ofstream fout("cppstudio.txt"); // создаём объект класса ofstream для записи и связываем его с файлом cppstudio.txt
    fout << "Работа с файлами в С++"; // запись строки в файл
    fout.close(); // закрываем файл
    system("pause");
    return 0;
}

Осталось проверить правильность работы программы, а для этого открываем файл cppstudio.txt и смотрим его содержимое, должно быть — Работа с файлами в С++.

Для того чтобы прочитать файл понадобится выполнить те же шаги, что и при записи в файл с небольшими изменениями:

1. создать объект класса ifstream и связать его с файлом, из которого будет производиться считывание;
2. прочитать файл;
3. закрыть файл.

// file_read.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <fstream>
#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
    setlocale(LC_ALL, "rus"); // корректное отображение Кириллицы
    char buff[50]; // буфер промежуточного хранения считываемого из файла текста
    ifstream fin("cppstudio.txt"); // открыли файл для чтения

    fin >> buff; // считали первое слово из файла
    cout << buff << endl; // напечатали это слово

    fin.getline(buff, 50); // считали строку из файла
    fin.close(); // закрываем файл
    cout << buff << endl; // напечатали эту строку

    system("pause");
    return 0;
}

В программе показаны два способа чтения из файла, первый – используя операцию передачи в поток, второй – используя функцию getline(). В первом случае считывается только первое слово, а во втором случае считывается строка, длинной 50 символов. Но так как в файле осталось меньше 50 символов, то считываются символы включительно до последнего. Обратите внимание на то, что считывание во второй раз (строка 17) продолжилось, после первого слова, а не с начала, так как первое слово было прочитано в строке 14. Результат работы программы показан на рисунке 1.

Работа
 с файлами в С++
Для продолжения нажмите любую клавишу . . .

Рисунок 1 — Работа с файлами в С++

Программа сработала правильно, но не всегда так бывает, даже в том случае, если с кодом всё впорядке. Например, в программу передано имя несуществующего файла или в имени допущена ошибка. Что тогда? В этом случае ничего не произойдёт вообще. Файл не будет найден, а значит и прочитать его не возможно. Поэтому компилятор проигнорирует строки, где выполняется работа с файлом. В результате корректно завершится работа программы, но ничего, на экране показано не будет. Казалось бы это вполне нормальная реакции на такую ситуацию. Но простому пользователю не будет понятно, в чём дело и почему на экране не появилась строка из файла. Так вот, чтобы всё было предельно понятно в С++ предусмотрена такая функция — is_open(), которая возвращает целые значения: 1 — если файл был успешно открыт, 0 — если файл открыт не был. Доработаем программу с открытием файла, таким образом, что если файл не открыт выводилось соответствующее сообщение.

// file_read.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <fstream>
#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
    setlocale(LC_ALL, "rus"); // корректное отображение Кириллицы
    char buff[50]; // буфер промежуточного хранения считываемого из файла текста
    ifstream fin("cppstudio.doc"); // (ВВЕЛИ НЕ КОРРЕКТНОЕ ИМЯ ФАЙЛА)

    if (!fin.is_open()) // если файл не открыт
        cout << "Файл не может быть открыт!n"; // сообщить об этом
    else
    {
    fin >> buff; // считали первое слово из файла
    cout << buff << endl; // напечатали это слово

    fin.getline(buff, 50); // считали строку из файла
    fin.close(); // закрываем файл
    cout << buff << endl; // напечатали эту строку
    }
    system("pause");
    return 0;
}

Результат работы программы показан на рисунке 2.

Файл не может быть открыт!
Для продолжения нажмите любую клавишу . . .

Рисунок 2 — Работа с файлами в С++

Как видно из рисунка 2 программа сообщила о невозможности открыть файл. Поэтому, если программа работает с файлами, рекомендуется использовать эту функцию, is_open(), даже, если уверены, что файл существует.

Режимы открытия файлов

Режимы открытия файлов устанавливают характер использования файлов. Для установки режима в классе ios_base предусмотрены константы, которые определяют режим открытия файлов (см. Таблица 1).

Режимы открытия файлов можно устанавливать непосредственно при создании объекта или при вызове функции open().

ofstream fout("cppstudio.txt", ios_base::app); // открываем файл для добавления информации к концу файла
fout.open("cppstudio.txt", ios_base::app); // открываем файл для добавления информации к концу файла

Режимы открытия файлов можно комбинировать с помощью поразрядной логической операции или |, например: ios_base::out | ios_base::trunc — открытие файла для записи, предварительно очистив его.

Объекты класса ofstream, при связке с файлами по умолчанию содержат режимы открытия файлов  ios_base::out | ios_base::trunc. То есть файл будет создан, если не существует. Если же файл существует, то его содержимое будет удалено, а сам файл будет готов к записи. Объекты класса ifstream связываясь с файлом, имеют по умолчанию режим открытия файла   ios_base::in  — файл открыт только для чтения. Режим открытия файла ещё называют — флаг, для удобочитаемости в дальнейшем будем использовать именно этот термин. В таблице 1 перечислены далеко не все флаги, но для начала этих должно хватить.

Обратите внимание на то, что флаги ate и app по описанию очень похожи, они оба перемещают указатель в конец файла, но флаг app позволяет производить запись, только в конец файла, а флаг ate просто переставляет флаг в конец файла и не ограничивает места записи.

Разработаем программу, которая, используя операцию sizeof(), будет вычислять характеристики основных типов данных в С++ и записывать их в файл. Характеристики:

1. число байт, отводимое под тип данных
2. максимальное значение, которое может хранить определённый тип данных.

Запись в файл должна выполняться в таком формате:

/*  data type      byte          max value  
bool               =  1         255.00
char               =  1         255.00
short int          =  2         32767.00
unsigned short int =  2         65535.00
int                =  4         2147483647.00
unsigned int       =  4         4294967295.00
long int           =  4         2147483647.00
unsigned long int  =  4         4294967295.00
float              =  4         2147483647.00
long float         =  8         9223372036854775800.00
double             =  8         9223372036854775800.00  */

Такая программа уже разрабатывалась ранее в разделе Типы данных С++ , но там вся информация о типах данных выводилась на стандартное устройство вывода, а нам необходимо программу переделать так, чтобы информация записывалась в файл. Для этого необходимо открыть файл в режиме записи, с предварительным усечением текущей информации файла (строка 14). Как только файл создан и успешно открыт (строки 16 — 20), вместо оператора cout, в строке 22 используем объект fout. таким образом, вместо экрана информация о типах данных запишется в файл.

// write_file.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <iostream>
#include <fstream> // работа с файлами
#include <iomanip> // манипуляторы ввода/вывода
using namespace std;

int main(int argc, char* argv[])
{
    setlocale(LC_ALL, "rus");

    // связываем объект с файлом, при этом файл открываем в режиме записи, предварительно удаляя все данные из него
    ofstream fout("data_types.txt", ios_base::out | ios_base::trunc); 

    if (!fout.is_open()) // если файл небыл открыт 
    { 
     cout << "Файл не может быть открыт или созданn"; // напечатать соответствующее сообщение
     return 1; // выполнить выход из программы
    }

        fout << "     data type      "   << "byte"                      << "      "    << "    max value  " << endl // заголовки столбцов
             << "bool               =  " << sizeof(bool)                << "         " << fixed << setprecision(2) 
/*вычисляем максимальное значение для типа данных bool*/                           << (pow(2,sizeof(bool) * 8.0) - 1)               << endl
         << "char               =  " << sizeof(char)                << "         " << fixed << setprecision(2) 
/*вычисляем максимальное значение для типа данных char*/                           << (pow(2,sizeof(char) * 8.0) - 1)               << endl
         << "short int          =  " << sizeof(short int)           << "         " << fixed << setprecision(2) 
/*вычисляем максимальное значение для типа данных short int*/                      << (pow(2,sizeof(short int) * 8.0 - 1) - 1)      << endl
             << "unsigned short int =  " << sizeof(unsigned short int)  << "         " << fixed << setprecision(2) 
/*вычисляем максимальное значение для типа данных unsigned short int*/             << (pow(2,sizeof(unsigned short int) * 8.0) - 1) << endl
             << "int                =  " << sizeof(int)                 << "         " << fixed << setprecision(2) 
/*вычисляем максимальное значение для типа данных int*/                            << (pow(2,sizeof(int) * 8.0 - 1) - 1)            << endl
             << "unsigned int       =  " << sizeof(unsigned int)        << "         " << fixed << setprecision(2) 
/*вычисляем максимальное значение для типа данных unsigned int*/                   << (pow(2,sizeof(unsigned int) * 8.0) - 1)       << endl
             << "long int           =  " << sizeof(long int)            << "         " << fixed << setprecision(2) 
/*вычисляем максимальное значение для типа данных long int*/                       << (pow(2,sizeof(long int) * 8.0 - 1) - 1)       << endl
             << "unsigned long int  =  " << sizeof(unsigned long int)   << "         " << fixed << setprecision(2) 
/*вычисляем максимальное значение для типа данных undigned long int*/              << (pow(2,sizeof(unsigned long int) * 8.0) - 1)  << endl
             << "float              =  " << sizeof(float)               << "         " << fixed << setprecision(2) 
/*вычисляем максимальное значение для типа данных float*/                          << (pow(2,sizeof(float) * 8.0 - 1) - 1)          << endl
             << "long float         =  " << sizeof(long float)          << "         " << fixed << setprecision(2) 
/*вычисляем максимальное значение для типа данных long float*/                     << (pow(2,sizeof(long float) * 8.0 - 1) - 1)     << endl
             << "double             =  " << sizeof(double)              << "         " << fixed << setprecision(2) 
/*вычисляем максимальное значение для типа данных double*/                         << (pow(2,sizeof(double) * 8.0 - 1) - 1)         << endl;
        fout.close(); // программа больше не использует файл, поэтому его нужно закрыть
    cout << "Данные успешно записаны в файл data_types.txtn";
    system("pause");
    return 0;
}

Нельзя не заметить, что изменения в программе минимальны, а всё благодаря тому, что стандартный ввод/вывод и файловый ввод/вывод используются абсолютно аналогично. В конце программы, в строке 45 мы явно закрыли файл, хотя это и не обязательно, но считается хорошим тоном программирования. Стоит отметить, что все функции и манипуляторы используемые для форматирования стандартного ввода/вывода актуальны и для файлового ввода/вывода. Поэтому не возникло никаких ошибок, когда оператор cout был заменён объектом fout.

При открытии файла при помощи wifstream программа крашится и выдает такую ошибку. Файл формата txt существует и путь к нему указан верно. Может у кого нибудь была похожая проблема?

Код функции main:

#include "stdafx.h"

int _tmain(int argc, _TCHAR* argv[])
{
	//setlocale(LC_ALL, "rus");
	wifstream nja(L"text1.txt");
	if (!nja.is_open())
		cout<<"Ошибка!";
	Parm::PARM parm;
	cout << argc;
	cout << "---- Тест Error::geterror   ---" << endl << endl;
	try { ERROR_THROW(104); }
	catch (Error::ERROR e)
	{
		cout << "Ошибка " << e.id << ": " << e.message << endl << endl;
	};

	cout << "---- Тест Error::geterrorin   ---" << endl << endl;
	try { ERROR_THROW_IN(111, 7, 7); }
	catch (Error::ERROR e)
	{
		cout << "Ошибка " << e.id << ": " << e.message
			<< ", строка " << e.inext.line
			<< ", позиция " << e.inext.col << endl << endl;
	};

	cout << "---- Тест Parm::getparm   ---" << endl << endl;
	try
	{
		parm = Parm::getparm(argc, argv);
		wcout << L"-in:" << parm.in << L", -out:" << parm.out << L", -log:" << parm.log << endl << endl;
	}
	catch (Error::ERROR e)
	{
		cout << "Ошибка " << e.id << ": " << e.message << endl << endl;
	};
	cout << "---- Тест Parm::getin   ---" << endl << endl;
	try
	{
		In::IN in = In::getin(parm.in);
		cout << in.text << endl;
		cout << "Всего символов: " << in.size << endl;
		cout << "Всего строк: " << in.lines << endl;
		cout << "Пропущено: " << in.ignor << endl;
	}
	catch (Error::ERROR e)
	{
		cout << "Ошибка " << e.id << ": " << e.message << endl << endl;
	};
	system("pause");
	return 0;
}

Содержимое stdafx.h:
#pragma once

#include "targetver.h"

#include <fstream>
#include <iostream>
#include <tchar.h>
#include <stdio.h>
#include <cwchar>
#include <stdio.h>
#include <cstring>
#include <wchar.h>
#include <locale>

#include "Error.h"
#include "Parm.h"
#include "In.h"

using namespace std;