Программирование работа с текстовыми файлами. Работа с файлами в языке си
До этого при вводе-выводе данных мы работали со стандартными потоками - клавиатурой и монитором. Теперь рассмотрим, как в языке C реализовано получение данных из файлов и запись их туда. Перед тем как выполнять эти операции, надо открыть файл и получить доступ к нему.
В языке программирования 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
В данном случае объявляется структура и массив структур. Каждая строка из файла соответствует одному элементу массива; элемент массива представляет собой структуру, содержащую строковое и два числовых поля. За одну итерацию цикл считывает одну строку. Когда встречается конец файла fscanf() возвращает значение EOF и цикл завершается.
fgets()
Функция fgets() аналогична функции gets() и осуществляет построчный ввод из файла. Один вызов fgets() позволят прочитать одну строку. При этом можно прочитать не всю строку, а лишь ее часть от начала. Параметры fgets() выглядят таким образом:
fgets (массив_символов, количество_считываемых_символов, указатель_на_файл)
Например:
fgets (str, 50, myfile)
Такой вызов функции прочитает из файла, связанного с указателем myfile, одну строку текста полностью, если ее длина меньше 50 символов с учетом символа "\n", который функция также сохранит в массиве. Последним (50-ым) элементом массива str будет символ "\0", добавленный fgets() . Если строка окажется длиннее, то функция прочитает 49 символов и в конце запишет "\0". В таком случае "\n" в считанной строке содержаться не будет.
#include
В этой программе в отличие от предыдущей данные считываются строка за строкой в массив arr. Когда считывается следующая строка, предыдущая теряется. Функция fgets() возвращает NULL в случае, если не может прочитать следующую строку.
getc() или fgetc()
Функция getc() или fgetc() (работает и то и другое) позволяет получить из файла очередной один символ.
while ((arr[ i] = fgetc (file) ) != EOF) { if (arr[ i] == "\n " ) { arr[ i] = "\0 " ; printf ("%s\n " , arr) ; i = 0 ; } else i++; } arr[ i] = "\0 " ; printf ("%s\n " , arr) ;
Приведенный в качестве примера код выводит данные из файла на экран.
Запись в текстовый файл
Также как и ввод, вывод в файл может быть различным.
- Форматированный вывод. Функция fprintf (файловый_указатель, строка_формата, переменные) .
- Посточный вывод. Функция fputs (строка, файловый_указатель) .
- Посимвольный вывод. Функция fputc() или putc(символ, файловый_указатель) .
Ниже приводятся примеры кода, в которых используются три способа вывода данных в файл.
Запись в каждую строку файла полей одной структуры:
file = fopen ("fprintf.txt" , "w" ) ; while (scanf ("%s%u%f" , shop[ i] .name , & (shop[ i] .qty ) , & (shop[ i] .price ) ) != EOF) { fprintf (file, "%s %u %.2f\n " , shop[ i] .name , shop[ i] .qty , shop[ i] .price ) ; i++; }
Построчный вывод в файл (fputs() , в отличие от puts() сама не помещает в конце строки "\n"):
while (gets (arr) != NULL) { fputs (arr, file) ; fputs ("\n " , file) ; }
Пример посимвольного вывода:
while ((i = getchar () ) != EOF) putc (i, file) ;
Чтение из двоичного файла и запись в него
С файлом можно работать не как с последовательностью символов, а как с последовательностью байтов. В принципе, с нетекстовыми файлами работать по-другому не возможно. Однако так можно читать и писать и в текстовые файлы. Преимущество такого способа доступа к файлу заключается в скорости чтения-записи: за одно обращение можно считать/записать существенный блок информации.
При открытии файла для двоичного доступа, вторым параметром функции fopen() является строка "rb" или "wb".
Тема о работе с двоичными файлами достаточно сложная, для ее изучения требуется отдельный урок. Здесь будут отмечены только особенности функций чтения-записи в файл, который рассматривается как поток байтов.
Функции fread() и fwrite() принимают в качестве параметров:
- адрес области памяти, куда данные записываются или откуда считываются,
- размер одного данного какого-либо типа,
- количество считываемых данных указанного размера,
- файловый указатель.
Эти функции возвращают количество успешно прочитанных или записанных данных. Т.е. можно "заказать" считывание 50 элементов данных, а получить только 10. Ошибки при этом не возникнет.
Пример использования функций fread() и fwrite() :
#include
Здесь осуществляется попытка чтения из первого файла 50-ти символов. В n сохраняется количество реально считанных символов. Значение n может быть равно 50 или меньше. Данные помещаются в строку. То же самое происходит со вторым файлом. Далее первая строка присоединяется ко второй, и данные сбрасываются в третий файл.
Решение задач
- Напишите программу, которая запрашивает у пользователя имя (адрес) текстового файла, далее открывает его и считает в нем количество символов и строк.
- Напишите программу, которая записывает в файл данные, полученные из другого файла и так или иначе измененные перед записью. Каждая строка данных, полученная из файла, должна помещаться в структуру.
Записывать информацию в текстовый файл мы уже научились. – Если не научились смотрите прошлую статью. Там рассказывается и подробно описано
Но что если файл уже существует и нам нужно считать с него информацию для обработки? К счастью это тоже достаточно просто. Напоминаю, что вариантов для реализации этой задачи существует несколько, мною описан только один из. Описан тот, который лично мне почему-то кажется наиболее простым для восприятия.
#include
int main
()
{
char s1
//
Переменная будет считывать строку
ifstream in
(“C:\\\FromC\\myfile.txt”
); //
Открываем файл для считывания информации
in
>>s1
; //
считываем строку
in
.close
() //
Закрываем файл
cout
<
return 0
;
}
Вот наипростейшая программа для считывания первой строки из текстового файла, который находится по пути
C:\\\FromC\\myfile.txt
–
Так как это продолжение прошлой статьи , то я решил использовать тот файл, который мы там создавали. Трудностей с этим, наверное возникнуть не должно.
Но вернемся к коду. Сначала мы открываем файл для считывания из него информации, для этого используем команду ifstream
,
в скобках указываем либо название файла, либо путь к файлу, как сделано у меня.(“C:\\\FromC\\myfile.txt”
);
Когда мы открыли файл, чтобы считать из него что-то, мы объявили одну переменную типа char –
char s1
Теперь нам осталось только присвоить переменной значение строки из файла. Это мы делаем командой in
Обращаем внимание на угловые скобки in
>>
Собственно, как должно быть видно из комментариев к коду программы, то чтобы переменная присвоила считываемое значение, мы должны написать её после in
>>
in
>>s1
;
Никакой особо сложной задачей это не представляется, особенно если вы уже прекрасно освоили и научились использовать материал прошлой статьи – всё абсолютно аналогично, только 2 команды другие
Создание файла и запись в него информации С++
ofstream out
(Имя файла
);
out
<< (Записываемая строка
);
out
.close
();
=============================
Чтение текста из файла и вывода текста на экран в C++
ifstream in
(Имя файла
);
in
>>
(Считываем строку
);
in
.close
();
(Закрываем файл
)
============================
Напишем простую программу, которая будет считывать ввод с клавиатуры текста и записывать его в файл:
#include
#include
int main
()
{
\\
3 будущие строки
clrscsr
(); //
Очищаем экран
cout
<<“Wwedi pervuu stroku”
;
cin
>>a
; endl
;
cout
<<“Wwedi wtoruu stroku”
;
cin
>>b
; endl
;
cout
<<“Wwedi tretuu stroku”
;
cin
>>c
; endl
;
clrscr
(); //
/*Начинаем работу с файлом*/
ofstream out
(“C:\\\FromC\\myfile.txt”
); //
Открываем файл для записи
out
<Записываем первую строчку
out
<Записываем вторую строчку
out
<
out
.close
(); //
Закрываем файл
//Обнуляем переменные
for (int i
=0
;i
<=255
;i
++)
{a
=*“”
; b
=*“”
; c
=*“”
;}
ifstream in
(“C:\\\FromC\\myfile.txt”
);
in
>>a
>>b
>>c
; //
Считываем каждую новую строчку в новую переменную
in
.close
(); //
Закрываем файл
/* */
for (i
=0
;a
!=*“”
;i
++)
{
if (i
>sizeof(a
))
break
;
cout
<
}
cout
<<“\n”
; \\
/* */
{
if (i
>sizeof(b
))
break
;
cout
<
}
cout
<<“\n”
; \\
Перевели курсор на новую строчку
/* */
for (i
=0
;с
!=*“”
;i
++)
{
if (i
>sizeof(c
))
break
;
cout
<<с
;
}
return 0
;
}
===================
В приведенных выше примерах есть один такой ОГРОМНЫЙ недостаток. Если мы будем пытаться ввести строчку, содержащую пробелы, то программа будет срабатывать не так как нам нужно. Наверное, на эту ошибку наткнулся не только я, но и многие другие люди. Поэтому я оставляю неверно приведенный код, чтобы было видно с чем можно столкнуться.
Так как книжек дома нет, я снова стал рыскать в интернете и понаходил много всякой мудреной ерунды. Но всё-таки как-то подобрал решение своей проблемы.
Помогло то, что читал о том, что cout
поддерживает свои методы. И в интернете все советы идут на использование функции getline
К моему счастью как использовать эту функцию я нашел очень быстро и потом использовал ее в коде.
Вообще стоит упомянуть и описать эту функцию, но пока что я не особо её понимаю, просто понимаю, что её нужно использовать и понимаю как, поэтому привожу более правильный пример нашей разрабатываемой программы:
#include
#include
int main
()
{
char a
,b
,c
;
\\
3 будущие строки
clrscsr
(); //
Очищаем экран
/* Вводим значения для переменных*/
cout
<<“Wwedi pervuu stroku”
;
cin.getline(a,sizeof(a));
endl
;
cout
<<“Wwedi wtoruu stroku”
;
cin.getline(a,sizeof(b));
endl
;
cout
<<“Wwedi tretuu stroku”
;
cin.getline(a,sizeof(c));
endl
;
clrscr
(); //
После ввода значений очистили экран
/*Начинаем работу с файлом*/
ofstream out
(“C:\\\FromC\\myfile.txt”); //
Открываем файл для записи
out
<Записываем первую строчку
out
<Записываем вторую строчку
out
<
out
.close
(); //
Закрываем файл
//Обнуляем переменные
for (int i
=0
;i
<=255
;i
++)
{a
=*“”
; b
=*“”
; c=*“”
;}
/*Продолжаем работу с файлом*/
if stream in
(“C:\\\FromC\\myfile.txt”
);
in.getline(a,sizeof(a));
//
а
in.getline(b,sizeof(b));
//
Считываем строчку в переменную b
in.getline(c,sizeof(c));
//
Считываем строчку в переменную c
in
.close
(); //
Закрываем файл
/* Считываем посимвольно первую строку и выводим её на экран*/
for (i
=0
;a
!=*“”
;i++)
{
if (i
>sizeof(a
))
break
;
cout
<
}
cout
<<“\n”
; \\
Перевели курсор на новую строчку
/* Считываем посимвольно вторую строку и выводим её на экран*/
for (i
=0
;b
!=*“”
;i
++)
{
if (i
>sizeof(b
))
break
;
cout
<
}
cout
<<“\n”
; \\
Перевели курсор на новую строчку
/* Считываем посимвольно третью строку и выводим её на экран*/
for (i
=0
;с
!=*“”
;i++)
{
if (i>sizeof
(c
))
break
;
cout
<<с[i];
}
getch
(); \\
Ожидаем нажатия клавиши Enter
return 0
;
}
===================
В этом материале разобран пример посимвольного чтения информации. Так как я не описывал работу с перемнными типа char , то у начинающих могут возникнуть некоторые неудобства воспринятия кода. Просто я не знал, что тип char имеет какие-то особенности и думал всё проще. Поэтому некоторые непонятные моменты приведенной программы можно прочитать в следующей статье работа с char в C++ для начинающих
В остальном, приведенный пример, как в C++ считать строки из текстового файла должен быть доступен и вполне понятен. Это сейчас не оптимальный вариант реализации, и я упустил некоторые важные моменты, но так как у нас начало изучения языка C++, то этого пока вполне достаточно. Попозже я наверняка дойду до упущенного, а сейчас нужно воспринимать только самое необходимое.
Если мы вместе с вами поняли этот материал, то значит продвинулись на маленький шажок к своему профессионализму.
Примечание:
break
;
– Это команда, которая выполняет выход из цикла. У нас если счетчик цикла for
становится больше чем объявленный размер переменной char,
то мы принудительно выходим из цикла
!= –
это поставленное нами условие. Обозначает такое условие неравенство
if(a
!=b
)
– Читается как если a
не равно b
endl
; –
Это перевод курсора на новую строку внутри консоли (насколько я понял)
Эта команда похожа на“\n”
Для программиста открытый файл представляется как последовательность считываемых или записываемых данных. При открытии файла с ним связывается поток ввода-вывода . Выводимая информация записывается в поток, вводимая информация считывается из потока.
Когда поток открывается для ввода-вывода, он связывается со стандартной структурой типа FILE, которая определена в stdio.h. Структура FILE содержит необходимую информацию о файле.
Открытие файла осуществляется с помощью функции fopen(), которая возвращается указатель на структуру типа FILE, который можно использовать для последующих операций с файлом.
FILE *fopen (name, type);
name – имя открываемого файла (включая путь),
type - указатель на строку символов, определяющих способ доступа к файлу:
· "r" - открыть файл для чтения (файл должен существовать);
· "w" - открыть пустой файл для записи; если файл существует, то его содержимое теряется;
· "a" - открыть файл для записи в конец (для добавления); файл создается, если он не существует;
· "r+" - открыть файл для чтения и записи (файл должен существовать);
· "w+" - открыть пустой файл для чтения и записи; если файл существует, то его содержимое теряется;
· "a+" - открыть файл для чтения и дополнения, если файл не существует, то он создаётся.
Возвращаемое значение - указатель на открытый поток. Если обнаружена ошибка, то возвращается значение NULL.
Функция fclose() закрывает поток или потоки, связанные с открытыми при помощи функции fopen() файлами. Закрываемый поток определяется аргументом функции fclose().
Возвращаемое значение: значение 0, если поток успешно закрыт; константа EOF, если произошла ошибка.
#include
int main()
char name="my.txt";
if(fp = fopen(name, "r")!=NULL)
// открыть файлу далось?
... // требуемые действия над данными
else printf("Не удалось открыть файл");
Чтение символа из файла :
char fgetc(поток);
Аргументом функции является указатель на поток типа FILE. Функция возвращает код считанного символа. Если достигнут конец файла или возникла ошибка, возвращается константа EOF.
Запись символа в файл
:
fputc(символ,поток);
Аргументами функции являются символ и указатель на поток типа FILE. Функция возвращает код считанного символа.
Функции fscanf() и fprintf() аналогичны функциям scanf() и printf(), но работают с файлами данных, и имеют первый аргумент - указатель на файл.
fscanf(поток, "Формат Ввода", аргументы);
fprintf(поток, "Формат Вывода", аргументы);
Функции fgets() и fputs() предназначены для ввода-вывода строк, они являются аналогами функций gets() и puts() для работы с файлами.
fgets(Указатель На Строку, Количество Символов, поток);
Символы читаются из потока до тех пор, пока не будет прочитан символ новой строки "\n", который включается в строку, или пока не наступит конец потока EOF или не будет прочитано максимальное символов. Результат помещается в указатель на строку и заканчивается нуль- символом "\0". Функция возвращает адрес строки.
fputs(Указатель На Строку, поток);
Копирует строку в поток с текущей позиции. Завершающий нуль- символ не копируется.
Пример
Ввести число и сохранить его в файле s1.txt. Считать число из файла s1.txt, увеличить его на 3 и сохранить в файле s2.txt.
Работа с текстовыми файлами в C++.
Существуют два основных типа файлов: текстовые и двоичные. Файлы позволяют пользователю считывать большие объемы данных непосредственно с диска, не вводя их с клавиатуры.
Текстовыми называются файлы, состоящие из любых символов. Они организуются по строкам, каждая из которых заканчивается символом «конец строки». Конец самого файла обозначается символом «конец файла». При записи информации в текстовый файл, просмотреть который можно с помощью любого текстового редактора, все данные преобразуются к символьному типу и хранятся в символьном виде.
В двоичных файлах информация считывается и записывается в виде блоков определенного размера, в которых могут храниться данные любого вида и структуры.
Для работы с файлами используются специальные типы данных , называемые потоками . Поток ifstream служит для работы с файлами в режиме чтения, а ofstream в режиме записи. Для работы с файлами в режиме как записи, так и чтения служит поток fstream .
В программах на C++ при работе с текстовыми файлами необходимо подключать библиотеки iostream и fstream.
Для того чтобы записывать данные в текстовый файл, необходимо:
описать переменную типа ofstream.
вывести информацию в файл.
обязательно закрыть файл.
Для считывания данных из текстового файла, необходимо:
описать переменную типа ifstream.
открыть файл с помощью функции open.
закрыть файл.
Запись информации в текстовый файл
Как было сказано ранее, для того чтобы начать работать с текстовым файлом, необходимо описать переменную типа ofstream. Например, так:
Будет создана переменная F для записи информации в файл.
На следующим этапе файл необходимо открыть для записи. В общем случае оператор открытия потока будет иметь вид:
F.open(«file», mode);
Здесь F - переменная, описанная как ofstream,
file - полное имя файла на диске,
mode - режим работы с открываемым файлом.
Обратите внимание на то, что при указании полного имени файла нужно ставить двойной слеш. Например, полное имя файла noobs.txt, находящегося в папке game на диске D:, нужно будет записать так:
D:\\game\\noobs.txt.
Файл может быть открыт в одном из следующих режимов:
ios::in - открыть файл в режиме чтения данных, этот режим является режимом по умолчанию для потоков ifstream;
ios::out - открыть файл в режиме записи данных (при этом информация о существующем файле уничтожается), этот режим является режимом по умолчанию для потоков ofstream;
ios::app - открыть файл в режиме записи данных в конец файла;
ios::ate - передвинуться в конец уже открытого файла;
ios::trunc - очистить файл, это же происходит в режиме ios::out;
ios::nocreate - не выполнять операцию открытия файла, если он не существует;
ios::noreplace - не открывать существующий файл.
Параметр mode может отсутствовать, в этом случае файл открывается в режиме по умолчанию для данного потока.
После удачного открытия файла (в любом режиме) в переменной F будет храниться true, в противном случае false. Это позволит проверить корректность операции открытия файла.
Открыть файл (в качестве примера возьмем файл D:\\game\\noobs.txt) в режиме записи можно одним из следующих способов:
// первый способ
ofstream F;
F.open("D:\\game\\noobs.txt", ios::out);
//второй способ, режим ios::out является режимом по умолчанию
// для потока ofstream
ofstream F;
//третий способ объединяет описание переменной и типа поток
//и открытие файла в одном операторе
ofstream F ("D:\\game\\noobs.txt", ios::out);
После открытия файла в режиме записи будет создан пустой файл, в который можно будет записывать информацию.
Если вы хотите открыть существующий файл в режиме до записи, то в качестве режима следует использовать значение ios::app.
После открытия файла в режиме записи, в него можно писать точно так же, как и на экран, только вместо стандартного устройства вывода cout необходимо указать имя открытого файла.
Например, для записи в поток F переменной a, оператор вывода будет иметь вид:
Для последовательного вывода в поток G переменных b, c, d оператор вывода станет таким:
G< Закрытие потока
осуществляется с помощью оператора: ПРИМЕР:
Создать
текстовый файл D:\\game\\noobs.txt
и записать в него n
вещественных чисел. #include
"stdafx.h"
#include
#include
#include
using
namespace std;
int
main()
setlocale
(LC_ALL, "RUS");
int
i, n;
double
a;
//описывает
поток для записи данных в файл
ofstream
f
;
//открываем
файл в режиме записи,
//режим
ios
::
out
устанавливается по умолчанию
f.open("D:\\game\\noobs.txt",
ios::out);
//вводим
количество вещественных чисел
cout
<<"
n
=";
cin
>>
n
;
//цикл
для ввода вещественных чисел
//и
записи их в файл
for
(i=0; i cout<<"a=";
//ввод
числа
cin>>a;
f< //закрытие
потока
f.close();
system("pause");
return
0;
_______________________________________________________________ Для того чтобы
прочитать информацию из текстового
файла, необходимо описать переменную
типа ifstream
.
После этого нужно открыть файл для
чтения с помощью оператора open
.
Если переменную назвать F,
то первые два оператора будут такими: F.open("D:\\game\\noobs.txt",
ios::in); После
открытия файла в режиме чтения из него
можно считывать информацию точно так
же, как и с клавиатуры, только вместо
cin
указать имя потока из которого будет
происходить чтение данных.
Например, для
чтения из потока F
в переменную a,
оператор ввода будет выглядеть так: Два числа в текстовом
редакторе считаются разделенными, если
между ними есть хотя бы один из символов:
пробел, табуляция, символ конца строки.
Хорошо, если программисту заранее
известно, сколько и каких значений
храниться в текстовом файле. Однако
часто просто известен тип значений,
хранящихся в файле, при этом их количество
может быть различным. При решении
подобной проблемы необходимо считывать
значения из файла по одному, а перед
каждым считыванием проверять, достигнут
ли конец файла. Для этого существует
функция F
.
eof
().
Здесь F
- имя потока функция возвращает логическое
значение: true
или false,
в зависимости от того достигнут ли конец
файла. Следовательно, цикл для чтения
содержимого всего файла можно записать
так: //организуем
для чтения значений из файла, выполнение
//цикла
прервется, когда достигнем конец файла,
//в
этом случае F.eof() вернет истину
while
(!F.eof())
ПРИМЕР:
В
текстовом файле D:\\game\\noobs.txt хранятся
вещественные числа, вывести их на экран
и вычислить их количество. #include
"stdafx.h"
#include
#include
#include
#include
using
namespace std;
int
main()
setlocale
(LC_ALL, "RUS");
int
n=0;
float
a;
fstream F;
//открываем
файл в режиме чтения
F.open("D:\\game\\noobs.txt");
//если
открытие файла прошло корректно, то
//цикл
для чтения значений из файла; выполнение
цикла прервется,
//когда
достигнем конца файла, в этом случае
F.eof() вернет истину.
while
(!F.eof())
//чтение
очередного значения из потока F в
переменную a
F>>a;
//вывод
значения переменной a на экран
cout< //увеличение
количества считанных чисел
//закрытие
потока
F.close();
//вовод
на экран количества считанных чисел
cout<<"n="< //если
открытие файла прошло некорректно, то
вывод
//сообщения
об отсутствии такого файла
else
cout<<" Файл не существует"< system("pause");
return
0;
C++.
Обработка двоичных файлов
При записи информации
в двоичный файл символы и числа
записываются в виде последовательности
байт. Для того чтобы
записать
данные в двоичный файл, необходимо: описать файловую
переменную типа FAIL * с помощью оператора
FILE *filename;. Здесь filename - имя переменной,
где будет храниться указатель на файл. записать информацию
в файл с помощью функции fwrite Для
того чтобы считат
ь
данные из двоичного файла, необходимо: описать переменную
типа FILE * открыть файл с
помощью функции fopen закрыть файл с
помощью функции fclose Основные функции,
необходимые для работы с двоичными
файлами.
Для
открытия
файла предназначена функция fopen. FILE
*fopen(const *filename, const char *mode) Здесь
filename - строка, в которой хранится полное
имя открываемого файла, mode - строка,
определяющая режим работы с файлом;
возможны следующие значения: «rb» - открываем
двоичный файл в режиме чтения; «wb» - создаем
двоичный файл для записи; если он
существует, то его содержимое очищается; «ab» - создаем или
открываем двоичный файл для дозаписи
в конец файла; «rb+» - открываем
существующий двоичный файл в режиме
чтения и записи; «wb+» - открываем
двоичный файл в режиме чтения и записи,
существующий файл очищается; «ab+» - двоичный
файл открывается или создается для
исправления существующий информации
и добавления новой в конец файла. Функция возвращает
в файловой переменной f значение NULL в
случае неудачного открытия файла. После
открытия файла доступен 0-й его байт,
указатель файла равен 0, значение которого
по мере чтения или записи смещается на
считанное (записанное) количество байт.
Текущие значение указателя файла -
номер байта, начиная с которого будет
происходить операция чтения или записи. Для закрытия
файла предназначена функция fclose int
fclose(FILE *filename); Возвращает
0 при успешном закрытие файла и NULL в
противном случае. Функция remove
предназначена для удаления
файлов. int
remove(const char *filename); Эта
функция удаляет с диска файл с именем
filenema. Удаляемый файл должен быть закрыт.
Функция возвращает ненулевое значение,
если файл не удалось удалить. Для переименования
файлов предназначена функция rename: int
rename(const char *oldfilename, const char *newfilename); Первый
параметр - старое имя файла, второй -
новое. Возвращает 0 при удачном завершении
программы. Чтение
из двоичного файла осуществляется с
помощью функции fread: fread(void
*ptr, size, n, FILE *filename); Функция
fread считывает из файла filename в массив ptr
n элементов размера size. Функция возвращает
количество считанных элементов. После
чтения из файла его указатель смещается
на n*size байт. Запись
в двоичный файл осуществляется с помощью
функции fwrite: fwrite(const
void *ptr, size, n, FILE *filename); Функция
fwrite записывает в файл filename из массива
ptr n элементов размера size. Функция
возвращает количество записанных
элементов. После записи информации в
файл указатель смещается на n*size байт. Для контроля
достижения конца файла
есть функция feof: int
feof(FILE *filename); Она
возвращает ненулевое значение если
достигнут конец файла. ПРИМЕР:
Создать
двоичный файл D:\\game\\noobs.dat и записать в
него целое число n и n вещественных чисел. #include
"stdafx.h"
#include
using
namespace std;
int
main()
setlocale
(LC_ALL, "RUS");
int
n, i;
double
a;
//создаем
двоичный файл в режиме записи
f=fopen("D:\\game\\noobs.dat",
"wb");
//
ввод
числа
n
cout<<"n=";
cin>>n;
fwrite(&n,
sizeof(int), 1, f);
//цикл
для ввода n вещественных чисел
for
(i=0; i //ввод
очередного вещественного числа
cout<<"a=";
cin>>a;
//запись
вешественного числа в двоичный файл
fwrite(&a,
sizeof(double), 1, f);
//
закрываем
файл
fclose(f);
system("pause");
return
0;
ПРИМЕР:
Вывести
на экран содержимого созданного в
прошлой задаче двоичного файла
D:\\game\\noobs.dat #include
"stdafx.h"
#include
using
namespace std;
int
main()
setlocale
(LC_ALL, "RUS");
int
n, i;
double
*a;
FILE
*f; //описываем файловую переменную
//открываем
существующий двоичный файл в режиме
чтения
//считываем
из файла одно целое число в переменную
n
//вывод
n на экран
cout<<"n="< //выделение
памяти для массива из n чисел
a=new double[n];
//чтение
n вещественных чисел из файла в массив
a
//вывод
массива на экран
for
(i=0; i cout< cout< //
закрываем
файл
fclose(f);
system("pause");
return
0;
Двоичный файл
-
последовательная структура данных,
после открытия файла доступен первый
байт, хранящийся в нем. Можно последовательно
записывать или считывать данные из
файла. Допустим, необходимо считать
пятнадцатое число, а затем первое. С
помощью последовательного доступа это
можно сделать следующим способом: int
n, i;
double
a;
FILE
*f;
f=fopen("D:\\game\\noobs.dat",
"rb");
for
(i=0; i<15; i++)
fclose(f);
f=fopen("D:\\game\\noobs.dat",
"rb");
fread(&a,
sizeof(double), 1, f);
fclose(f);
Как видно, такое
чтение чисел из файла, а затем повторное
открытие файла - не самый удобный
способ. Гораздо удобнее будет использовать
функцию fseek перемещения указателя файла
к заданному байту. int
fseek(FILE *filename, long int offset, int origin); Функция устанавливает
указатель текущий позиции файла F в
соответствии со значением начала отсчета
origin и смещения offset. Параметр offset равен
количеству байтов, на которые будет
смещен указатель файла относительно
начала отсчета, заданного параметром
origin. В качестве значения для параметра
origin должно быть взято одно из следующих
значений отсчета смещения offset, определенных
в заголовке stdio.h: SEEK_SET
- с начала файла; SEEK_CUR
- с текущей позиции; SEEK_END
- с конца файла. Функция возвращает
нулевое значение при успешном выполнение
операции, ненулевое - при возникновении
сбоя при выполнении смещения Функция fseek
фактически реализует прямой доступ к
любому значению в файле. Необходимо
только знать месторасположение (номер
байта) значения в файле. Рассмотрим
использование прямого доступа в двоичных
файлах на примере решения следующей
задачи. ПРИМЕР
В
созданном раннее двоичном файле
D:\\game\\noobs.dat, поменять местами наибольшее
и наименьшее из вещественных чисел. Алгоритм
решения задачи состоит из следующих
этапов: чтение вещественных
из файла в массив a. поиск в массиве
а максимального (max) и минимального
(min) значения и их номеров (imax, imin). перемещения
указателя файла к максимальному значению
и запись min. перемещения
указателя файла к минимальному значению
и запись max. Ниже приведен
текст программы решения задачи с
комментариями. #include
"stdafx.h"
#include
using
namespace std;
int
main()
setlocale
(LC_ALL, "RUS");
int
n, i, imax, imin;
double
*a, max, min;
FILE
*f;
//открытие
файла в режиме чтения и записи
f=fopen("D:\\game\\noobs.dat",
"rb+");
//считываем
из файла в переменную n количество
//вещественных
чисел в файле
fread(&n,
sizeof(int), 1, f);
cout<<"n="< //выделяем
память для хранения вещественных чисел,
//которые
будут храниться в массиве a
a=new double[n];
//считываем
из файла в массив а вещественные числа
fread(a,
sizeof(double), n, f);
//поиск
максимального и минимального элементов
//в
массиве а и их индексов
for
(imax=imin=0, max=min=a, i=1; i if
(a[i]>max)
max=a[i];
if
(a[i] min=a[i];
//
перемещение
указателя
к
максимальному
элементу
fseek(f,
sizeof(int)+imax*sizeof(double), SEEK_SET);
//запись
min вместо максимального элемента файла
fwrite(&min,
sizeof(double), 1, f);
//
перемещение
указателя
к
минимальному
элементу
fseek(f,
sizeof(int)+imin*sizeof(double), SEEK_SET);
//запись
max вместо минимального элемента файла
fwrite(&max,
sizeof(double), 1, f);
//закрытие
файла
fclose(f);
//освобождение
памяти
delete [
]a;
system("pause");
– сравнение для выявления равенства либо неравенства. Практическое назначение перечисления – определение множества различающихся символических констант целого типа. Пример использования переменных перечислимого типа:
mo=1, tu, we, th, fr, sa, su } days; puts(“ Введите день недели (от 1 до 7) : ”); scanf(“%d”, &t_day); w_day = su; start = mo; end = w_day -t_day; printf(“\n Понедельник - %d-й день недели, \ сейчас %d-й день. \n\ До конца недели %d дней (дня). ”, start, t_day, end); Результат работы программы: Введите день недели (от 1 до 7) : 2
Понедельник - 1-й день недели, сейчас 2-й день. До конца недели 5 дней (дня). Файл – это набор данных, размещенный на внешнем носителе и рассматриваемый в процессе обработки как единое целое. В файлах размещаются данные, предназначенные для длительного хранения. Различают два вида файлов: текстовые и бинарные. Текстовые файлы представляют собой последовательность ASCII символов и могут быть просмотрены и отредактированы с помощью любого текстового редактора. Бинарные (двоичные) файлы представляют собой последовательность данных, структура которых определяется программно. В языке Си имеется большой набор функций для работы с файлами, большинство которых находятся в библиотеках stdio.h
иio.h
. Каждому файлу присваивается внутреннее логическое имя, используемое в дальнейшем при обращении к нему. Логическое имя (идентификатор файла) – это указатель на файл, т.е. на область памяти, где содержится вся необходимая информация о файле. Формат объявления указателя на файл следующий: FILE
*
указатель на файл;
FILE – идентификатор структурного типа, описанный в стандартной библиотеке stdio.h
и содержащий следующую информацию: type struct {
– число оставшихся в буфере непрочитанных байт; обычный размер буфера – 512 байт; как только level=0, в буфер из файла читается следующий блок данных; – флаг статуса файла – чтение, запись, дополнение; – дескриптор файла, т.е. число, определяющее его но- unsigned char hold; – непереданный символ, т.е. ungetc-символ; – размер внутреннего промежуточного буфера; unsigned char buffer; – значение указателя для доступа внутри буфера, т.е. задает начало буфера, начало строки или текущее зна- чение указателя внутри буфера в зависимости от режи- ма буферизации; unsigned char *curp; – текущее значение указателя для доступа внутри бу- фера, т.е. задает текущую позицию в буфере для обме- на с программой; unsigned istemp; – флаг временного файла; – флаг при работе с файлом; }
FILE;
Прежде чем начать работать с файлом, т.е. получить возможность чтения или записи информации в файл, его нужно открыть для доступа. Для этого обычно используется функция FILE*
fopen
(char*
имя_
файла,
char*
режим);
она берет внешнее представление – физическое имя файла на носителе (дискета, винчестер) и ставит ему в соответствие логическое имя. Физическое имя, т.е. имя файла и путь к нему задается первым параметром – строкой, например, “a:Mas_dat.dat” – файл с именем Mas_dat.dat, находящийся на дискете, “d:\\work\\Sved.txt” – файл с именем Sved.txt, находящийся на винчестере в каталоге work. Внимание!
Обратный слеш (\), как специальный символ, в строке записывается дважды. При успешном открытии функция fopen
возвращает указатель на файл (в дальнейшем – указатель файла). При ошибке возвращаетсяNULL
. Данная ситуация обычно возникает, когда неверно указывается путь к открываемому файлу. Например, если в дисплейном классе нашего университета указать путь, запрещенный для записи (обычно разрешенным является d:\work\). Второй параметр – строка, в которой задается режим доступа к файлу: w
– файл открывается для записи; если файла с заданным именем нет, то он будет создан; если такой файл существует, то перед открытием прежняя информация уничтожается; r
– файл открывается только для чтения; если такого файла нет, то возникает ошибка; a
– файл открывается для добавления в конец новой информации; r+
– файл открывается для редактирования данных – возможны и запись, и чтение информации; w+
– то же, что и для r+; a+
– то же, что и для a, только запись можно выполнять в любое место файла; доступно и чтение файла; t
– файл открывается в текстовом режиме;b
– файл открывается в двоичном режиме. Текстовый режим отличается от двоичного тем, что при открытии файла как текстового пара символов «перевод строки», «возврат каретки» заменяется на один символ: «перевод строки» для всех функций записи данных в файл, а для всех функций вывода символ «перевод строки» теперь заменяется на два символа: «перевод строки», «возврат каретки». По умолчанию файл открывается в текстовом режиме. Пример: FILE *f; – объявляется указатель на файл f; f = fopen ("d:\\work\\Dat_sp.cpp", "w"); – открывается для записи файл с логическим именем f, имеющим физическое имя Dat_sp.cpp, находящийся на диске d, в каталоге work; или более кратко FILE *f = fopen
("d:\\work\\Dat_sp.cpp", "w"); После работы с файлом доступ к нему необходимо закрыть. Это выполняет функция int
fclose
(указатель файла
). Например, из предыдущего примера файл закрывается так: fclose (f); Для закрытия нескольких файлов введена функция, объявленная следующим образом: void
fcloseall
(void
); Если требуется изменить режим доступа к файлу, то для этого сначала необходимо закрыть данный файл, а затем вновь его открыть, но с другими правами доступа. Для этого используют стандартную функцию: FILE* freopen
(char*имя_файла
, char *режим
, FILE *указатель_файла
); Эта функция сначала закрывает файл, объявленный указателем_файла
(как это делает функцияfopen
), а затем открывает файл сименем_файла
и правами доступа «режим
». В языке Си имеется возможность работы с временными файлами, которые нужны только в процессе работы программы. В этом случае используется функция FILE* tmpfile
(void); которая создает на диске временный файл с правами доступа «w+b», после завершения работы программы или после закрытия временного файла он автоматически удаляется. Все действия по чтению-записи данных в файл можно разделить на три группы: операции посимвольного ввода-вывода; операции построчного вводавывода; операции ввода-вывода по блокам. Рассмотрим основные функции, применяемые в каждой из указанных трех групп операций. Посимвольный ввод-вывод В функциях посимвольного ввода-вывода происходит прием одного символа из файла или передача одного символа в файл: Построчный ввод-вывод В функциях построчного ввода-вывода происходит перенос из файла или в Блоковый ввод-вывод В функциях блокового ввода-вывода работа происходит с целыми блоками информации: int fread
(void*p,
intsize,
– считывает n
блоков поsize
байт каждый из фай- int
n, FILE *f) ла f
в область памяти с указателемp
(необходимо int fwrite
(void*p,
intsize,
заранее отвести память под считываемый блок); – записывает n блоков по size байт каждый из об- int
n, FILE *f) ласти памяти с указателем p в файл f. Форматированный ввод-вывод производится функциями.18. Файлы в языке Си
18.1. Открытие файла
18.2. Закрытие файла
18.3. Запись – чтение информации
