Ввод данных из файла и вывод в файл в языке программирования С
До этого при вводе-выводе данных мы работали со стандартными потоками — клавиатурой и монитором. Теперь рассмотрим, как в Си реализовано получение данных из файлов и запись их туда. Перед тем как выполнять эти операции, надо открыть файл и получить доступ к нему.
В языке программирования C указатель на файл имеет тип FILE и его объявление выглядит так:
FILE *myfile;
С другой стороны, функция fopen() открывает файл по указанному в качестве первого аргумента адресу в режиме чтения «r», записи «w» или добавления «a» и возвращает в программу указатель на него. Поэтому процесс открытия файла и подключения его к программе выглядит примерно так:
myfile = fopen("hello.txt", "r");
Примечание. В случае использования относительной адресации текущим/рабочим каталогом в момент исполнения программы должен быть тот, относительно которого указанный относительный адрес корректен. Место нахождения самого исполняемого файла не важно.
При чтении или записи данных в файл обращение к нему осуществляется посредством файлового указателя (в данном случае, myfile ).
Если в силу тех или иных причин (нет файла по указанному адресу, запрещен доступ к нему) функция fopen() не может открыть файл, то она возвращает NULL . В реальных программах почти всегда обрабатывают ошибку открытия файла в ветке if , мы же далее опустим это.
Объявление функции fopen содержится в заголовочном файле stdio.h , поэтому требуется его подключение. Также в stdio.h объявлен тип-структура FILE .
После того, как работа с файлом закончена, принято его закрывать, чтобы освободить буфер от данных и по другим причинам. Это особенно важно, если после работы с файлом программа продолжает выполняться. Разрыв связи между внешним файлом и указателем на него из программы выполняется с помощью функции fclose() . В качестве аргумента ей передается указатель на файл:
fclose(myfile);
В программе может быть открыт не один файл. В таком случае каждый файл должен быть связан со своим файловым указателем. Однако если программа сначала работает с одним файлом, потом закрывает его, то указатель можно использовать для открытия второго файла.
Чтение из текстового файла и запись в него
fscanf
Функция fscanf() аналогична по смыслу функции scanf() , но в отличии от нее осуществляет форматированный ввод из файла, а не стандартного потока ввода. Функция fscanf() принимает параметры: файловый указатель, строку формата, адреса областей памяти для записи данных:
fscanf(myfile, "%s%d", str, &a);
Возвращает количество удачно считанных данных или EOF. Пробелы, символы перехода на новую строку учитываются как разделители данных.
Допустим, у нас есть файл содержащий такое описание объектов:
apples 10 23.4 bananas 5 25.0 bread 1 10.3
Тогда, чтобы считать эти данные, мы можем написать такую программу:
#include int main () { FILE *file; struct food { char name[20]; unsigned qty; float price; }; struct food shop[10]; char i = 0; file = fopen("goods.txt", "r"); while (fscanf(file, "%s%u%f", shop[i].name, &(shop[i].qty), &(shop[i].price)) != EOF) { printf("%s %u %.2f\n", shop[i].name, shop[i].qty, shop[i].price); i++; } }
В данном случае объявляется структура и массив структур. Каждая строка из файла соответствует одному элементу массива; элемент массива представляет собой структуру, содержащую строковое и два числовых поля. За одну итерацию цикл считывает одну строку. Когда встречается конец файла fscanf() возвращает значение EOF и цикл завершается.
fgets
Функция fgets() осуществляет построчный ввод из файла. Один вызов fgets() позволят прочитать одну строку. При этом можно прочитать не всю строку, а лишь ее часть от начала. Параметры fgets() выглядят таким образом:
fgets(массив_символов, количество_считываемых_символов, указатель_на_файл)
fgets(str, 50, myfile)
Такой вызов функции прочитает из файла, связанного с указателем myfile , одну строку текста полностью, если ее длина меньше 50 символов с учетом символа ‘\n’, который функция также сохранит в массиве. Последним (50-ым) элементом массива str будет символ ‘\0’, добавленный fgets . Если строка окажется длиннее, то функция прочитает 49 символов и в конце запишет ‘\0’. В таком случае ‘\n’ в считанной строке содержаться не будет.
#include #define N 80 int main() { FILE *file; char arr[N]; file = fopen("goods.txt", "r"); while (fgets(arr, N, file) != NULL) printf("%s", arr); printf("\n"); fclose(file); }
В этой программе в отличие от предыдущей данные считываются строка за строкой в массив arr . Когда считывается следующая строка, предыдущая теряется. Функция fgets() возвращает NULL в случае, если не может прочитать следующую строку.
getc или fgetc
Функция getc() или fgetc() (работает и то и другое) позволяет получить из файла очередной один символ.
#include #define N 80 int main() { FILE *file; char str[N]; int i; file = fopen("goods.txt", "r"); while ((str[i] = fgetc(file)) != EOF) { if (str[i] == '\n') { str[i] = '\0'; printf("%s\n", str); i = 0; } else i++; } str[i] = '\0'; printf("%s\n",str); fclose(file); }
Приведенный в качестве примера код выводит данные из файла на экран.
Запись в текстовый файл
Также как и ввод, вывод в файл может быть различным.
- Форматированный вывод. Функция fprintf( файловый_указатель, строка_формата, переменные ) .
- Построчный вывод. Функция fputs( строка, файловый_указатель ) .
- Посимвольный вывод. Функция fputc() или putc( символ, файловый_указатель ) .
Ниже приводятся примеры кода, в которых используются три способа вывода данных в файл.
Запись в каждую строку файла полей одной структуры (прерывание в Linux ‒ Ctrl + D ):
#include #define N 80 int main() { FILE *file; char str[N]; int i; file = fopen("goods.txt", "r"); while ((str[i] = fgetc(file)) != EOF) { if (str[i] == '\n') { str[i] = '\0'; printf("%s\n", str); i = 0; } else i++; } str[i] = '\0'; printf("%s\n",str); fclose(file); }
Построчный вывод в файл ( fputs() , в отличие от puts() сама не помещает в конце строки ‘\n’):
#include int main () { FILE *file; char str[10]; file = fopen("output.txt", "w"); while (scanf("%s", str) != EOF) { fputs(str, file); fputs("\n", file); } fclose(file); }
Пример посимвольного вывода:
#include int main() { FILE *file; char i; file = fopen("output.txt", "w"); while ((i = getchar()) != EOF) fputc(i, file); fclose(file); }
Чтение из двоичного файла и запись в него
С файлом можно работать не как с последовательностью символов, а как с последовательностью байтов. В принципе, с нетекстовыми файлами работать по-другому не возможно. Однако так можно читать и писать и в текстовые файлы. Преимущество такого способа доступа к файлу заключается в скорости чтения-записи: за одно обращение можно считать/записать существенный блок информации.
При открытии файла для двоичного доступа, вторым аргументом fopen() является строка «rb» или «wb».
Тема о работе с двоичными файлами достаточно сложная, для ее изучения требуется отдельный урок. Здесь будут отмечены только особенности функций чтения-записи в файл, который рассматривается как поток байтов.
Функции fread() и fwrite() имеют следующие параметры:
- адрес области памяти, куда данные записываются или откуда считываются,
- размер одного данного какого-либо типа,
- количество считываемых данных указанного размера,
- файловый указатель.
Эти функции возвращают количество успешно прочитанных или записанных данных. Т.е. можно «заказать» считывание 50 элементов данных, а получить только 10. Ошибки при этом не возникнет.
Пример использования функций fread() и fwrite() :
#include #include int main() { FILE *file; char shelf1[50], shelf2[100]; int n, m; file = fopen("shelf1.txt", "rb"); n = fread(shelf1, sizeof(char), 50, file); fclose(file); file = fopen("shelf2.txt", "rb"); m = fread(shelf2, sizeof(char), 50, file); fclose(file); shelf1[n] = '\0'; shelf2[m] = '\n'; shelf2[m+1] = '\0'; file = fopen("shop.txt", "wb"); fwrite(strcat(shelf2, shelf1), sizeof(char), n+m, file); fclose(file); }
Здесь осуществляется попытка чтения из первого файла 50-ти символов. В n сохраняется количество реально считанных символов. Значение n может быть равно 50 или меньше. Данные помещаются в строку. То же самое происходит со вторым файлом. Далее первая строка присоединяется ко второй, и данные сбрасываются в третий файл.
Курс с решением задач:
pdf-версия
Как прочитать содержимое файла в string
Ещё несколько вариантов (в теории, по возрастанию скорости):
std::string readFile(const std::string& fileName) < return std::string((std::istreambuf_iterator(std::ifstream(fileName))), std::istreambuf_iterator()); > std::string readFile(const std::string& fileName)
std::string readFile(const std::string& fileName) < std::ifstream f(fileName); f.seekg(0, std::ios::end); size_t size = f.tellg(); std::string s(size, ' '); f.seekg(0); f.read(&s[0], size); // по стандарту можно в C++11, по факту работает и на старых компиляторах return s; >Отслеживать
ответ дан 26 мая 2016 в 0:21
Vladimir Gamalyan Vladimir Gamalyan
7,733 5 5 золотых знаков 28 28 серебряных знаков 57 57 бронзовых знаков
последний вариант дурной какой-то — зачем забивать строку пробелами (std::string s(size, ‘ ‘)), когда можно просто сделать .resize()?
26 мая 2016 в 3:27
@gbg можно и resize , разница в том, что resize потребует реаллокации памяти, а fill конструктор (вероятнее всего) сразу запросит нужный кусок. Другими словами resize потенциально медленнее.
26 мая 2016 в 7:36
В случае взятия сразу готового string мы получим долгое и печальное забивание нулями выделенного блока.
26 мая 2016 в 8:53
@gbg вы удивитесь, но resize делает то же самое (забивает нулями)
26 мая 2016 в 8:54
вы удивитесь, но resize конструктор не вызывает stackoverflow.com/a/7413968/5533854
26 мая 2016 в 8:57
Для начала, ofstream предназначен для вывода в файл, для ввода из файла используйте ifstream . Проще всего читать построчно:
std::ifstream file("тут ваш путь"); std::string line; while (std::getline(file, line)) < // обработайте строку // например, добавьте её к суммарной строке >Не забудьте, что std::getline не сохраняет \n в конце строки, так что при необходимости добавьте его сами.
Как считать весь файл в строку c
При работе с текстовыми файлами граздо проще работать с данными не как с отдельными символами, а как со строками с помощью функций fgets() и fputs() .
Запись текстового файла
Функция fputs() записывает в файл строку, то есть набор символов, который завершается символом ‘\0’. Она имеет следующий прототип:
int fputs(const char *s, FILE *stream);
Первый параметр функции — записываемая строка, а второй — указатель на файловый поток. В качестве результата функция возвращает неотрицательное целое число. При ошибках в процессе записи возвращается значение EOF .
При записи строки нулевой символ ‘\0’ в файл не записывается.
Например, запишем строку в файл:
#include int main(void) < // строка для записи char * message = "Hello METANIT.COM!\nAn apple a day keeps the doctor away"; // файл для записи char * filename = "data.txt"; // запись в файл FILE *fp = fopen(filename, "w"); if(fp) < // записываем строку fputs(message, fp); fclose(fp); printf("File has been written\n"); >>
Запись довольно проста: открываем файл на запись и с помощью вызова fputs(message, fp) записываем в файл искомую строку.
Чтение текстового файла
Функция fgets() считывает из файла одну строку и имеет следующий прототип:
char * fgets(char *s, int n, FILE *sream);
Первый параметр char *s представляет строку, в которую производится считывание. Второй параметр — число n указывает, сколько символов необходимо считывать. И третий параметр представляет файловый поток, из которого производится считывание.
При вызове функция считывает из файла не более n-1 символов. Функция прекращает чтение, когда прочтет n-1 символов или встретит символ переноса строки \n. Все считанные символы записываются в строку s, в том числе символ \n. И также конец каждой строки дописывается нулевой символ ‘\0’.
При успешном завершении функция возвращает указатель s , а при ошибке или достижении конца файла возвращается значение NULL .
Считаем данные из выше записанного файла «data.txt»:
#include int main(void) < // файл чтения char * filename = "data.txt"; // буфер для считавания данных из файла char buffer[256]; // чтение из файла FILE *fp = fopen(filename, "r"); if(fp) < // пока не дойдем до конца, считываем по 256 байт while((fgets(buffer, 256, fp))!=NULL) < printf("%s", buffer); >fclose(fp); > >
Здеcь открываем файл на чтение и в цикле считываем из файла по 256 символов и выводим их на консоль с помощью вызова fgets(cc, 256, fp) . Когда данные в файле закончатся, функция возвратит NULL, и произойдет выход из цикла.
Копирование файлов
Другой пример работы с текстовыми файлами — копирование содержимого из одного файла в другой:
#include int main(void) < char * filename1 = "data1.txt"; char * filename2 = "data2.txt"; char buffer[256]; FILE *f1 = fopen(filename1, "r"); // файл на чтение FILE *f2 = fopen(filename2, "w"); // файл на запись if(!f1 || !f2) < printf("Error occured while opening file\n"); >else < // пока не дойдем до конца, считываем по 256 байт из файла f1 while((fgets(buffer, 256, f1))!=NULL) < // записываем строку в файл f2 fputs(buffer, f2); printf("%s", buffer); >> fclose(f1); fclose(f2); return 0; >
Чтение текстового файла построчно на C#
Два самых простых способа как прочитать текстовый файл построчно на C#. В обоих случаях используется using System.IO;. Напишу сразу примеры кода без всяких прелюдий.
Способ 1
Классический вариант чтения файла построчно:
StreamReader f = new StreamReader("test.txt"); while (!f.EndOfStream) < string s = f.ReadLine(); // что-нибудь делаем с прочитанной строкой s >f.Close();
Еще один пример, как можно организовать цикл построчного чтения:
string s; StreamReader f = new StreamReader("test.txt"); while ((s = f.ReadLine()) != null) < // что-нибудь делаем с прочитанной строкой s >f.Close();
Указать кодировку при чтении файла (например, DOS-кодировку) можно так:
StreamReader f = new StreamReader("test.txt", Encoding.GetEncoding(866));
Так же можно использовать обёртку using чтобы не закрывать файл после чтения.
string s; using (var f = new StreamReader("test.txt", Encoding.GetEncoding(1251))) < while ((s = f.ReadLine()) != null) < // что-нибудь делаем с прочитанной строкой s >>
Способ 2
Прочитать весь файл целиком в массив строк:
string[] lines = File.ReadAllLines("test.txt"); foreach (string s in lines) < // что-нибудь делаем с прочитанной строкой s >
По аналогии, кстати, можно и записывать построчно в файл, использовав StreamWriter, f.WriteLine и File.WriteAllLines. Побробнее смотрите в следующей статье.