Работа с файлами С++. Проверки, для начинающих
В этой статье описываются некоторые особенности подхода к обработке файлов, когда используется С++ стиль работы с файлами.
ВНИМАНИЕ!
- В этой теме используется работа с файлами: обработка файлов текстового формата. Чтобы осилить эту статью, необходим навык программирования в С++ простого чтения и записи текстового файла.
В целом, работа с файлами мало отличается от работы с клавиатурным вводом, только вместо клавиатуры у нас файл. В отличие от файла в клавиатуры мы, разумеется, записать информацию обычно не можем. На самом еле можем конечно перепрограммировать клавиши, но это уже другая история. Часто нужно или просто удобно работать именно с файлами. При работе с файлами хороший программист обязательно добавит некоторых проверок, чтобы и самому не тупить, и чтобы программа работала правильно, а если происходил бы сбой, то чтобы этот сбой каким-нибудь образом сообщался.
Одной из обязательных проверок является проверка открытия файла. Программа, обращаясь к файлу, может не найти файл или не смочь открыть файл из-за ограниченных прав доступа. Если файл находится в одном каталоге, а программа ищет в другом месте, то или откроется не тот файл (и представляете, нужный файл испортится после записи) или вообще не откроется, потому что описанный программе путь никуда не ведёт. Если файл не существует — то и открывать вообще нечего. Новички часто мучаются при работе с файлами по той простой причине, что часто пишут путь не тот, а потом задаются вопросом: "Почему не работает?". Чтобы найти себе спасение, сэкономить нервы и время, нужно проверять файл на успешное открытие, всегда! Такая проверка в современных компиляторах (на момент записи этой строки идёт 2018г.) возможна, например, так:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
//clang Проверка файла но открытость Листинг #1.1 #include <fstream> //Для работы с файлами #include <iostream> //Для работы с клавиатурой и монитором using namespace std; int main(){ ifstream f1; f1.open("C:\\MyFile.txt"); if (!(f1.is_open())){ cout << "File not find\n"; cout << "exit"; cin.get(); //Это если окошко сразу закрывается, задерживаем return -1; } else { cout << "Process began\n"; //Обработка файла cout << "Process finished\n"; } cin.get(); //Это если окошко сразу закрывается, задерживаем } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
//Borland C++ 3.1 Проверка файла но открытость Листинг #1.2 #include <fstream.h> //Для работы с файлами #include <iostream.h> //Для работы с клавиатурой и монитором #include <conio.h> int main(){ clrscr(); ifstream f1; f1.open("C:\\MyFile.txt"); if (!(f1.good())){ cout << "File not find\n"; cout << "exit"; cin.get(); //Чтобы сразу не закрывалось окошко return -1; } else { cout << "Process began\n"; //Обработка файла cout << "Process finished\n"; } cin.get(); return 0; } |
Предпочтительнее is_open(), но некоторые компиляторы такое не умеют, тогда остаётся вариант похуже: good().
- Метод is_open() возвращает true, если файл открыт успешно, поэтому выражение !inFile.is_open() даёт в результате true, если попытка оказывается неудачной.
- Если ваш компилятор не поддерживает is_open(), можете воспользоваться вместо него методом good(). Метод good() не проверяет возможные проблемы настолько тщательно, как это делает is_open ().
Для того, чтобы программа не выдавала сообщение об ошибке, нужно, чтобы и существовал сам файл, и путь к файлу был в программе написан правильно. На страницах моего сайта в угоду легкочитаемости показанная проверка пропускается, но это не значит, что правильно её вообще не использовать, просто я решил облегчить участь читателю, изучающему коды в моих статьях. Правильно — однозначно, использовать показанную проверку.
Кроме того, что может быть проблема с открытием файла, могут быть проблемы, возникающие при обработке файла: в файле может оказаться недопустимое значение, и кто его знает, сколько ещё возможных барьеров может возникнуть прямо во время прочтения файла. Но не только во время прочтения, даже во время записи доступ к файлу может быть прерван. В общем, нужны проверки, проверки, проверки.
Запись в файл, позволяющая предупреждать о возникшей проблемы выглядит, возможно, страшно, но страшнее получать проблемы в реальных программах, поэтому лучше конечно серьёзно подходить к проверкам открытия и чтения файлов:
===========================================================================
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
//clang Листинг #2.1 Запись информации в файл Проверки #include <fstream> //Для работы с файлами #include <iostream> //Для работы с клавиатурой и монитором using namespace std; int main(){ const char *PATH = "C:\\MyFile\\1.txt"; const int N = 256; //максимальная длина строки S char S[N] = {}; //Строка, записываемая в файл unsigned short ERROR = 0; //Это переменная для отслеживания ошибки ofstream f1(PATH); //f1 у нас воплощает сам файл if (f1.is_open()){ //Если воплощение файла засуществовало (т. е. если файл открылся), то выполняем блок действий for (int i=0; i< 10; i++){ cout << "S[" << i << "]: "; cin.getline(S, N); f1 << S << '\n'; }; } else { ERROR = 1; //Если воплощение файла не засуществовало, то обозначаем это } switch (ERROR){ case 1: cout << "file no opened\n"; break; //Обозначаем, что файл не открылся case 2: cout << "file corrupted\n"; break; //Обозначаем, что файл открылся, но что-то с ним случилось } f1.close(); //Завершаем работу с f1 if (!ERROR){ //Если не произошло ошибки, то выполняет блок действий //тут можно работать с массивом, заполненным из файла, например } cin.get(); } |
В идеале ещё добавить запись лога, т. е. записывать в отдельный файл инофрмацию об успешности или неудаче последней попытки записи. Я не хочу усложнять пример навешиванием логриующей части, а до функций и классов, которые могли бы помочь раскидать всё по полочкам, темы, даваемые на моём сайте, ещё до дошли. Поэтому ограничусь записью в файл в том виде, который сейчас получился.
Но даже эти проверки не дают 100% гарантии, что ваша программа не даст слабину в неподходящий момент. Есть такие тонкости, когда стандартный С++ не очень способствует решениям. Тем не менее, это основная форма записи. Т. е. файл просто проверяется на открытость. Коли файл открыт, то, значит, есть во что записывать.
Проверки чтения файла мало отличаются от проверок во время записи. Всё также: нужно проверять. А при чтении проверять надо на удачное к файлу обращение, считываемую из файла информацию. Но не всегда понятно, сколько именно из файла информации будет прочитано, поэтому добавляется проверка на достижение конца файла. Сейчас я напишу пример просто чтения. Потом соберу и чтение и запись в одном коде.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 |
//clang Листинг #2.2 Чтение файла Проверки #include <fstream> //Для работы с файлами #include <iostream> //Для работы с клавиатурой и монитором using namespace std; int main(){ const char *PATH1 = "C:\\MyFiles\\1.txt"; const int N = 256; //максимальная длина строки S char S[N] = {}; //Строка, записываемая в файл unsigned short ERROR = 0; //Это переменная для отслеживания ошибки ifstream f1(PATH1); //f1 у нас воплощает сам файл if (f1.is_open()){ //Если наша программа смогла открыть файл, то выполняеи блок действий while (f1.good()){ //Пока ввод успешен и не достигнут конец файла, читаем из файла данные // f1 >> S; //читаем f1.getline(S,N); cout << S << '\n'; } if (!f1.eof()){ //Если НЕ достигнут конец файла, то выполняем блок действий if (f1.fail()){ ERROR = 2; //Если считываемое значение не соответствует типу принимающего значение } else{ ERROR = 3; //Обозначаем неизвестную ошибку } } } else { ERROR = 1; //1 будет обозначать, что наша программа файл открыть не смогла } switch (ERROR){ case 1: cout << "file no opened\n"; break; //Обозначаем, что файл не открылся case 2: cout << "Input terminated by data mismatch.\n"; break; //Обозначаем, что сбор информации прерван из-за несоответствия типов case 3: cout << "unknown error.\n"; break; //Обозначаем, что сбор информации прерван из-за неопознанной ошибки } f1.close(); //Завершаем работу с f1 if (!ERROR){ //Если не произошло ошибки, то выполняет блок действий //тут можно работать с массивом, заполненным из файла, например } cin.get(); } |
Такая вот проверка на чтение. Комменарии обо всём говорят. Выкрутасов тут вообще нет. У разных товарищей можно видеть разные вариации, но суть сводится к непосредственно проверке на открытость файла и проверки на достижение конца файла. Проверку цикла прочтения можно делать немного наоборот:
|
1 2 3 4 5 6 7 8 9 10 11 |
while (f1.good){...} if (inFile.eof ()) // Достигнут конец файла cout << "End of file reached. \n"; else if (inFile.fail ()) // Ввод прекращен из-за несоответствия типа данных cout << "Input terminated by data mismatch.\n"; else // Ввод прекращен по неизвестной причине cout << "Input terminated for unknown reason.\n"; |
По сути это то же, что у меня, просто вывернуто наоборот. Но по вот этому примеру пояснить один момент проще:
- Этот код находится сразу после цикла чтения информации из файла, поэтому он исследует, почему цикл был прерван. Поскольку eof() проверяет только EOF, a fail() проверяет как EOF, так и несоответствие типа, здесь вначале проверяется именно EOF. Таким образом, если выполнение дойдет до else if, то достижение конца файла (EOF) как причина выхода из цикла будет исключена, и значение true, полученное от fail(), недвусмысленно укажет на несоответствие типа.
В общем, от наиболее узкой проверки двигаемся к наиболее широкой, чтобы более точно диагностировать проблему. А саму проверку включаем сразу после цикла чтения.
- good() сообщает о самой последней попытке чтения ввода
Т. е. перед тем как обращаться к good() надо что-то считать из файла.
Две вариации кода, с отображением предпочтительнотси (код сокращается и некоторые потенциальные проблемы предотвращаются):
|
1 2 3 4 5 |
//Листинг #a1.1 f >> value; while (f.good()){ //чтение и проверка успешности f >> value; //читаем из файла значение в переменную value } |
|
1 2 3 4 |
//Листинг #a1.2 //предпочтительная форма форме 1.1 while (f >> N){ //чтение и проверка успешности тело цикла } |
|
1 2 3 4 5 |
//Листинг #a2.1 f.getline(value,N); while (f.good()){ //чтение строки и проверка успешности f.getline(value,N); //читаем из файла значение в переменную value } |
|
1 2 3 4 |
//Листинг #a2.2 //предпочтительная форма форме 2.1 while (f.getline(S,N)){ //чтение и проверка успешности тело цикла } |
В листингах a1 и a2 — f обозначает воплощение файла, а value переменную, в которую записывается прочитанное из файла значение. N — то возможная вместимость строки S (это знакомо тем, кто уже успел попрограммировать программы со строками). Поскольку good() надо смотреть после прочтения значения, то необходимо выполнить первое чтение до начала выполнения цикла, иначе бы на первом шаге цикла подобно использованию неинициализированной переменной могла произойти лотерея, поэтому в листинге a1 первое считывание происходит до начала выполнения цикла. Но С++ позволяет сократить код таким образом, как показано в лстинге a2. Лучше использовать вторую форму (она даже может избавить вас от некоторых мелких проблем). Объяснить новичку это немного проблемно, просто знайте, что часто применяют именно вариант из листинга a2, потому что он короче.
Подводим краткие итоги:
- При работе с файлами нужно особое внимание уделять проверкам.
- К файловой переменной можно приписывать точку, тогда можно выбрать подходящий для проверки метод.
- is_open() — проверяет файл на открытость, если is_open() не поддерживается вашим компилятором, то остаётся использовать good().
-
good() — даёт знать произошла ли операция чтения успешно. Если произошла ошибка, то возвращается false, если всё хорошо — то true.
- is_good логично смотреть после прочтения некоторого значения из файла, но С++ позволяет сокращать код, отчего можно подумать, что значение не зачитывается (хотя на самом деле в короткой показанной форме листингов a1.2 и a2.2 сначала значение считывается, а потом нам отдаётся good там всё или не good, отдаваемое мы можем подсмотреть, чем и занимемся)
- fail() — можно использовать для проверки на несоответствие типов считываемого из файла значения и переменной-реципиента. (реципиент — это антоним слова "донор")
- eof() — используют для проверки на достижение конца файла. (Не путайте с EOF, обозначающим символ-признак конца файла)
good()
Операция выполнена успешно
eof()
Достигнут конец ввода (например, конец файла)
fail()
Произошло нечто неожиданное (например, мы ждем цифру , а получаем букву)
bad()
Произошло нечто неожиданное и серьезное (например, ошибка чтения диска)
К сожалению, различия между состояниями fail() и bad() определены неточно и зависят от точки зрения программистов, создающих операции ввода-вывода для новых типов. Однако основная идея проста: если обнаруживается простая ошибка форматирования, поток переключается в состояние fail(), предполагая, что вы (мы) способны её исправить. Если же произошло нечто совершенно ужасное, например, неправильное чтение с диска, то поток оказывается в состоянии bad(), предполагая, что вам (нам) ничего не остаётся делать, кроме как отказаться от попыток считать данные из потока. Поток в состоянии bad() находится также и в состоянии fail().
Поток — это наша файловая переменная-объект, которая имеет отношение к файлу (в общем случае потоковые переменные далеко не только к файлам относятся). Просто их часто обозначают словом "поток". Потоки — это отдельная тема. Частный случай потоков — это файловые потоки, и я описываю здесь работу с файлами, поэтому файлами и ограничусь.
Объединим две программы в одну. Я покажу вариант очень для новичков, как можно собрать всё в main(). Это не значит, что так надо: так как раз не надо, позднее вы познокомитесь с функциями и классами, которые помогут вам (читающим меня новичкам) писать коды лучше.
В показываемом коде произойдут некоторые изменения: файлы будут открываться не сразу, а по мере необходимости. И будет добавлен счётчик счёта считанного. Пример ориентирован на работу с текстовым файлом со строками, поэтому будут считаться строки.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 |
//clang Листинг #3 Запись и чтение (объединяем в одну программу) #include <fstream> //Для работы с файлами #include <iostream> //Для работы с клавиатурой и монитором using namespace std; int main() { const char *PATH = "C://MyFiles//2.txt"; const int N = 256; //максимальная длина строки S char S[N] = {}; //Строка, записываемая в файл unsigned short ERROR = 0; //Это переменная для отслеживания ошибки ofstream f1; //f1 у нас воплощает сам файл, с которого будем читать ifstream f2; //f2 то же самое воплощение, но для записи unsigned short count = 0; //Это счётчик значений, прочитанных из файла unsigned short select; //Это переменная для выбора, будем делать мини-меню cout << "1. Read file" << endl; cout << "2. write file" << endl; (cin >> select).get(); if (2 == select) { f1.open(PATH); //Если выбрали 2, то записываем if (f1.is_open()) { //Если воплощение файла засуществовало (т. е. если файл открылся), то выполняем блок действий for (int i = 0; i< 10; i++) { cout << "S[" << i << "]: "; cin.getline(S, N); f1 << S << '\n'; }; } else { ERROR = 1; //Если воплощение файла не засуществовало, то обозначаем это } f1.close(); } //end if 2 == select else if (1 == select) { cout << "\n===========\nstart read\n===========\n"; f2.open(PATH); if (f2.is_open()) { //Если наша программа смогла открыть файл, то выполняеи блок действий while (f2.getline(S, N)) { //Пока ввод успешен и не достигнут конец файла, читаем из файла данные cout << S << '\n'; count++; } if (!f2.eof()) { //Если НЕ достигнут конец файла, то выполняем блок действий if (f2.fail()) { ERROR = 2; //Если считываемое значение не соответствует типу принимающего значение } else { ERROR = 3; //Обозначаем неизвестную ошибку } } } else { ERROR = 1; //1 будет обозначать, что наша программа файл открыть не смогла } f2.close(); cout << "\n===========\nend read\n===========\n"; } switch (ERROR) { case 1: cout << "file no opened\n"; break; //Обозначаем, что файл не открылся case 2: cout << "file corrupted\n"; break; //Обозначаем, что файл не открылся case 3: cout << "unknown error\n"; break; //Обозначаем, что ошибка неопознана } if (!ERROR) { //Если не произошло ошибки, то выполняет блок действий //тут можно работать с массивом, заполненным из файла, например if (!count) cout << "Empty file\n"; //Если ошибок не возникло, то скорее всего файл пустой cout << "finished\n"; cout << "read " << count << "value" << '\n'; //было прочитано count значений } cin.get(); } |
Как было отмечено, этот показанный код дан только в учебных целях. Но по нему хорошо можно видеть, что код достаточно распух. Когда код становится таким неудобным, это повод выносить разделять внутренние подзадачи на отдельные функции: запись организовать в одной функции, чтение в другой, проверку на ошибки в третьей. Вы же должны обратить внимание на метод open(), появившейся в этом коде. Этот метод позволяет нам обращаться к разным файлам в ходе работы программы: открыть один файл, открыть другой. Если бы я оставил всё как показано в первых листингах, где сразу определяется, какой именно файл будет открыт, то получил бы усечение файла до нулевого размера. Вы можете попробовать написать:
Тогда, что бы в файле изначально записано не было, оно просто перезапишется. В общем, иногда имеет смысл отложить открытие файла до нужного момента. Ещё обратите внимание, что я использую две переменные-объекта: f1 и f2 — это потому что одна в показанном коде записывает файл, а другая читает файл.
|
1 2 3 |
unsigned short ERROR = 0; //Это переменная для отслеживания ошибки ofstream f1(PATH); //f1 у нас воплощает сам файл, с которого будем читать ifstream f2; |
Тогда, что бы в файле изначально записано не было, оно просто перезапишется. В общем, иногда имеет смысл отложить открытие файла до нужного момента. Ещё обратите внимание, что я использую две переменные-объекта: f1 и f2 — это потому что одна в показанном коде записывает файл, а другая читает файл.
На этом, наверное, закончу, если что, сильно не бейте, а будет что подсказать или чем помочь — то можете поспособствовать улучшению этого текста. Мне остаётся надеяться, что эта страница помогла узнать что-то кому-то нужное и продвинуться в своём обучении хоть ненамного.
Использованные материалы:
12 комментариев на «“Работа с файлами С++. Проверки, для начинающих”»
Добавить комментарий
Случайная книга в электронном формате
подскажите, что делает (return -1) и тогда соответственно (return 0)?
В моём случае ничего полезного.
return 0, используемое в функции main(), только-лишь сообщает операционной системе, что программа успешно завершилась.
return -1 могло бы использоваться для работы с внешними программами. Т. е. какая-нибудь внешняя программа могла бы использовать написанную мной, по -1 можно было бы легко выявить, что моя эта программа задачу свою не выполнила и, например, сообщить об этом пользователю. -1 необязательное значение, а взятое с потолка. Т. е. любое можно использовать, достаточно будет знать, что оно должно обозначить (в моём случае неоткрытие файла).
что то не пойму как организовать в проге проверку методом fail(). он пишется после цикла считывания с файла или само считывание пишется в- цикл() {if ( f2.fail() ){ f2.get() = переменная;}} ?
что то не пойму как организовать в проге проверку методом fail(). он пишется после цикла считывания с файла или само считывание пишется в- цикл() {if ( f2.fail() ){ f2.get() = переменная;}} ?
У меня в примере сначала проверяется, что файл успешно открыт. Потом проверяется fail, т. е. успешность прочитанности значения. В случае неуспеха выбирается поведение диагностики ошибки. В моём случае ошибке присваивается номер и запоминается в переменную ERROR.
fail переводится как неудача. Если компилятор прочитал что смог и всё поломалось, то или достигнут конец файла, или не соответствует тип для записи в переменную значения. Поскольку дальнейшее чтение не имеет смысла, нужно зафиксировать проблему удобным способом.
admin, я больше интересовался для выхода из цикла «фэйлом», если прочитанный символ в переменную из файла оказался не того типа как у переменной; если это имеет смысл вообще
Если проверять на fail(), то это как проверять на eof().
Только fail() включает в себя и проверку на eof() и проверку на успешное считывание.
Я не могу понять, чего Вы понять не можете.
я написал программу в которой хотел, чтоб если на пути считывания f2.get()-ом в переменную типа чар попадала цифра, то считывание прекращалось и выводило на каком символе произошел конец. но у меня несколько раз, то ничего не выводило, то выводило все подряд до EOF
char — целочисленный тип.
цифра — целое число
Читаем в целочисленный тип целое число и ждём, что сломается? Не дождётесь.
а разве char это не символьный тип?
Я его называю целочисленным типом с символьным представлением. Т. е. для компьютера он ничем не отличается от числа, а для нас как символ.
То, что мы его видим как символ, — это только умение cout его так выводить.
Программисты С, например, сами указывают какой тип ожидается на выходе (у них нету cout).
Всё, что можно делать с целыми числами, — всё можно делать с типом char.
Называем мы этот тип символьным скорее по традиции и для ясности, но не потому что так есть на самом деле.