"Файлы и организация ввода-вывода"

Файлы и их представления. Файлы являются существенной частью современных компьютерных систем. Они используются для хранения произвольной (текстовой, графической, аудио, видео и др.) информации. Файл - это именованный раздел для сохранения информации, обычно раздел на диске. Например, относительно stdio.h можно думать как об имени файла, содержащем некоторую полезную информацию.

Язык С рассматривает файл как последовательность байтов, каждый из которых может быть прочитан индивидуально. Стандартами установлено два вида представления файлов: текстовое и двоичное. В текстовом представлении то, что видит программа может отличаться от того, что находится в файле. В случае использования двоичного представления, программа будет видеть точно ту последовательность байтов, которая записана в файле.

Библиотека языка С поддерживает три уровня ввода-вывода: потоковый ввод-вывод, ввод-вывод нижнего уровня и ввод-вывод для консоли и портов.

Стандартные файлы. Программы С автоматически открывают три файла. Они имеют названия стандартный ввод (stdin), стандартный вывод (stdout) и стандартный вывод ошибок (stderr). Стандартный ввод - это по умолчанию обычное устройство ввода в системе, как правило, клавиатура. Оба стандартных вывода по умолчанию также представляют собой обычное устройство вывода, как правило, монитор.

Стандартный ввод естественным образом обеспечивает ввод для программ. Этот файл, который читается с помощью функций getchar(), gets(), scanf(). Стандартный вывод - это место, куда направляется обычный вывод программы. При обработке вывода используются функции putchar(), puts(), printf(). Назначение стандартного вывода ошибок заключается в обеспечении логически понятного направления для посылки сообщений об ошибках.

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

Функции С, поддерживающие обмен данными с файлами на уровне потока, позволяют обрабатывать данные различных размеров и форматов, обеспечивая при этом буферизованный ввод-вывод. Таким образом, поток - это файл вместе с предоставляемыми средствами буферизации. При работе с потоками можно производить следующие действия:

- открывать и закрывать потоки (т.е. связывать указатели на потоки с конкретными файлами);

- вводить и выводить: символ, строку, форматированные данные, порцию данных произвольной длины;

- анализировать ошибки потокового ввода-вывода и условие достижения конца файла;

- управлять буферизацией потока и размером буфера;

- получать и устанавливать указатель текущей позиции в потоке.

Все функции, необходимые для работы с потоками, описаны в заголовочном файле stdio.h.

1. Открытие и закрытие потока. Прежде чем начать работу с потоком, его следует открыть. При этом поток связывается в программе со структурой предопределенного типа FILE. Определение этой структуры находится в заголовочном файле stdio.h. В структуре FILE содержатся компоненты, с помощью которых ведется работа с потоком. В результате открытия в программу возвращается указатель на эту структуру, который идентифицирует поток во всех последующих операциях.

Для открытия используется функция fopen():

#include <stdio.h>

...

FILE *fp;

...

fp = fopen(<имя_файла>,<режим_открытия>)

...

Здесь аргументы <имя_файла> и <режим_открытия> - указатели на массивы символов, содержащих соответственно имя файла, связанного с потоком, и строку режимов открытия.

Существует шесть основных режимов открытия:

"w" (write)	новый текстовый файл открывается для записи. Если файл уже существовал, то его содержимое стирается и он создастся заново
"r" (read)	открывается только для чтения существующий текстовый файл
"a" (append)	текстовый файл открывается или создается для добавления в конец файла новой порции информации.
"w+" (write)	новый текстовый файл открывается для записи и последующей модификации. Если файл уже существует, то его содержание стирается. После открытия файла чтение и запись допустимы в любом месте, в том числе разрешена запись в конец файла.
"r+" (read)	существующий текстовый файл открывается как для чтения, так и для записи в любом месте файла; однако запись в конец, приводящая к увеличению размера файла недопустима.
"a+" (append)	текстовый файл открывается или создается с возможностью последующей модификации. В отличие от режима "w+" можно открыть существующий файл без уничтожения его содержимого; в отличие от режима "r+" можно записывать в конец файла, увеличивая его размеры.

В случае использования двоичных файлов к строке режима открытия следует добавить символ "b" ("wb", "rb", "ab", "w+b", "r+b","a+b"). В этом случае все преобразования, связанные с обработкой концов строк, будут отсутствовать.

При открытии потока могут возникнуть ошибки, например, "указанный файл не найден", "диск заполнен", "диск защищен от записи" и ряд других. В случае ошибки функция fopen() возвращает указатель со значением NULL. Для вывода на экран сообщения об ошибке используется функция perror(), прототип которой описан в stdio.h:

void perror (const char *s);

Функция выводит строку символов, адресуемую указателем s, за которой размещается двоеточие, пробел и сообщение об ошибке. Содержимое и формат сообщения определяются используемой системой программирования. Текст сообщения об ошибке выбирается функцией на основании номера ошибки. Этот номер заносится в глобальную переменную с именем errno ( определенную в заголовочном файле errno.h) при реализации библиотечных функций ввода-вывода.

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

int fclose(<указатель_на_поток>);

Открытый файл можно открыть повторно (например, для изменения режима работы с ним) только после того, как файл будет закрыт с помощью функции fclose().

Для изменения прав доступа к файлу, также существует функция

FILE * freopen(<имя_файла>,<режим_открытия>,<указатель_на_поток>)

Типичный фрагмент программы, связанный с открытием файла выглядит следующим образом:

if ((fp = fopen("Exampl.txt","w")) == NULL)

{

perror("Error opening file Exampl.txt \n");

exit(0);

}

2. Работа с потоками. Для обслуживания потоков, определяющих файлы на дисках используются функции библиотеки языка С:

fgetc(), getc() - чтение одного символа из файла;

fputc(), putc() - запись одного символа в файл;

fprintf() - форматированный вывод в файл;

fscanf() - форматированный ввод из файла;

fgets() - чтение строки из файла;

fputs() - запись строки в файл;

fread() - чтение из файла порции данных;

fwrite()- запись в файл порции данных.

2.1. Посимвольный обмен. Прототипы функций:

int getc(FILE *stream);

int fgetc(FILE *stream);

int putc(int c, FILE *stream);

int fputc(int c, FILE *stream);

Пример.

...

int c;

FILE *in;

...

c = getc(in);

2.2. Cтроковый обмен. При работе с текстовыми файлами очень часто удобно работать с применением функций строкового обмена. Прототипы функций:

int fputs(const char *str, FILE *stream);

char * fgets(char *str, int n, FILE *stream);

Функция fputs записывает строку str в файл, заданный указателем stream на поток, и возвращает неотрицательное целое. При ошибках функция возвращает значение EOF. Символ конца строки - '\0' в файл не переносится, и символ '\n' в файл не записывается.

Функция fgets читает из определяемого указателем stream файла не более (n - 1) символов и записывает их в строку str. Функция прекращает чтение, как только прочтет (n - 1) символов или встретит символ новой строки '\n', который переносится в строку str. При ошибках или при достижении конца файла, при условии, что из файла не прочитан ни один символ, функция возвращает значение NULL. Следует особо отметить, что в отличие от функции строкового ввода из стандартного потока (gets()) данная функция не отбрасывает символ '\n'.

2.3. Форматированный обмен. Для работы с файлами определены функции

int fscanf(FILE *stream, const char *format, ...);

int fprintf(FILE *stream, const char *format, ...);

которые аналогичны рассмотренным нами функциям scanf() и printf(), реализующими обмен со стандартными потоками.

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

size_t fread( void *buffer, size_t size, size_t count, FILE *stream );

size_t fwrite( const void *buffer, size_t size, size_t count, FILE *stream );

Функция fread() считывает из файла, определяемого указателем потока stream, в область памяти buffer count элементов размером по size байтов каждый. Функция возвращает число действительно прочитанных элементов. Если число элементов меньше заказанного (count), то это свидетельствует либо о достижении конца файла, либо об ошибке чтения. Чтобы проанализировать эту ситуацию можно воспользоваться функциями feof() или ferror(). Если файл открыт в текстовом режиме, то осуществляется замена символов конца строки ('\r\n' à '\n').

Функция fwrite() записывает count элементов, по size байтов каждый, из области памяти, задаваемой указателем buffer в поток stream. Функция возвращает число действительно записанных элементов. Если возвращаемое значение меньше заказанного (count) - то это свидетельствует о возникшей ошибке.

3. Позиционирование в потоке. Выполнение всех обменных операций с потоком связано с понятием текущей позиции в потоке. Начальная позиция чтения-записи установливается при открытии потока и может соответствовать либо первому байту файла (для режимов "write" или "read"), либо конечному (за последним байтом) (для режима "append"). При выполнении операций ввода-вывода текущая позиция в потоке меняется в соответствии с количеством прочитанных или записанных байтов.

Программисту даются средства для управления позиционированием в потоках, связанных с файлами (но не потоков, связанных с устройствами! Например, стандартных).

Функция fseek() позволяет установить указатель текущей позиции в потоке на нужный байт. Прототип этой функции:

int fseek( FILE *stream, long offset, int origin );

здесь offset - смещение, может быть как отрицательным так и положительным, т.е. возможно изменение текущей позиции по файлу и вперед, и назад;

origin - начало отсчета - задается при помощи одной из предопределенных констант:

SEEK_SET () - начало файла (значение 0);

SEEK_CUR () - текущая позиция (значение 1);

SEEK_END ()- конец файла (значение 2).

Примеры:

fseek(fp,0L,SEEK_SET); // Перемещение к началу файла (из любой позиции)

fseek(fp,0L,SEEK_END); // Перемещение к концу файла (из любой позиции)

fseek(fp,-2L,SEEK_СUR); // Возврат на два байта от текущей позиции

fseek(fp,12L,SEEK_СUR); // Пропуск 12 байтов от текущей позиции

Для получения значения указателя текущей позиции в потоке служит функция

long ftell( FILE *stream);

Пример:

long pos;

FILE * fp;

...

pos = ftell(fp); //Запомнить текущую позицию

...

fseek(fp, pos, SEEK_SET); // Восстановить запомненное значение

...

4. Контроль исполнения потоковых операций. Для проверки условия достижения конца файла служит функция

int feof( FILE *stream );

Функция возвращает не нулевое значение после первой операции чтения после достижения конца файла. Если конец файла не достигнут возвращается 0.

Для контроля ошибок обмена служит функция

int ferror( FILE *stream );

Если ошибок нет - функция возвращает значение 0, в противном случае - не 0. После возникновения ошибки индикатор ошибки, связанный с данным потоком, остается установленным до закрытия или изменения текущей позиции файла или выполнения функции очистки clearer().

Для сброса индикатора ошибки потока служит функция

void clearerr( FILE *stream );

:

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

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

Линейный односвязный список представляет собой самый обыкновенный список: каждый элемент связан только с одним элементом, который называется элементом, следующим за данным. Сам элемент по отношению к следующему называется предшествующим или предыдущим. Последний элемент списка содержит. признак конца списка.

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

struct Node{

тип d; // тип данных информационного поля

Node *next;

};

Самьми распространенными случаями линейного односвязного списка являются очередь и стек.

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

Ниже приведена программа, которая формирует очередь из пяти целых чисел и выводит ее на экран. Функция помещения в конец очереди называется add, а выборки — del. Указатель на начало очереди называется pbeg, указатель на конец — pend.

#include <iostream.h>

#include <conio.h>

struct Info

{int i;

};

struct FIFO{

Info d;

FIFO *next;

};

FIFO * first(Info d); //Формирование 1 элемента очереди

void add(FIFO **pend, Info d);

Info del(FIFO **pbeg);

//--.------...----------...--..-.....-----.-....--

int main(){

Info d;

d.i=1;

FIFO *pbeg = first (d);

FIFO *pend = pbeg;

for (int i = 2; i<6; i++)

{d.i=i;

add(&pend, d);

}

while (pbeg)

{d=del(&pbeg);

cout<<d.i<<' ';

}

getche();

return 0;

} //----..----------.---------.-..--------...-----..

// Начальное формирование очереди

FIFO *first(Info d)

{

FIFO *pv = new FIFO;

pv->d = d;

pv->next = 0;

return pv;

} //.-.---.----------------------------------------

// Добавление в конец

void add(FIFO **pend, Info d)

{

FIFO *pv = new FIFO;

pv->d = d;

pv->next = 0;

(*pend)->next = pv;

*pend = pv;

} //--.-------------------------.------------..---.-

// Выборка

Info del(FIFO **pbeg)

{

Info temp = (*pbeg)->d;

FIFO *pv = *pbeg;

*pbeg = (*pbeg)->next;

delete pv;

return temp;

}

Результат работы программы:

12345

Стек — это список с таким способом связи между элементами, при котором элементы добавляются строго в начало списка и извлекаются тоже строго из начала списка. Принцип организации: "Первым пришел — последним ушел".

Ниже приведена программа, которая формирует стек из пяти целых чисел (1, 2, 3, 4, 5) и выводит его на экран Функция помещения в стек называется add, а выборки — del Указатель для работы со стеком (top) всегда ссылается на его вершину

#include <iostream.h>

#include <conio.h>

struct Info

{int i;

};

struct LIFO{

Info d;

LIFO *next;

};

LIFO * first(Info d); //Формирование 1 элемента очереди

void add(LIFO **top, Info d);

Info del(LIFO **top);

//--.------...----------...--..-.....-----.-....--

int main(){

Info d;

d.i=1;

LIFO *top = first (d);

for (int i = 2; i<6; i++)

{d.i=i;

add(&top, d);

}

while (top)

{d=del(&top);

cout<<d.i<<' ';

}

getche();

return 0;

} //----..----------.---------.-..--------...-----..

// Начальное формирование очереди

LIFO *first(Info d)

{

LIFO *pv = new LIFO;

pv->d = d;

pv->next = 0;

return pv;

} //.-.---.----------------------------------------

// Добавление в конец

void add(LIFO **top, Info d)

{

LIFO *pv = new LIFO;

pv->d = d;

pv->next = *top;

*top = pv;

} //--.-------------------------.------------..---.-

// Выборка

Info del(LIFO **top)

{

Info temp = (*top)->d;

LIFO *pv = *top;

*top = (*top)->next;

delete pv;

return temp;

}