Работа с текстовым файлом в C++ для начинающих
Работа с текстовыми файлами в C++ вызывала у меня, как и у многих моих читателей вызывает, много вопросов. В C++ с текстовыми файлами работают в основном в двух стилях: в C++ стиле и в C стиле. Так уж вышло, что язык C++ является надмножеством языка C и отчего многое поддерживает из C.
В первых моих попытках работать с файлами я натыкался на всякое, в особенности на страшную конструкцию из языка C. Книг тогда я ещё не приобрёл, информацию искал плохо, отчего словил себе много трудностей. Всё, что я хотел в то время — это только лишь узнать, как записать в файл текст, введённый в консольное окно или в окно программы клавиатурой.
Поскольку этот сайт о C++, то описываться будет преимущественно C++ стиль. Параллельно будет показываться С стиль. Конечная программа в C стиле в листинге #10.4.
- Для работы с файлами нужно подключить специально для этого существующий файл. В C++ можно подключать как файл из непосредственно C++, так и файл из C. В зависимости от подключенного файла может использоваться один или другой стиль работы с файлами: для C++ стиля подключают заголовочный файл fstream (не путать с одноимённым типом).
- fstream — это специальный тип, с помощью которого можно одновременно как записывать в файл данные, так и считывать из файла их.
- ifstream — это специальный тип, с помощью которого можно только считывать из файла данные.
- ofstream — это специальный тип, с помощью которого можно только записывать в файл данные.
Подключаются файлы в самом начале программы:
|
1 2 |
#include <iostream> //для работы с клавиатурой #include <fstream> //для работы с файлами |
Первое время проще отдельно брать файл для записи и файл для чтения. Можно, конечно, брать и файл для одновременно либо записи, либо чтения, тогда отдельно брать два файла не имеет смысла.
В этих файлах описан специальный файловый тип. Чтобы мы могли обращаться к файлам, необходимо создавать переменные таких типов. Т. е. наши переменные будут связующим звеном программы и файлов. Фактически эти переменные будут воплощать сами файлы, и каждое обращение к таким переменным будет означать или "файл, дай мне", или "файл, возьми у меня". Файл будет брать или значение какой-то переменной, или передавать значение в какую-то переменную.
|
1 2 3 4 5 6 7 8 9 10 11 |
//Листинг #1 clang Работа с текстовым файлом #include <iostream> //для работы с клавиатурой #include <fstream> //для работы с файлами using namespace std; int main(){ ofstream f1; //переменная f1 отвечает за запись в файл ifstream f2; //переменная f2 отвечает за чтение файла } |
Файлы — это то, что хранится на носителях. К каждому файлу есть свой путь. Пока что мы не задействуем путь, а сохраним туда, куда компилятор сохраняет по умолчанию.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
//Листинг #2.1 clang Работа с текстовым файлом #include <iostream> //для работы с клавиатурой #include <fstream> //для работы с файлами using namespace std; int main(){ ofstream f1; //переменная f1 отвечает за запись в файл ifstream f2; //переменная f2 отвечает за чтение файла f1.open("myfile"); //Открываем файл для записи f1 << "Hello, world"; //Записываем в файл текст f1.close(); //закрываем открытый файл } |
По умолчанию файл сохраняется туда, где находится файл выполняемой программы (экзешник, бинарник). Где именно он находится, может зависеть от того, как и где создавался проект программы. Здесь придется полазить, поискать, понять, куда сохраняются файлы. В моём случае файл сохранился туда, где сохранён исходный код программы из листинга #2.1. Так же путь может быть прописан в настройках вашей IDE.
В С стиле всё выглядит приблизительно также, только используются не файловые объекты, а указатели, привязываемые к файлам:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
//Листинг #2.2 clang Работа с текстовым файлом в стиле C #include <stdio.h> using namespace std; int main(){ FILE *f1; FILE *f2; f1 = fopen("myfile_C.txt", "w"); //открываем файл для записи (w оначает write) fputs("Hello, world!!!", f1); //записываем строку в файл fclose(f1); //закрываем файл } |
Если всё правильно сделано, то файлы должны были записаться. Эти коды могут выглядеть немного иначе:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
//Листинг #3.1 clang Работа с текстовым файлом в стиле C++ #include <iostream> //для работы с клавиатурой #include <fstream> //для работы с файлами using namespace std; int main(){ ofstream f1("myfile"); //переменная f1 отвечает за запись в файл myfile ifstream f2("myfile"); //переменная f2 отвечает за чтение файла myfile f1 << "Hello, world"; //Записываем в файл текст f1.close(); //закрываем открытый файл } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
//Листинг #3.2 clang Работа с текстовым файлом в стиле C #include <stdio.h> using namespace std; int main(){ FILE *f1 = fopen("myfile_C.txt", "w"); //открываем файл для записи (w оначает write); FILE *f2; fputs("Hello, world!!!", f1); //записываем строку в файл fclose(f1); //закрываем файл } |
В листинге #3.1 ifstream и ofstream — это типы, эти типы — это классы, описанные в заголовочном файле fstream. У любых классов в C++ есть так называемые конструкторы классов. И такое указание значений в скобках при объявлении переменных чаще всего использование конструкторов.
|
1 2 3 4 5 |
int main(){ int a(10); //приблизительно то же самое, только здесь это не конструктор, //но поведение как у конструктора //переменная "а" инициализируется значением 10 } |
В C стиле в этом случае использовалась обычная инициализация.
Для чтения файлов будем использовать переменную f2. В С стиле Это сейчас не обязательно, но мне это нужно для чёткой параллели, для отражения принципа.
- В подавляющем числе случаев ошибки новичков с чтением файла связаны с неправильным указанием пути или имени файла.
Будьте очень внимательны к имени файла и к полному пути до него. Поскольку пока что файлы были созданы без явного указания пути, то и задействуем мы сейчас только имена файлов. В C++ стиле способ доступа к файлам определяется с помощью типов, а в C стиле с помощью специальных модификаторов. Запомнить модификаторы чтения и записи не сложно: "w" — означает write, т. е. запись, а "r" — означает read, т. е чтение. В С++ стиле тоже запись и чтение можно определить по одной букве: i означает input, т. е. устройство ввода (для нас сейчас клавиатура), а o означает output, т. е. устройство вывода (для нас сейчас экран)
- Считывая что-то из файла, нужно это что-то запоминать в переменную. После записи значения в переменную со значением можно делать что угодно.
- Сначала нужно читать файл, чем определять, существует ли он, иначе можно стереть данные файла.
ofstream в C++ по умолчанию перезаписывает файл, поэтому можно столкнуться с проблемой, что файл вроде как есть, но как будто данные с него не читаются, а не читаться они могут, потому что данные файла оказались стёрты:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
//Листинг #4 clang ofstream С++ по умолчанию стирает данные #include <iostream> //для работы с клавиатурой #include <fstream> //для работы с файлами using namespace std; int main(){ ofstream f1("myfile"); //переменная f1 отвечает за запись в файл myfile ifstream f2("myfile"); //переменная f2 отвечает за чтение файла myfile /* СЕЙЧАС ФАЙЛ УЖЕ ЗАПИСАН, ПОКА ЧТО ЭТИ СТРОКИ НЕ НУЖНЫ f1 << "Hello, world"; //Записываем в файл текст f1.close(); //закрываем открытый файл */ char S[255]; //строка в 255 символов. В неё мы будем запоминать строку из файла f2 >> S; f2.close(); //закрываем файл после использования cout << S << '\n'; //текст в файле оказался стёрт, поэтому ничего не вывелось } |
Казалось бы, что прочитать существующий файл не должно быть проблемой, но, как видите, существует довольно серьёзная опасность потерять данные, поэтому будьте особенно аккуратны к этому моменту и сначала пробуйте прочитать файл, а только потом что-то с файлом делать. Пока что перепишем файл, раскоментировав строки.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
//Листинг #4 clang ofstream С++ по умолчанию стирает данные #include <iostream> //для работы с клавиатурой #include <fstream> //для работы с файлами using namespace std; int main(){ ofstream f1("myfile"); //переменная f1 отвечает за запись в файл myfile ifstream f2("myfile"); //переменная f2 отвечает за чтение файла myfile f1 << "Hello, world"; //Записываем в файл текст f1.close(); //закрываем открытый файл char S[255]; //строка в 255 символов. В неё мы будем запоминать строку из файла f2 >> S; f2.close(); //закрываем файл после использования cout << S << '\n'; //текст в файле оказался стёрт, поэтому ничего не вывелось } |
Не забывайте запускать программу на исполнение, а то мало ли кто-то найдётся забывчивый. На то, что строка вывелась не полностью, внимания пока не обращаем, важнее не терять данные, т. е. сначала попробуем прочитать файл, а на основании результата выполним действие с файлом.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
//Листинг #5 clang работа с файлом #include <iostream> //для работы с клавиатурой #include <fstream> //для работы с файлами using namespace std; int main(){ ifstream f1("myfile"); ofstream f2; char S[255]; if (f1.is_open()){ //Проверяем открыт ли файл f1 >> S; //если открыт, записываем значение в S cout << S << '\n'; //выводим S на экран } else { //Если же не открыт, пробуем записать в файл значение f2.open("myfile"); //связываем f2 с файлом f2 << "Hello, world"; //записываем в f2 значение (это значение транзитом уйдёт в файл) } } |
В том случае, если файл создаётся не самой программой, обычно в случае ошибки открытия файла просто выводят сообщение о том, что файл не существут/не найден.
|
1 2 3 4 |
if (!f1.is_open()){ //Проверяем открыт ли файл cerr << "File not found" << '\n'; //тут выход из программы, функции, цикла и т. п. } |
Такая проверка в первое время может вас неоднократно выручить.
Теперь можно вернуться к тому, что выводится текст из файла не полностью. Мы записывали Hello, world, а видим только Hello. Связано это с операцией >>: она читает до первого пробельного символа. Это значит, что из файла можно прочитать текст словесными порциями. Под словесными порциями сейчас подразумеваются слова, которые могут оказаться с прикленными к ним знаками препинания (поскольку слово от знака препинания пробелом не отделяется, оно вместе со знаком препинания в некотором смысле тоже слово, но чтобы не путаться, я назвал такую сущность словесной порцией).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
//Листинг #6 clang работа с файлом #include <iostream> //для работы с клавиатурой #include <fstream> //для работы с файлами using namespace std; int main(){ ifstream f1("myfile"); ofstream f2; char S[255]; if (f1.is_open()){ f1 >> S; //считали первую порцию cout << S << '\n'; //выводим S на экран f1 >> S; //считали вторую порцию cout << S << '\n'; //выводим S на экран } else { f2.open("myfile"); f2 << "Hello, world"; } } |
В такой ситуации для чтения напрашивается цикл. Если бы было нужно прочитать много словесных порций, то заранее может быть неизвестно, какое в файле их количество, да и вручную слишком много писать неразумно. Это у нас сейчас текст и поэтому чтение словесных порций не выглядит чем-то толковым, но зато когда в файл записан массив чисел, словесные порции оказываются очень даже к месту. Но пока мы будем ориентироваться на текст, который есть.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
//Листинг #7 clang работа с файлом #include <iostream> //для работы с клавиатурой #include <fstream> //для работы с файлами using namespace std; int main(){ ifstream f1("myfile"); ofstream f2; char S[255]; if (f1.is_open()){ //Проверяем открыт ли файл while (f1 >> S){ //До тех пор, пока порции попадают в массив S cout << S << '\n'; //выводим на экран словесную порцию } } else { //Если же не открыт, пробуем записать в файл значение f2.open("myfile"); //связываем f2 с файлом f2 << "Hello, world"; //записываем в f2 значение (это значение транзитом уйдёт в файл) } } |
Ну, смысл должен быть понятен: если в файл, например, записаны слова через пробел, то каждое слово можно прочитать показанным способом, также, если записаны числа через пробел, то тоже. Но что делать, если нужно читать строку, а не словесные порции? Для этого не нужно использовать операцию >>.
- Для чтения разделённых пробелами слов или чисел из файла можно использовать операцию >>
- Для чтения непосредственно строк из файла нужно использовать функции чтения строк. Таких функций несколько. Одна — это функция getline объекта, а другая — это самостоятельная функция getline. Они имеют одинаковые названия, но работают разными способами.
Чтобы использовать функцию из объекта, нужно написать её через точку после объекта, а ей самой указать строку, в которую записывается значение, и указать число записываемых символов:
|
1 2 |
cin.getline(S, 255); //в строку S запишется максимум 255 символов, вводимых с клавиатуры f.getline(S, 255); //в строку S запишется максимум 255 символов, взятых из файлового объекта f |
Для того, чтобы работать с самостоятельной функцией getline, нужно использовать не массив или указатель как строку, а string (или любой подтип basic_string)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
//Листинг #8.1 clang работа с файлом читаем строку #include <iostream> #include <fstream> #include <string> //для самостоятельной getline using namespace std; int main(){ ifstream f1("myfile"); ofstream f2; string S; if (f1.is_open()){ while (getline(f1, S)){ //До тех пор, пока строка файла приходит в строку S cout << S << '\n'; //выводим на экран словесную очередную строку } } else { f2.open("myfile"); f2 << "Hello, world"; } } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
//Листинг #8.2 clang работа с файлом читаем строку #include <iostream> #include <fstream> using namespace std; int main(){ ifstream f1("myfile"); ofstream f2; char S[255]; if (f1.is_open()){ while (f1.getline(S, 255)){ //До тех пор, пока строка файла приходит в строку S cout << S << '\n'; //выводим на экран словесную очередную строку } } else { f2.open("myfile"); f2 << "Hello, world"; } } |
- Самостоятельная функция getline принимает в круглых скобках связывающую программу и файл переменную и строку, тип которой вхожит в множество подтипов basic_string (в начале подойдёт просто string).
- Функция из объекта принимает в круглых скобках или массив символов, или указатель на символьную строку и число символов в строке.
Если вы пишете в современных компиляторах, то предпочтение отдавайте самостоятельной getline и string.
Вообще, работа с файлами в C++ стиле очень напоминает работу с объектами cin и cout.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
//Листинг #9.1 clang #include <iostream> using namespace std; int main(){ char S[255]; cin.getline(S, 255); //Считать значение с клавиатуры cout << S << '\n'; //Вывести значение на экран } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
//Листинг #9.2 clang #include <fstream> #include <iostream> //для cout using namespace std; int main(){ char S[255]; ifstream f1; ofstream f2; //связывание f1 с каким-то файлом f1.getline(S, 255); //считать значение с файла f1 cout << S << '\n'; //Вывести значение на экран } |
И cin, и cout, и f1, и f2 в этих кодах — это потоковые объекты. То, что они потоковые, можно понять по названию заголовочных файлов, в которых содержится слово stream. Потоки могут быть разные, в нашем случае задействованы файловый поток и потоки ввода-вывода (их можно распознавать по первым символам перед stream в заголовочных файлах). А работают они приблизительно одинаково, потому что язык C++ так и проектировался, чтобы была одинаковая форма для операций с потоками.
В С стиле прочитать строку файла можно так (чтение строки без пробелов):
|
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 |
//Листинг #10.1 clang Работа с текстовым файлом в стиле C #include <stdio.h> #include <iostream> using namespace std; int main(){ FILE *f1; // чтобы не стереть данные, сразу для записи не открываем FILE *f2 = fopen("myfile_C.txt", "r"); //открываем файл для чтения (r) char S[255]; //строка, в которую будем записывать строку файла if (f2 == NULL){ cerr << "file not found\n"; //Если файл не был открыт, всообщаем об этом return 0; //завершаем программу (или можно ещё фрагмент программы) /* вместо завершения можно здесь выполнить код, создающий файл, тогда return надо убрать */ } else{ fscanf(f2, "%s", S); //читаем строку. cout << S << '\n'; } fclose(f1); //закрываем файл } |
Как и в случае с C++ нас подстерегает опасность затирания файла. Этого затирания необходимо избегать. Понять, открылся файл или нет, можно с помощью проверки указательной переменной, связываемой с файлом, на NULL. Указательные переменные — это те переменные, которые объявляются со звёздочками. В нашем случае связанная с файлом переменная — это f2 (поскольку мы ей говорили путь для открытия, то она получилась связанной с файлом, который мы пытаемся использовать). Поскольку этот сайт сосредоточен на C++, форматирование языка C при прочтении данных будет опущено, иначе придётся много расписывать лишнего. Суть здесь, что чтение происходит почти также, как считывание символов с клавиатуры, только имя функции не scanf, a fscanf и первым параметром принимает указатель, связанный с файлом.
- Скорее всего, вы сейчас имеете пустой файл, поэтому текст на эран может не выводится и текста об ошибке не происходить. В таком случае файл лучше перезаписать, а потом прочитать. Вы можете сделать это программно, а можете найти вручную, где находится файл, и внести в него данные.
Так же можно окрыть файл для дозаписи. Но в этом случае надо иметь в виду, что могут остаться следы старого содержания в файле, если этого умело не избежать. В любом случае, вариантов открытия файла несколько: дополнительно проверять пустоту файла или открывать файл для дозаписи.
Чтобы создать пустой файл (чтобы вернуться в ход темы), чтобы наверняка, можно поменять в листинге #10.1 строку с объявлением f2 на
|
1 |
FILE *f2 = fopen("myfile_C.txt", "w"); //открываем файл для записи (w) |
И запустить программу. Файл должен будет быть перезаписан. Т. е. должен появиться пустой файл. Потом верните модификатор чтения на место: вместо w напишите r. И изучайте код ниже.
|
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 |
//Листинг #10.2 clang Работа с текстовым файлом в стиле C #include <stdio.h> #include <iostream> using namespace std; int main(){ FILE *f1; // чтобы не стереть данные, сразу для записи не открываем FILE *f2 = fopen("myfile_C.txt", "r"); //открываем файл для чтения (r) char S[255]; //строка, в которую будем записывать строку файла char EMPTY_FILE = 0; /*ПРОВЕРКА ФАЙЛА НА ПУСТОТУ*/ fseek(f2,0,SEEK_END); long pos = ftell(f2); if (pos>0) { // файл непустой. rewind(f2); //возвращаем курсор в начало файла } else { EMPTY_FILE = 1; //обозначаем истинность утверждения "файл пустой" cout << "OK\n"; } /*КОНЕЦ ПРОВЕРКИ НА ПУСТОТУ*/ if (f2 == NULL || EMPTY_FILE){ cerr << "file not found\n"; //Если файл не был открыт, всообщаем об этом cout << "file will create\n"; //сообщаем, что файл будет создан f1 = fopen("myfile_C.txt","w"); fputs("Hello, world!", f1); fputs("str2", f1); } else{ fscanf(f2, "%s", S); cout << S << '\n'; } fclose(f1); //закрываем файл } |
Теперь если у вас был пустой файл, то первый запуск листинга #10.2 создаст новый файл, запишет в созданный файл две строчки. А во время второго запуска программа определит, что файл существует и он не пустой, и прочитает одну строку, значение которой мы запишем S. Два раза пришлось запускать программу, потому что у нас так определена ветка if…else. Если else не писать, то всё, что нужно, произойдёт при первом запуске: т. е. файл сначала в любом будет создан или обновлён, а потом уже независим от того, был ли он вообще, или был он пустым, выполнится чтение.
Лучше не писать много раз имя или путь к файлу, а отвести такому значению свою переменную.
|
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 |
//Листинг #10.3 clang Работа с текстовым файлом в стиле C #include <stdio.h> #include <iostream> using namespace std; int main(){ const char* PATH = "myfile_C.txt"; //отвели имени файла собственную константу FILE *f1; // чтобы не стереть данные, сразу для записи не открываем FILE *f2 = fopen(PATH, "r"); //открываем файл для чтения (r) char S[255]; //строка, в которую будем записывать строку файла char EMPTY_FILE = 0; //признак существования пустого файла if (f2){ /*ПРОВЕРКА ФАЙЛА НА ПУСТОТУ*/ fseek(f2,0,SEEK_END); long pos = ftell(f2); if (pos>0) { // файл непустой. rewind(f2); //возвращаем курсор в начало файла } else { EMPTY_FILE = 1; //обозначаем истинность утверждения "файл пустой" } /*КОНЕЦ ПРОВЕРКИ НА ПУСТОТУ*/ } if (f2 == NULL || EMPTY_FILE){ cerr << "file not found\n"; //Если файл не был открыт, сообщаем об этом cout << "file will create\n"; //сообщаем, что файл будет создан f1 = fopen(PATH,"w"); //для указания пути используется константа PATH fputs("Hello, world!\n", f1); fputs("str2\n", f1); fclose(f1); //закрыли файл } /*УБРАЛИ ELSE*/ if (!f2){ //Проверяем, что f2 открыто (то же, что [f2 == NULL] ) f2 = fopen(PATH, "r"); } fscanf(f2, "%s", S); cout << S << '\n'; fclose(f2); //закрываем файл } |
Обратите внимание, что закрытие связи f1 было перенесено. Если файл не открыт или окажется закрытым, то закрытие неоткрытого файла может повалить программу. И лучше проверять, что файл открыт: добавились проверки и перед проверкой на пустой файл и в других местах. Это может помочь хотя бы в то время, когда программа будет переписываться-улучшаться. Да. И как видите, чтобы записывать в файл строку, нужно разграничивать записываемые строки символом конца строки, иначе много строк будут записаны как одна строка, а это не то, что мы обычно делаем.
Прочитаем все строки. Если вы внимательный читатель, то можете вспомнить, что чтобы прочитать много строк, нужно задействовать цикл.
|
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 |
//Листинг #10.3 clang Работа с текстовым файлом в стиле C #include <stdio.h> #include <iostream> using namespace std; int main(){ const char* PATH = "myfile_C.txt"; //отвели имени файла собственную константу FILE *f1; // чтобы не стереть данные, сразу для записи не открываем FILE *f2 = fopen(PATH, "r"); //открываем файл для чтения (r) char S[255]; //строка, в которую будем записывать строку файла char EMPTY_FILE = 0; //признак существования пустого файла if (f2){ /*ПРОВЕРКА ФАЙЛА НА ПУСТОТУ*/ fseek(f2,0,SEEK_END); long pos = ftell(f2); if (pos>0) { // файл непустой. rewind(f2); //возвращаем курсор в начало файла } else { EMPTY_FILE = 1; //обозначаем истинность утверждения "файл пустой" } /*КОНЕЦ ПРОВЕРКИ НА ПУСТОТУ*/ } if (f2 == NULL || EMPTY_FILE){ cerr << "file not found\n"; //Если файл не был открыт, сообщаем об этом cout << "file will create\n"; //сообщаем, что файл будет создан f1 = fopen(PATH,"w"); //для указания пути используется константа PATH fputs("Hello, world!\n", f1); fputs("str2\n", f1); fclose(f1); //закрыли файл } /*УБРАЛИ ELSE*/ if (!f2){ f2 = fopen(PATH, "r"); } /*ЧИТАЕМ ВСЕ СТРОКИ*/ while ( fscanf(f2, "%s", S) != EOF){ cout << S << '\n'; }; fclose(f2); //закрываем файл } |
Обратите своё внимание, что мы записывали строки в файл, но читаем сейчас словесные порции одной строки. Это связано с тем, что scanf бьёт данные по разделителю, которым считает пробел. Это как с операцией >> в стиле C++. Чтобы прочитать строки, можно использовать fgets.
|
1 2 3 4 |
/*ЧИТАЕМ ВСЕ СТРОКИ*/ while(fgets(S, sizeof(S), f2) != NULL){ cout << ++i << " " << S; }; |
|
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 |
//Листинг #10.4 clang Работа с текстовым файлом в стиле C #include <stdio.h> #include <iostream> using namespace std; int main(){ const char* PATH = "myfile_C.txt"; //отвели имени файла собственную константу FILE *f1; // чтобы не стереть данные, сразу для записи не открываем FILE *f2 = fopen(PATH, "r"); //открываем файл для чтения (r) char S[255]; //строка, в которую будем записывать строку файла char EMPTY_FILE = 0; //признак существования пустого файла if (f2){ /*ПРОВЕРКА ФАЙЛА НА ПУСТОТУ*/ fseek(f2,0,SEEK_END); long pos = ftell(f2); if (pos>0) { // файл непустой. rewind(f2); //возвращаем курсор в начало файла } else { EMPTY_FILE = 1; //обозначаем истинность утверждения "файл пустой" } /*КОНЕЦ ПРОВЕРКИ НА ПУСТОТУ*/ } if (f2 == NULL || EMPTY_FILE){ cerr << "file not found\n"; //Если файл не был открыт, сообщаем об этом cout << "file will create\n"; //сообщаем, что файл будет создан f1 = fopen(PATH,"w"); //для указания пути используется константа PATH fputs("Hello, world!\n", f1); fputs("str2\n", f1); fclose(f1); //закрыли файл } /*УБРАЛИ ELSE*/ if (!f2){ f2 = fopen(PATH, "r"); } /*ЧИТАЕМ ВСЕ СТРОКИ*/ while(fgets(S, sizeof(S), f2) != NULL){ cout << S; }; if (f2){ fclose(f2); //закрываем файл } } |
Подводим промежуточные итоги:
- Работать с файлами в C++ можно в С стиле и в стиле С++. Пока вы пишете на C++, предпочтение лучше отдавать C++ стилю.
- Файл может оказываться в трёх состояниях: «существует и пустой, существует и не пустой, не существует» — каждое из этих состояний возможно нужно проверить.
- Сначала лучше открывать файл для чтения, проверять, что всё ОК, и только потом записывать данные в файл.
- Для работы со строками, содержащими пробельные символы, как в C++, так и в C нужно использовать специальные функции, которые умеют считывать словесные порции не до первого встреченного пробельного символа, а до признака конца строки.
- Одна из характерных проблем новичков — не делать проверки на успешное открытие файла. В связи с чем очень распространена ошибка — указаниt пути к файлу или имени файла.
- По умолчанию, т. е. без указания полного пути, а с указанием только имени файла, файлы могут сохраняться в ту папку, где оказывается исполняемый файл. Путь сохранения файла можно указывать явно.
Если путь указывается явно, то в случае несуществования какой-то части папок в пути, файл создан не будет:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
//Листинг #11.1 clang Работа с текстовым файлом Задание полного пути #include <fstream> #include <iostream> using namespace std; int main(){ const char* PATH = "A:/cpp/myfile"; //отвели имени файла собственную константу ifstream fin; ofstream fout; fout.open(PATH); if (!fout.is_open()){ cerr << "error\n"; } fout.close(); } |
У меня есть диск A:/, но на нём нет папки cpp, поэтому попытка записи файла оказывается неудачной.
- При указании полного пути нужно или чтобы путь уже существовал, или создать необходимые папки на пути для расположения сохраняемого файла в конечной папке.
Создавать путь можно как вручную, так и программно. Мы обойдёмся созданием пути вручную. Определитесь с диском (у мало кого из вас может оказаться логический диск A:\). Я же использую свой существующий. На своём диске я создам папку cpp. После этого запущу программу #11.1 и файл будет создан в той папке. Поскольку данные я не записывал, файл будет создан пустым.
17 комментариев на «“Работа с текстовым файлом в C++ для начинающих”»
Добавить комментарий
Случайная книга в электронном формате
Спасибо огромное за урок!!Ваш урок очень сильно мне помог)
Говно это все.
Херня, а не урок.
Вася, шел бы ты отсюда. Автор красавчик. Так держать
Прошу прощения, уважаемый, но использование «using namespace std;» не разумно и бывает опасно в проектах. А ещё это говорит о не самом лучшем вкусе программиста.
Подскажите, как считать информацию с нескольких файлов?
Вот к примеру я записал один файл и считал с него 2 строки. Затем я захотел прочитать другой файл(уже существующий) и вывести его информацию на экран. Но выдает ошибку.
Ошибки:
[C++ Error] UnitText.cpp(24): E2238 Multiple declaration for 'in'
[C++ Error] UnitText.cpp(19): E2344 Earlier declaration of 'in'
Как-то он фальшива выдал мой код. Вообщем на повторный запрос чтения файл мой компил ругается. Подскажите как это исправить или что я делаю не правильно?
Спасибо большое! Полезная информация для работы с вашими самостоятельными заданиями.
😎
Самый толковый урок, находил другие, где код в 30 строк и с применением 100500 других библиотек, хотя мне нужно было лишь вывести данные. Огромное спасибо!
Большое спасибо за урок!
Получилось скомпилить код в линуксе с небольшими изменениями. Если кому интересно то такой код работает в линуксе
#include <fstream>
#include <iostream>
using namespace std;
int main()
{
ofstream out(«/home/dima/Develop/lp/tmp/config_test.ini»); //ofstream — это тип данных. Внутри скобок параметр, принимаемый конструктором объявленного объекта out<<«HelloWorld<<«\n»; //Записываем первую строчку
out<<«UraRabotaet!!!»; //Записываем вторую строчку
out.close(); //Закрываем файл
return 0;
}
Этот код должен работать если его вставлять в готовую программу между заголовочными файлами и формой?
Не подскажите, как присвоить значения переменным в начале работы программы, если их значения нужно хранить в файле?
Подскажите, к кому обратиться за помощью в написании программки на с++, краткий смысл — чтение числа из текстового файла, вывод его на лпт-порт, чтение числа с порта, запись в другой текстовый файл, подробнее в личке. Обращение к ЛПТ на с++ нашёл, а с чтением-записью не получается. Учить язык с++ времени нет, основная программа будет на другом языке, который с ЛПТ не дружит и считывать будет из текстовых файлов.
Скажите пожалуйста, как в текстовый файл в определённую строку ввести текст (у меня 57 строк, а мне нужно в 26 или в какую-нибудь другую).
Допиливать надо. мне лень. Можно делать вообще по другому. Но так как условий мало, то берите, что даю.
Добрый вечер, уважаемый автор -реально полезный туториал. У меня вопрос- если нужно считать информацию с одного текстового файла а затем сохранить в другой файл тот же самый текст, но уже разбитый на колонки длиною Х, где икс равен числу которое вводишь сразу после названия (расположения файла в командной строке).
то есть вводишь имя файла и количество знаков (икс) и в новом файле появляются колонки со строками длиною икс. Плюс проблемка так же в том , что пробелы тоже учитываются как знаки
Заранее спасибо,
Простое форматирование.
Какой текст и в каких местах его разбивать на колонки мне откуда знать?
Такой вопрос, а как сделать так, чтобы мы сами в переменую задали путь к файлу в который будем вносить данные?
Только нужно дополнительно проверки делать, если каталога не существует, то не запишет, поэтому либо записывать в уже существующий каталог, либо создавать каталог перед записью.
отличный материал для новичков
Отличная статья