Использование структур и файлов в языке С

Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

Дипломная работа

Использование структур и файлов в языке С

Гомель 2023

Содержание

Введение

1. Структуры в языке C

1.1 Основные понятия о структурах

1.2 Создание структурных переменных

1.3 Вложенные структуры, массивы структур

1.4 Размещение структур в памяти

2. Файлы в языке C

2.1 Общие понятия

2.2 Этапы работы с файлом

2.2.1 Открытие файла

2.2.2 Обработка файла

2.2.3 Закрытие файла

2.3 Понятие потока

2.4 Ввод/вывод в поток

2.4.1 Позиционирование в файле

2.4.2 Функции задания положения указателя

2.4.3 Функции чтения и записи потока байтов

2.4.4 Функции чтения символа из потока

2.4.5 Функции записи символа в поток

2.4.6 Функции чтения строки из потока

2.4.7 Функции записи строки в поток

2.4.8 Функции форматированного ввода из потока

2.4.9 Функции форматированного вывода в поток

2.5 Функции обработки ошибок

3. Использование структур и файлов

3.1 Постановка задачи и описание структуры

3.2 Визуальное приложение

Заключение

Список используемых источников

Приложение A. Текст визуального приложения

Введение

В течение трех последних десятилетий С стал одним из основных и наиболее широко распространенных языков программирования. Его популярность росла в связи с тем, что люди предпринимали попытки работать с ним, во время которых он показывал себя с лучшей стороны. За последнее десятилетия многие программисты перешли с языка на более претенциозный язык С++, но язык С сам по себе все еще остается важным языком, равно как и путем перехода к С++. Он обладает многими достоинствами. Мощные управляющие структуры, компактный программный код - небольшие программы, быстродействие, переносимость на другие компьютеры.

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

Все это позволяет получать надежные и понятные программы.

Поскольку язык С тесно связан с Unix, операционные системы семейства Unix поставляются с компилятором С в виде части соответствующих пакетов.

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

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

Такая гибкость является достоинством и одновременно означает опасность. Достоинство заключается в том, что решение многих задач, таких как преобразование форматов данных, в С намного проще, чем в других языках. Опасность состоит в том, что вы можете допускать такие ошибки, которые просто невозможны в других языках. Язык С предоставляет вам большую свободу действий, но при этом накладывает и большую ответственность.

В дипломном проекте рассматривается предметная область «Товары в продуктовом магазине», для которой необходимо создать приложение для обработки и поиска информации в визуальном режиме.

Визуальное приложение будет создано в среде C++ Builder 6.0. В приложении должно быть реализовано добавление, удаление, вставка, отображение записей, отбор записей из файла по условию.

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

Диалог с пользователем в приложении осуществляется посредством меню.

1. Информация о структурах

1.1 Основные понятия о структурах

Структура - это множество логически связанных именованных элементов различных типов.

Термин «структура» в языке Си соответствует двум разным по смыслу понятиям:

- структура - это обозначение участка оперативной памяти, где располагаются конкретные значения данных; в дальнейшем - это структурная переменная, поля которой располагаются в смежных областях памяти;

- структура - это правила формирования структурной переменной, которыми руководствуется компилятор при выделении ей места в памяти и организации доступа к ее полям.

Структура представляет собой сложный тип данных, составленный из простых типов. Поля (элементы структуры) - переменные или массивы стандартного типа (int, char и т.п) или другие, ранее описанные структуры.

Общая форма объявления структуры:

Struct ИмяСтруктуры

{

тип ИмяЭлемента1;

тип ИмяЭлемента2;

...

тип ИмяЭлементаn;

};

После закрывающей фигурной скобки } в объявлении структуры обязательно ставится точка с запятой.

Пример объявления структуры:

struct date

{

int day; // 4 байта

char *month; // 4 байта

int year; // 4 байта

};

Поля структуры располагаются в памяти в том порядке, в котором они объявлены (рисунок 1.1).

Рисунок 1.1 - Хранение в памяти структуры

В указанном примере структура date занимает в памяти 12 байт. Кроме того, указатель *month при инициализации будет началом текстовой строки с названием месяца, размещенной в памяти [2].

Пример структуры:

struct persone

{

char lastname[20]; // фамилия

char firstname[20]; // имя

struct date bd; // дата рождения

};

Инициализация полей структуры может осуществляться двумя способами:

1) присвоение значений элементам структуры в процессе объявления переменной, относящейся к типу структуры;

2) присвоение начальных значений элементам структуры с использованием функций ввода-вывода (например, printf() и scanf()).

В первом способе инициализация осуществляется по следующей форме:

Struct ИмяСтруктуры ИмяПеременной=

{ЗначениеЭлемента_1, ЗначениеЭлемента_2,..., ЗначениеЭлемента_n};

Второй способ инициализации объектов языка Си с использованием функций ввода-вывода.

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

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

- задание шаблона структуры

- описание структурной переменной.

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

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

В общем случае при работе со структурами следует выделить четыре момента:

- объявление и определение типа структуры;

- объявление структурной переменной;

- инициализация структурной переменной;

- использование структурной переменной.

1.2 Создание структурных переменных

Структурная переменная - это переменная типа, который задан в шаблоне структуры. Если объявляется такая переменная, то происходит выделение памяти для нее. Структурная переменная еще называется экземпляром структуры.

Структура определяет составные части структурной переменной, другими словами определяет новый составной тип данных, этот тип данных определяет сам пользователь [3].

Структурную переменную можно объявить несколькими способами:

- на основе шаблона, который был объявлен раньше;

- во время объявления шаблона;

- с помощью квалификатора typedef.

Описания структурных переменных синтаксически аналогичны ранее изученным описаниям Си: <тип> <список_переменных>.

Для структурных переменных <тип> задается шаблонам структуры, который может иметь один из видов:

1. структурный шаблон с именем:

struct имя шаблона {<описание полей структуры>};

2. структурный шаблон с именем и списком переменных:

struct имя шаблона {<описание полей структуры>}<список переменных>;

3. структурный шаблон без имени:

struct{<описание полей структуры>} <список переменных>.

В языке С++ в качестве полей можно задавать и определения функций. Фактически имя шаблона это имя нового типа, созданного пользователем.

Например, объявим структуру для описания данных для хранения информации о служащем:

struct Worker

{

int code; // код работника

char name[50]; // имя работника

int hours; // количество отработанных часов

float cost; // расценка за 1 час

};

struct Worker zap1, zap2, zap3;

Имя структурного типа данных обычно записывается строчными буквами с целью лучшего визуального отличия от имен переменных.

После создания типа объявлены три структурные переменные: zap1, zap2, zap3. В языке Си слово struct при объявлении переменных указывать необязательно. Можно было объявить переменные одновременно с созданием шаблона:

struct Worker

{

int code; // код работника

char name[50]; // имя работника

int hours; // количество отработанных часов

float cost; // расценка за 1 час

} zap1, zap2, zap3;

Первый способ предпочтительнее: тип отдельно, объявление переменные отдельно.

С одной стороны данные, содержащиеся в переменных zap1, zap2 и zap3, рассматриваются как нечто единое, а с другой стороны, Си обеспечивает возможность доступа и к отдельным подполям структурной переменной.

Для определения размера памяти занимаемой структурной переменной рекомендуется использовать операцию sizeof.

Ссылка на поле структурной переменной обладает всеми свойствами обычных переменных. Для упрощения описания структурных переменных можно использовать оператор typedef описания собственного типа данных. Это упрощает текст программы и экономит силы на повторный набор слова struct при описании структурных переменных.

Если структурные переменные соответствуют одному шаблону, допускается операция присваивания таких структурных переменных.

Разрешается объединять задание шаблона, описание структурных переменных и их инициализацию в одном предложении языка Си [4].

Общая форма предложения конструирования собственного типа данных:

typedef описание_типа имя_нового_типа.

Пример:

typedef struct Wrk

{

int code;

char name[50];

int hours;

float cost;

} WORKER;

Затем можно использовать сконструированный тип для описания необходимых данных, например, так: WORKER w1.

Здесь используется для создания собственного типа именованный шаблон Wrk. Однако использование имени шаблона совсем не обязательно.

Обычно, при разработке больших программ с большим количеством структур описания структурных шаблонов помещаются в файлы-заголовки и включаются в программу при помощи директивы препроцессора include.

Для доступа к отдельным полям структурной переменной используют операцию '.', формируя ссылку на нужное поле посредством имени структурной переменной и имени нужного поля [5].

Такая ссылка может располагаться в любом месте выражений, где допустимы ссылки на простые переменные.

1.3 Вложенные структуры, массивы структур

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

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

Тип вложенной структуры должен быть объявлен раньше. Кроме того, структура не может быть вложена в структуру того же типа. Так как Си не накладывает никаких ограничений на типы полей структуры, то структурная переменная вполне допускается в качестве элемента шаблона.

Например, в описанной выше структуре RECORD элемент name может в свою очередь представлять структуру:

struct NAME

{

char fam[10]; /* Фамилия */

char im[10]; /* Имя */

};

Тогда описание структуры будет иметь вид:

struct RECORD

{

int num;

struct NAME name;

float wage;

};

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

Например, компилятор сообщит об ошибке при обработке следующего описания:

struct MORE

{

int volna;

char veter [21];

struct MORE black; /* Неправильно */

};

Однако ошибки не будет, если такое описание шаблона задано структурной переменной, так как в этом случае переменная black является указателем на тип struct MORE, а не структурной переменной типа struct MORE.

struct MORE

{

int volna;

char veter [21];

struct MORE *black; /* Правильно */

};

По аналогии с простыми переменными несколько структурных переменных с одинаковыми шаблонами могут быть объединены в массив структур.

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

Например, описание struct RECORD pos[12] определяет массив из 12 элементов, где pos[0], pos[1],..., pos[11] - структурные переменные типа RECORD.

Доступ к элементам структуры или объединения можно осуществить с помощью указателей.

Указатели на структурные переменные широко используются для доступа к структурам, размещаемым в динамически выделяемой памяти, при создании сложных структур данных - списков, стеков, деревьев, для передачи в качестве фактических аргументов функциям.

Доступ к элементам массива может выполняться с использованием индекса или через указатель-константу, которым является имя массива.

Выделение оперативной памяти структурной переменной осуществляется по шаблону, интерпретируемому слева направо. При этом учитывается дополнительный фактор, называемый выравниванием структуры.

Выравнивание задается либо как опция IDE, либо опцией компилятора командной строки. Может быть задано выравнивание структурной переменной на границе слова или на границе байта.

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

Начинаться переменная будет с любого адреса; ее длина равна сумме длин полей шаблона.

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

1) отдельная структурная переменная (элемент массива структурных переменных) начинается на границе слова, т. е. с четного адреса;

2) любое поле, тип которого не совпадает с типом char, будет начинаться с четного адреса (имеет четное смещение от начала структурной переменной);

3) при необходимости в конце структурной переменной добавляется еще один байт так, чтобы число байтов переменной было четным.

Выравнивание сказывается критическим образом при переносе структурных переменных между диском и памятью.

1.4 Размещение структур в памяти

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

- структурные переменные, являющиеся элементами массива, начинаются на границе слова, т.е. с четного адреса;

- любое поле структурной переменной начинается на границе слова, т.е. с четного адреса и имеет четное смещение по отношению к началу переменной;

- при необходимости в конец переменной добавляется пустой байт, чтобы общее число байт было четное.

Рассмотрим следующий пример кода:

struct TestStruct

{

public short First;

public byte Second;

}

class Program

{

static void Main()

{

TestStruct s = new TestStruct();

Console.WriteLine("Размер структуры в байтах: " + Marshal.SizeOf(s));

Console.ReadKey();

}

}.

В структуре TestStruct объявлены два поля: First типа short (2 байта) и Second тип byte (1 байт). В методе Main()создается экземпляр этой структуры и в консоль выводится ее размер в байтах.

Можно было бы подумать, что размер структуры будет равен 3 байтам, сумме размеров полей структуры. Однако если запустить предыдущий пример, в консоль выводится размер в 4 байта.

Рисунок 1.2 - Вывод размера структуры

Такой результат получился благодаря тому, что среда CLR по умолчанию уместить элементы структуры в блоках, размер которых равен размеру самого большого элемента в структуре. Так как в приведенной структуре размер самого большего поля - First - равен 2 байтам, то все поля размещаются в блоках по 2 байта.

Рисунок 1.3 - Выравнивание полей структуры

На рисунке первые два байта были заняты полем First (short), третий байт полем Second (byte). В конце был добавлен еще один байт - «заполнитель» - для выравнивания до 2-х байт. Он не содержит никакой полезной информации и служит только для удобства управления структурой средой CLR.

Наличие «заполнителей» зависит от порядка следования полей в структуре.

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

Объединенный тип данных декларируется подобно структурному:

union ID_объединения

{

описание полей;

};

Пример описания объединенного типа:

union word

{

int nom;

char str[20];

};

Пример объявления объектов объединенного типа:

union word *p_w, mas_w[100].

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

Декларация данных типа union, создание переменных этого типа и обращение к полям объединений производится аналогично структурам.

Перечисления - это средство создания типа данных посредством задания ограниченного множества значений.

Определение перечислимого типа данных имеет вид

enum ID_перечислимого типа

{

список значений;

};

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

enum marks {zero, two, three, four, five }.

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

Например:

enum level {low=100, medium=500, high=1000, limit}.

Примеры объявления переменных перечислимого типа:

enum marks Est;

enum level state;

Переменная типа marks может принимать только значения из множества {zero, two, three, four, five}.

Основные операции с данными перечислимого типа:

- присваивание переменных и констант одного типа;

- сравнение для выявления равенства либо неравенства.

Практическое назначение перечисления - определение множества различающихся символических констант целого типа.

2. Файлы в языке Cи

2.1 Общие понятия

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

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

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

Бинарные (двоичные) файлы представляют собой последовательность данных, структура которых определяется программно.

В языке Си имеется большой набор функций для работы с файлами, большинство которых находятся в библиотеках stdio.h и io.h.

Файл имеет следующие атрибуты:

- имя файла. Создается по правилам составления идентификаторов в операционной системе, например, D:\fail.txt;

- тип компонентов. Например, файл может представлять собой последовательность строк или последовательность байтов.

- длина файла. Это число компонент файла.

- указатель файла. Это переменная специального типа, предназначенная для указания на компонент (позицию) файла. Значение указателя файла изменяется после каждого выполнения операции чтения или записи данных.

Стандартные аппаратные устройства ПК, такие как клавиатура, экран дисплея, печатающее устройство (принтер) и коммуникационные каналы ввода-вывода, определяются специальными именами, которые называются логическими устройствами:

- con - логическое имя, которое определяет консоль (клавиатуру или экран дисплея);

- prn - логическое имя принтера. Если к ПК подключено несколько принтеров, доступ к ним осуществляется по логическим именам LPT1, LPT2, LPT3. Первоначально prn и LPT3 - синонимы;

- aux - логическое имя коммуникационного канала, который используется для связи ПК с двумя машинами. Коммуникационный канал может осуществлять передачу и прием данных. Как правило, имеется 2 коммуникационных канала: com1 и com2. Первоначально aux и com1 - синонимы.

NUL - логическое имя "пустого" устройства. Чаще всего используется в отладочном режиме как устройство-приемник информации неограниченной емкости. При обращении к NUL как к источнику информации, выдается признак конца файла (EOF).

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

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

При чтении каждого символа из файла (или записи в файл) указатель текущей позиции увеличивается. Тем самым обеспечивается продвижение по файлу. Файл отсоединяется от определенного потока с помощью операции закрытия файла. При закрытии файла, открытого с целью вывода, содержимое связанного с ним потока записывается на внешнее устройство. При этом гарантируется, что никакая информация случайно не останется в буфере диска [4].

Если программа завершает работу нормально, то есть либо main() возвращает управление операционной системе, либо выход происходит через exit(), то все файлы закрываются автоматически.

В случае же аварийного завершения работы программы, например, в случае краха или завершения путем вызова abort(), файлы не закрываются.

У каждого потока, связанного с файлом, имеется управляющая структура, содержащая информацию о файле. Она имеет тип FILE.

Блок управления файлом - это небольшой блок памяти, временно выделенный операционной системой для хранения информации о файле, который был открыт для использования.

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

Для выполнения всех операций ввода/вывода следует использовать только понятия потоков и применять всего лишь одну файловую систему. Ввод или вывод от каждого устройства автоматически преобразуется системой в легко управляемый поток.

Таковы основополагающие замечания относительно существования различных потоков информации и связанных с ними файлов.

2.2 Этапы работы с файлом

Файл в программе на языке С - это переменная - указатель на тип FILE, называемая файловой переменной.

Работа с файлами состоит их трех этапов:

1. открытие файла;

2. обработка файла;

3. закрытие файла.

2.2.1 Открытие файла

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

Данная функция берет внешнее представление файла (например, c:\my_prog.txt) и связывает его с внутренним логическим именем, которое используется далее в программе.

Логическое имя - это указатель на требуемый файл. Его необходимо определить; делается это, например, так: FILE *fp.

Здесь FILE - имя типа, описанное в стандартном заголовочном файле stdio.h, а fp - указатель на файл [8].

Обращение к функции fopen() в программе осуществляется выражением:

fp = fopen(спецификация файла, "способ использования файла");

Способ использования файла задается следующими символами:

- r - открыть существующий файл для чтения;

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

- а - дополнить файл (открыть существующий файл для записи информации, начиная с конца файла, или создать файл, если он не существует);

- r+ - открыть существующий файл для чтения и записи;

- w+ - создать новый файл для чтения и записи;

- a+ - дополнить или создать файл с возможностью чтения и записи;

- rb - открыть двоичный файл для чтения;

- wb - создать двоичный файл для записи;

- аb - дополнить двоичный файл;

- r+b - открыть двоичный файл для чтения и записи;

- w+b - создать двоичный файл для чтения и записи;

- а+b - дополнить двоичный файл с предоставлением возможности чтения и записи;

- rt - открыть текстовой файл для чтения;

- wt - создать текстовый файл для записи;

- at - дополнить текстовый файл;

- r+t - открыть текстовой файл для чтения и записи;

- w+t - создать текстовый файл для чтения и записи;

- a+t - дополнить текстовый файл с предоставлением возможности записи и чтения.

По умолчанию (когда в режиме открытия файла отсутствует t или b) файл открывается в текстовом режиме.

Если режим t или b не задан, то он определяется значением глобальной переменной fmode.

Если fmode=0_BINARY, то файлы открываются в двоичном режиме, а если fmode=0_TEXT - в текстовом режиме.

Константы 0_BINARY и 0_ТЕXТ определены в файле fcntl.h. Строки вида r+b можно записывать и в другой форме: rb+.

Если в результате обращения к функции fopen() возникает ошибка, то она возвращает константу NULL.

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

Возвращаемое функцией значение нужно сохранить и использовать для ссылки на открытый файл.

Таким образом, для работы с функцией fopen() в программе на языке С необходимо:

- объявить переменную-указатель на структуру типа FILE, например: FILE* f. Эта переменная (f) называется файловой переменной или файлом;

- файловой переменной присвоить значение, возвращаемое функцией fopen, например: f=fopen("c:\mdoc\d.txt", "r+").

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

FILE*f = fopen ("c:\mdoc\d.txt","r+");

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

if ((fp = fopen("c:\\my_prog.txt", "rt")) == NULL)

{

puts("Открыть файл не удалось\n");

exit(1);

}

После открытия файла все действия над файловой переменной будут отождествляться с действиями над внешним файлом (физическим файлом), т.е. с файловой переменной связывается определенный физический поток. При этом структуре типа FILE выделяется область ОП, адрес которой возвращает функция fopen(). Поток связывается со структурой типа FILE.

Структура типа FILE используется функциями ввода/вывода для хранения информации, связанной с устройством или файлом. Указатель на тип FILE используется для операций с файлом с помощью библиотечных функций. Его передают библиотечным функциям в качестве параметра. Такие библиотечные функции называются функциями ввода/вывода.

2.2.2 Обработка файла

Рассмотрим основные библиотечные функции, используемые для работы с файлами (все они описаны в файле stdio.h).

Функция putc() записывает символ в файл и имеет следующий прототип:

int putc(int с, FILE *fp),

где fp - указатель на файл, возвращенный функцией fopen(); с - символ для записи (переменная с имеет тип int, но используется только младший байт).

При успешном завершении putc() возвращает записанный символ, в противном случае возвращается константа EOF. Она определена в файле stdio.h и имеет значение -1.

Функция getc() читает символ из файла и имеет следующий прототип:

int getc(FILE *fp),

где fp - указатель на файл, возвращенный функцией fopen().

Эта функция возвращает прочитанный символ. Соответствующее значение имеет тип int, но старший байт равен нулю. Если достигнут конец файла, то getc() возвращает значение ЕОF.

Функция feof() определяет конец файла при чтении двоичных данных и имеет следующий прототип:

int feof(FILE *fp),

где fp - указатель на файл, возвращенный функцией fopen().

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

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

Функция fgets() читает строку символов из файла. Она отличается от функции gets() тем, что в качестве второго параметра должно быть указано максимальное число вводимых символов плюс единица, а в качестве третьего - указатель на переменную файлового типа. Строка считывается целиком, если ее длина не превышает указанного числа символов, в противном случае функция возвращает только заданное число символов. Функция возвращает указатель на строку string при успешном завершении и константу NULL в случае ошибки либо достижения конца файла.

Функция fprintf() выполняет те же действия, что и функция printf(), но работает с файлом. Ее отличием является то, что в качестве первого параметра задается указатель на переменную файлового типа.

Например: fprintf(fp, "%х",а).

Функция fscanf() выполняет те же действия, что и функция scanf(), но работает с файлом. Ее отличием является то, что в качестве первого параметра задается указатель на переменную файлового типа. При достижении конца файла возвращается значение EOF. Например: fscanf(fp, "%х", &a).

Функция fseek() позволяет выполнять чтение и запись с произвольным доступом и имеет следующий прототип:

int fseek(FILE *fp, long count, int access),

где fp - указатель на файл, возвращенный функцией fopen(); count - номер байта относительно заданной начальной позиции; access - способ задания начальной позиции [8].

Переменная access может принимать следующие значения:

- 0 - начальная позиция задана в начале файла;

- 1 - начальная позиция считается текущей;

- 2 - начальная позиция задана в конце файла.

При успешном завершении возвращается нуль, при ошибке - ненулевое значение.

Функция ferror() позволяет проверить правильность выполнения последней операции при работе с файлами. Имеет следующий прототип:

int ferror(FILE *fp).

В случае ошибки возвращается ненулевое значение, в противном случае возвращается нуль.

Функция remove() удаляет файл и имеет следующий прототип:

int remove(char *file_name),

где file_name - указатель на строку со спецификацией файла.

При успешном завершении возвращается нуль, в противном случае возвращается ненулевое значение [6].

Функция rewind() устанавливает указатель текущей позиции в начало файла и имеет следующий прототип:

void rewind(FILE *fp).

Функция fread() предназначена для чтения блоков данных из потока. Имеет прототип:

unsigned fread(void *ptr, unsigned size, unsigned n, FILE *fp).

Она читает n элементов данных, длиной size байт каждый, из заданного входного потока fp в блок, на который указывает указатель ptr.

Общее число прочитанных байтов равно произведению n*size. При успешном завершении функция fread() возвращает число прочитанных элементов данных, при ошибке - 0.

Функция fwrite() предназначена для записи в файл блоков данных. Имеет прототип:

unsigned fwrite(void *ptr, unsigned size, unsigned n, FILE *fp).

Она добавляет n элементов данных, длиной size байт каждый, в заданный выходной файл fp. Данные записываются с позиции, на которую указывает указатель ptr.

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

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

- stdin - для ввода данных из стандартного входного потока (по умолчанию - c клавиатуры);

- stdout - для вывода данных в стандартный выходной поток (по умолчанию - на экран дисплея);

- stderr - файл для вывода сообщений об ошибках (всегда связан с экраном дисплея);

- stdprn - для вывода данных на принтер;

- stdaus - для ввода и вывода данных в коммуникационный канал.

Заголовок <stdio.h> представляет прототипы функций ввода/вывода в Си и определяет следующие три типа: size_t, fpos_t и FILE.

Первые два: size_t, fpos_t представляют собой разновидности такого типа, как целое без знака.

2.2.3 Закрытие файла

Для закрытия потоков, используемых в программе, применяются стандартные функции fclose() и fcloseall().

Один заданный поток закрывается функцией fclose. Ее прототип:

int fclose (FILE *stream),

где stream - поток.

Пример обращения к функции fclose: fclose (f);

Если поток успешно закрыт, функция fclose возвращает значение 0. Если при закрытии потока произошла ошибка - значение EOF (-1).

Функция fcloseall() закрывает все потоки, открытые с помощью fopen(), кроме stdin, stdout, stderr. Прототип функции fcloseall:

int fcloseall().

Функция fcloseall() возвращает количество закрытых потоков или значение EOF (-1), если при закрытии произошла ошибка [1].

Примечание. Функция perror()позволяет вывести сообщение об ошибке при неуспешном закрытии файла. Ее прототип:

void perror(const char *s).

Пример использования данной функии:

FILE * fp;

fp=fopen("d.dat", "r");

if(!fp) perror("Нельзя открыть файл для чтения");

else fclose ("d.dat");

2.3 Понятие потока

При вводе/выводе данные рассматриваются как поток байтов. В языке Си отсутствуют операторы для работы с файлами. Все необходимые действия выполняются с помощью функций, включенных в стандартную библиотеку. Они позволяют работать с различными устройствами, такими, как диски, принтер, коммуникационные каналы и т.д.

Эти устройства сильно отличаются друг от друга. Однако файловая система преобразует их в единое абстрактное логическое устройство, называемое потоком.

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

Чтение данных из потока называется извлечением, вывод в поток - помещением или включением.

Обмен с потоками для увеличения скорости передачи данных производится, как правило, через специальную область ОП - буфер. При выводе фактическая передача данных происходит после заполнения буфера.

При вводе фактическая передача данных происходит, если буфер исчерпан [3].

По направлению обмена потоки можно разделить на входные (данные вводятся в память), выходные (данные выводятся из памяти) и двунаправленные (происходит как извлечение, так и включение).

По виду устройств, с которыми работает поток, можно разделит потоки на следующие виды: стандартные, файловые и строковые.

Стандартные потоки предназначены для передачи данных от клавиатуры в память ПК, или из памяти ПК на экран дисплея и принтер.

Файловые потоки предназначены для обмена информацией с файлами на внешних носителях данных.

Строковые потоки - для работы с массивами символов в ОП.

По структуре данных поток может быть текстовым или бинарным (двоичным).

Текстовый поток - это последовательность строк, каждая из которых имеет нуль или более ASCII-символов и заканчивается символом "\n" - конца строки и перехода к следующей строке. Текстовые файлы могут быть просмотрены и отредактированы с клавиатуры любым текстовым редактором.

Бинарный (двоичный) поток - это последовательность байтов без учета разделения на строки. Каждая программа для своих бинарных файлов определяет собственную структуру.

Для работы с потоками существуют стандартные библиотеки stdio, string, stdlib, io, которые становятся доступными из функций пользователя после использования директивы препроцессора #include.

В файловой системе языка Си в начале выполнения каждой программы автоматически открываются 5 предопределенных потоков.

Три из них относятся к стандартным потокам:

- stdin - стандартный поток ввода;

- stdout - стандартный поток вывода;

- stderr - стандартный поток ошибок.

Обычно эти потоки направляются к консоли. Но можно перенаправить их на другое устройство в тех операционных системах, которые поддерживают перенаправление [8].

Перенаправления ввода/вывода поддерживаются такими операционными системами, как Windows, DOS, UNIX, OS/2. Можно использовать stdin, stdout и stderr как указатели файлов во всех функциях, применяющих тип FILE.

Так как стандартные потоки являются указателями файлов, то они могут использоваться системой ввода/вывода языка Си также для выполнения операций ввода/вывода на консоль.

Вообще говоря, stdin используется для считывания с консоли (как известно, консоль это клавиатура + дисплей), а stdout и stderr - для записи на консоль.

В роли указателей файлов потоки stdin, stdout и sdterr можно применять в любой функции, где используется переменная типа FILE *.

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

Функции консольного ввода/вывода направляют результаты своих операций на одни из потоков - stdin или stdout, и по сути каждая из них является специальной версией соответствующей файловой функции.

Функции консольного ввода/вывода для того и существуют, чтобы удобно было именно программисту.

Ввод/вывод на консоль можно выполнять с помощью любой файловой функции языка Си [8].

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

Дело в том, что все эти операции консольного ввода/вывода выполняются с потоками stdin и stdout.

В средах, поддерживающих перенаправление ввода/вывода, это равносильно тому, что stdin и stdout могут быть перенаправлены на устройство, отличное от клавиатуры или экрана.

2.4 Ввод/вывод в поток

Ввод/вывод в поток можно осуществить разными способами:

- в виде последовательности байтов;

- в виде символов и строк;

- с использованием форматных преобразований.

Операции ввода/вывода выполняются, начиная с текущей позиции потока. Текущая позиция определяется положением указателя потока.

Указатель потока устанавливается на начало или конец файла при открытии в соответствии с режимом открытия. После каждой операции ввода/вывода указатель потока автоматически изменяется [2].

2.4.1 Позиционирование в файле

Функции получения текущего положения указателя потока ftell() и fgetpo().

Прототип функции ftell() (из <stdio.h>):

long int ftell(File *f).

Функция ftell()возвращает текущую позицию в файле, связанном с потоком f, как длинное целое. В случае ошибки возвращает число (-1).

Прототип функции fgetpos() (из <stdio.h>):

int fgetpos (File *f, fpos_t *pos).

Функция fgetpos() возвращает текущую позицию в файле, связанном с потоком f, и копирует значение текущей позиции по адресу pos. Это значение позднее может использоваться функцией.

Возвращаемое значение имеет тип fpos_t, который используется функциями fgetpos() и fsetpos() для хранения текущей позиции файла: typedef long fpos_t.

2.4.2 Функции задания положения указателя

Прототип функции fseek():

int fseek (File *f, long off, int org).

Функция перемещает текущую позицию в файле, связанном с потоком f, на позицию off, отсчитываемую от значения org, которое должно быть равно одной из констант, определенных в <stdio.h>:

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

- SEEK_END - от конца файла (2);

- SEEK_SET - от начала файла (0).

Параметр off задает количество байтов, на которое необходимо сместить указатель соответственно параметру org [8].

Величина смещения может быть как положительной, так и отрицательной, но нельзя сместиться за пределы начала файла. Такой доступ к данным в файле называется произвольным.

Прототип функции fsetpos():

int fsetpos (File *f, const fops_t *pos).

Функция перемещает текущую позицию в файле, связанном с потоком f, на позицию *pos, предварительно полученную с помощью функции fgetpos().

Примечание. Функции fseek() и fsetpos() нельзя использовать для стандартных потоков.

Функция rewind() очищает флаги ошибок при работе с потоками и переходит к началу файла. Ее прототип:

void rewind(File *f).

2.4.3 Функции чтения и записи потока байтов

Прототип функции fread():

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

Функция считывает count элементов длиной size байтов в область, заданную указателем buffer, из потока stream.

Функция возвращает количество прочитанных элементов, которое может быть меньше count, если при чтении произошла ошибка или встретился конец файла.

Прототип функции fwrite():

size_t fwrite (const void *p, size_t size, size_t, FILE *).

Функция записывает n элементов длиной size байтов из буфера, заданного указателем p, в поток f. Возвращает число записанных элементов [5].

2.4.4 Функции чтения символа из потока

Функция getс(), имеющая прототип:

int getc (FILE *f).

Функция возвращает очередной символ в формате int из потока f. Если символ не может быть прочитан, то возвращает значение EOF.

Функция fgetс(), имеющая прототип:

int fgetc (FILE *f).

Функция возвращает очередной символ в формате int из потока f. Если символ не может быть прочитан, то возвращает значение EOF.

Функция getchar(), имеющая прототип:

int getchar (void).

возвращает очередной символ в формате int из стандартного потока (stdin). Если символ не может быть прочитан, то возвращает значение EOF [3].

2.4.5 Функции записи символа в поток

Функция puts() записывает символ ch в поток f. При ошибке возвращает значение EOF. Ее прототип:

int putc (int ch, FILE *f).

Выполняется аналогично функция fputc(). Ее прототип:

int fputc (int ch, FILE *f).

Функция putchar()выводит символ ch на стандартное устройство вывода, добавляя в конце символ новой строки.

Функция возвращает неотрицательное значение при успехе или EOF - при ошибке [4].

2.4.6 Функции чтения строки из потока

Прототип функции fgets():

char *fgets (char *s, int n, FILE *f).

Функция читает не более n-1 байт из потока f в строку s, прекращая чтение при обнаружении символа новой строки или конца файла.

Символ новой строки при чтении не отбрасывается, помещается конец строки s. Прочитанная строка дополняется ограничителем строки ('\0'). При обнаружении ошибки или конца файла возвращает NULL, в противном случае - указатель на строку s.

Функция читает символы с клавиатуры до появления символа новой строки и помещает их в строку s. Сам символ новой строки в строку не включается. Возвращает указатель на s.

Прототип функции gets():

char *gets (char *s).

2.4.7 Функции записи строки в поток

Прототип функции fputs():

int fputs (const char * s, FILE *f).

Функция fputs() записывает строку символов s в поток f. Символ конца строки в файл не записывается.

При ошибке возвращает значение EOF, иначе - неотрицательное число.

Функция puts()выводит строку s на стандартное устройство вывода, добавляя в конце символ новой строки. Возвращает неотрицательное значение при успехе или EOF - при ошибке [4].

Прототип функции puts(): int puts (char *s).

2.4.8 Функции форматированного ввода из потока

Прототип функции fscanf():

int fscanf (FILE *f, const char *fmt [, par1, par2, …]).

Эта функция вводит (читает) строку параметров par1, par2, … в формате, определенном строкой fmt, из файла f. Функция возвращает число переменных, которым присвоено значение. Прототип функции scanf():

int scanf (const char *fmt [, par1, par2, …]).

Функция scanf() вводит (читает) строку параметров par1, par2, … в формате, определенном строкой fmt, со стандартного устройства ввода (обычно с клавиатуры (stdin)). Функция возвращает число переменных, которым присвоено значение. Прототип функции sscanf():

int sscanf (const char *buf, const char *fmt [, par1, par2, …]).

Функция sscanf() вводит данные аналогично функции scanf(), но не с клавиатуры, а из строки символов, переданной ей первым параметром.

Аргумент buf - строка символов, из которой вводятся значения, fmt - строка формата, в соответствии с которой происходит преобразование данных.

Многоточие указывает на наличие необязательных аргументов, соответствующих адресам вводимых значений [7].

2.4.9 Функции форматированного вывода в поток

Прототип функции fprintf():

int fprintf (FILE *f, const char *fmt, …).

Функция записывает в поток f переменные, список которых обозначен многоточием (…), в формате, указанном строкой fmt.

Функция возвращает число записанных значений.

Прототип функции printf():

int printf (const char *fmt, …).

Функция выводит на стандартное устройство вывода (stdout) значения переменных, перечисленных в списке, обозначенном многоточием (…), в формате, определенном строкой fmt.

Функция возвращает число выведенных значений.

Прототип функции sprintf():

int sprintf (char *buf, const char *fmt, …).

Функция выводит в строку значения переменных, перечисленных в списке, обозначенном многоточием (…), в формате, определенном строкой fmt.

Примечание. Спецификации формата fmt были рассмотрены в разделе "Консольный ввод-вывод" [6].

2.5 Функции обработки ошибок

Функции работы с потоками возвращают значения, которые рекомендуется анализировать в программе и обрабатывать ошибочные ситуации, возникающие, например, при открытии файлов или чтении из потока. При работе с файлами часто используют функции feof() и ferror().

Прототип функции feof():

int feof (FILE *f).

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

Прототип функции ferror():

int ferror (FILE *f).

Возвращает не равное нулю целое значение, означающее код ошибки, если обнаружена ошибка ввода/вывода; 0 - в противном случае.

3. Использование структур и файлов

3.1 Постановка задачи и описание структуры

В среде Borland Builder C++ разработать приложение, реализующее работу в своей предметной области, которая включает:

1) создание файла;

2) добавление записей в конец файла;

3) добавление записи по номеру;

4) вывод на экран всех записей в виде таблицы (использовать компонент StringGrid);

5) удаление записи по номеру;

6) осуществление поиска нужной информации по условию функций варианта. Результаты поиска выводить на экран в виде таблицы;

7) удаление файла;

8) копирование данных из файла в резервный файл;

9) восстановление файла из резервного файла.

Все действия со структурами оформить в виде отдельных функций с аргументами. Диалог с пользователем организовать в виде меню (использовать компонент MainMenu).

При реализации приложения использовать для описания атрибутов предметной области структуры. Сохранять информацию в текстовых файлах (использование функций fscanf(), fprintf()).

Предметная область «Товары в продуктовом магазине». Структура содержит следующие атрибуты:

1) название товара;

2) цена товара;

3) дата производства;

4) срок годности;

5) производитель;

6) количество единиц товара в магазине;

7) товарная группа: мясные, молочные, хлебобулочные, консервы, напитки, другое.

Основные функции:

- удалить все записи о просроченных товарах;

- изменить цену на товары заданной товарной группы;

- вывести сведения о товарах заданного производителя.

Структура имеет следующий вид:

struct tex

{

char naz[50];

char cen[10];

char dat[15];

char sro[15];

char pro[50];

char kol[5];

char tov[50];

} mas;

3.2 Визуальное приложение

После запуска приложения на экране появляется главное окно программы (рисунок 3.2.1).



Рисунок 3.2.1 - Главное окно программы

Для создания нового файла необходимо выбрать пункт «Файл - Создание файла» или нажать на кнопку «Создание файла» в главном окне программы.

Если файл успешно создан, то на экране появится соответствующее окно (рисунок 3.2.2).

Рисунок 3.2.2 - Успешное создание файла

Для добавления записей в конец файла необходимо выбрать пункт меню «Запись - Добавление записи в конец файла» или нажать кнопку «Добавить в конец», но предварительно необходимо ввести данными по всем полям записи (рисунки 3.2.3 - 3.2.4).



Рисунок 3.2.3 - Добавление записи

Рисунок 3.2.4 - Просмотр добавленной записи

Таким же образом, добавим еще несколько записей, которые будут использоваться для демонстрации работы программы.

Таблица с созданными записями представлена на рисунке 3.2.5.

Рисунок 3.2.5 - Просмотр добавленных записей

Для добавления записи по номеру необходимо выбрать пункт меню «Запись - Добавление записи по номеру» или нажать кнопку «Добавить по номеру», но предварительно заполнить все поля записи, а также указать номер записи для добавления.

В качестве примера добавим запись номер «2» (рисунок 3.2.6).



Рисунок 3.2.6 - Просмотр добавленной записи по номеру

Сохраним ранее введенные записи в резервный файл. Для этого необходимо выбрать пункт меню «Файл - Копирование данных из файла в резервный файл» или нажать кнопку «Сохранение файла», поле чего данные будут сохранены в резервный файл, и появится сообщение об успешном сохранении (рисунок 3.2.7).

Рисунок 3.2.7 - Успешное сохранение файла

Для удаления записи по номеру необходимо выбрать пункт меню «Запись - Удаление записи по номеру» или нажать на кнопку «Удалить по номеру», но предварительно нужно ввести номер для удаления. В качестве примера введем номер равный одному. Результат представлен на рисунке 3.2.8.

Рисунок 3.2.8 - Результат удаления записи по номеру

приложение информация визуальный

Выполним восстановление данных из резервного файла. Для этого необходимо выбрать пункт меню «Файл - Восстановление записей из резервного файла» или нажать на кнопку «Восстановление», поле данные будут занесены в основную таблицу программы (рисунки 3.2.9 - 3.2.10).

Рисунок 3.2.9 - Восстановление файла



Рисунок 3.2.10 - Записи после восстановления из резервного файла

Для удаления файла необходимо выбрать пункт меню «Файл - Удаление файла» или нажать на кнопку «Удаление файла», поле чего на экране появится окно с подтверждением об удалении. Если удаление файла подтверждено, то появится сообщение об успешном удалении файла (рисунок 3.2.11).

Рисунок 3.2.11 - Удаление файла

Для удаления всех записей с просроченным товаром необходимо выбрать пункт меню «Основные функции - Удалить все записи о просроченных товарах» или нажать на кнопку «Удалить по просроченные товары».

В результате получим таблицу, с удаленными записями (рисунок 3.2.12).

Рисунок 3.2.12 - Просмотр записей файла после удаления

Для того чтобы изменить цену по товарной группе необходимо выбрать пункт меню «Основные функции - Изменить цену на товары заданной группы» или нажать на кнопку «Заменить цену по группе», но предварительно нужно ввести товарную группу и новую цену.

Выполним восстановление данных из файла и затем введем товарную группу «Консервы»» и новую цену «8,50 (рисунок 3.2.13).