Ввод данных из файла и вывод в файл. Работа с текстовыми файлами в C
– сравнение для выявления равенства либо неравенства.
Практическое назначение перечисления – определение множества различающихся символических констант целого типа.
Пример использования переменных перечислимого типа:
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 дней (дня).
18. Файлы в языке Си
Файл – это набор данных, размещенный на внешнем носителе и рассматриваемый в процессе обработки как единое целое. В файлах размещаются данные, предназначенные для длительного хранения.
Различают два вида файлов: текстовые и бинарные. Текстовые файлы представляют собой последовательность ASCII символов и могут быть просмотрены и отредактированы с помощью любого текстового редактора.
Бинарные (двоичные) файлы представляют собой последовательность данных, структура которых определяется программно.
В языке Си имеется большой набор функций для работы с файлами, большинство которых находятся в библиотеках stdio.h иio.h .
18.1. Открытие файла
Каждому файлу присваивается внутреннее логическое имя, используемое в дальнейшем при обращении к нему. Логическое имя (идентификатор файла) – это
указатель на файл, т.е. на область памяти, где содержится вся необходимая информация о файле. Формат объявления указателя на файл следующий:
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");
18.2. Закрытие файла
После работы с файлом доступ к нему необходимо закрыть. Это выполняет функция int fclose (указатель файла ). Например, из предыдущего примера файл закрывается так: fclose (f);
Для закрытия нескольких файлов введена функция, объявленная следующим образом: void fcloseall (void );
Если требуется изменить режим доступа к файлу, то для этого сначала необходимо закрыть данный файл, а затем вновь его открыть, но с другими правами доступа. Для этого используют стандартную функцию:
FILE* freopen (char*имя_файла , char *режим , FILE *указатель_файла );
Эта функция сначала закрывает файл, объявленный указателем_файла (как это делает функцияfopen ), а затем открывает файл сименем_файла и правами доступа «режим ».
В языке Си имеется возможность работы с временными файлами, которые нужны только в процессе работы программы. В этом случае используется функция
FILE* tmpfile (void);
которая создает на диске временный файл с правами доступа «w+b», после завершения работы программы или после закрытия временного файла он автоматически удаляется.
18.3. Запись – чтение информации
Все действия по чтению-записи данных в файл можно разделить на три группы: операции посимвольного ввода-вывода; операции построчного вводавывода; операции ввода-вывода по блокам.
Рассмотрим основные функции, применяемые в каждой из указанных трех групп операций.
Посимвольный ввод-вывод
В функциях посимвольного ввода-вывода происходит прием одного символа из файла или передача одного символа в файл:
Построчный ввод-вывод
В функциях построчного ввода-вывода происходит перенос из файла или в
Блоковый ввод-вывод
В функциях блокового ввода-вывода работа происходит с целыми блоками
информации: | |
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. |
Форматированный ввод-вывод производится функциями.
Теги: Текстовые файлы, fopen, fclose, feof, setbuf, setvbuf, fflush, fgetc, fprintf, fscanf, fgets, буферизированный поток, небуферизированный поток.
Работа с текстовыми файлами
Р абота с текстовым файлом похожа работу с консолью: с помощью функций форматированного ввода мы сохраняем данные в файл, с помощью функций форматированного вывода считываем данные из файла. Есть множество нюансов, которые мы позже рассмотрим. Основные операции, которые необходимо проделать, это
- 1. Открыть файл, для того, чтобы к нему можно было обращаться. Соответственно, открывать можно для чтения, записи, чтения и записи, переписывания или записи в конец файла и т.п. Когда вы открываете файл, может также произойти куча ошибок – файла может не существовать, это может быть файл не того типа, у вас может не быть прав на работу с файлом и т.д. Всё это необходимо учитывать.
- 2. Непосредственно работа с файлом - запись и чтение. Здесь также нужно помнить, что мы работаем не с памятью с произвольным доступом, а с буферизированным потоком, что добавляет свою специфику.
- 3. Закрыть файл. Так как файл является внешним по отношению к программе ресурсом, то если его не закрыть, то он продолжит висеть в памяти, возможно, даже после закрытия программы (например, нельзя будет удалить открытый файл или внести изменения и т.п.). Кроме того, иногда необходимо не закрывать, а "переоткрывать" файл для того, чтобы, например, изменить режим доступа.
Кроме того, существует ряд задач, когда нам не нужно обращаться к содержимому файла: переименование, перемещение, копирование и т.д. К сожалению, в стандарте си нет описания функций для этих нужд. Они, безусловно, имеются для каждой из реализаций компилятора. Считывание содержимого каталога (папки, директории) – это тоже обращение к файлу, потому что папка сама по себе является файлом с метаинформацией.
Иногда необходимо выполнять некоторые вспомогательные операции: переместиться в нужное место файла, запомнить текущее положение, определить длину файла и т.д.
Для работы с файлом необходим объект FILE. Этот объект хранит идентификатор файлового потока и информацию, которая нужна, чтобы им управлять, включая указатель на его буфер, индикатор позиции в файле и индикаторы состояния.
Объект FILE сам по себе является структурой, но к его полям не должно быть доступа. Переносимая программа должна работать с файлом как с абстрактным объектом, позволяющим получить доступ до файлового потока.
Создание и выделение памяти под объект типа FILE осуществляется с помощью функции fopen или tmpfile (есть и другие, но мы остановимся только на этих).
Функция fopen открывает файл. Она получает два аргумента – строку с адресом файла и строку с режимом доступа к файлу. Имя файла может быть как абсолютным, так и относительным. fopen возвращает указатель на объект FILE, с помощью которого далее можно осуществлять доступ к файлу.
FILE* fopen(const char* filename, const char* mode);
Например, откроем файл и запишем в него Hello World
#include
Функция fopen сама выделяет память под объект, очистка проводится функцией fclose. Закрывать файл обязательно, самостоятельно он не закроется.
Функция fopen может открывать файл в текстовом или бинарном режиме. По умолчанию используется текстовый. Режим доступа может быть следующим
Тип | Описание |
---|---|
r | Чтение. Файл должен существовать. |
w | Запись нового файла. Если файл с таким именем уже существует, то его содержимое будет потеряно. |
a | Запись в конец файла. Операции позиционирования (fseek, fsetpos, frewind) игнорируются. Файл создаётся, если не существовал. |
r+ | Чтение и обновление. Можно как читать, так и писать. Файл должен существовать. |
w+ | Запись и обновление. Создаётся новый файл. Если файл с таким именем уже существует, то его содержимое будет потеряно. Можно как писать, так и читать. |
a+ | Запись в конец и обновление. Операции позиционирования работают только для чтения, для записи игнорируются. Если файл не существовал, то будет создан новый. |
Если необходимо открыть файл в бинарном режиме, то в конец строки добавляется буква b, например “rb”, “wb”, “ab”, или, для смешанного режима “ab+”, “wb+”, “ab+”. Вместо b можно добавлять букву t, тогда файл будет открываться в текстовом режиме. Это зависит от реализации. В новом стандарте си (2011) буква x означает, что функция fopen должна завершиться с ошибкой, если файл уже существует. Дополним нашу старую программу: заново откроем файл и считаем, что мы туда записали.
#include
Вместо функции fgets можно было использовать fscanf, но нужно помнить, что она может считать строку только до первого пробела.
fscanf(file, "%127s", buffer);
Также, вместо того, чтобы открывать и закрывать файл можно воспользоваться функцией freopen, которая «переоткрывает» файл с новыми правами доступа.
#include
Функции fprintf и fscanf отличаются от printf и scanf только тем, что принимают в качестве первого аргумента указатель на FILE, в который они будут выводить или из которого они будут читать данные. Здесь стоит сразу же добавить, что функции printf и scanf могут быть без проблем заменены функциями fprintf и fscanf. В ОС (мы рассматриваем самые распространённые и адекватные операционные системы) существует три стандартных потока: стандартный поток вывода stdout, стандартный поток ввода stdin и стандартный поток вывода ошибок stderr. Они автоматически открываются во время запуска приложения и связаны с консолью. Пример
#include
Ошибка открытия файла
Если вызов функции fopen прошёл неудачно, то она возвратит NULL. Ошибки во время работы с файлами встречаются достаточно часто, поэтому каждый раз, когда мы окрываем файл, необходимо проверять результат работы
#include
Проблему вызывает случай, когда открывается сразу несколько файлов: если один из них нельзя открыть, то остальные также должны быть закрыты
FILE *inputFile, *outputFile; unsigned m, n; unsigned i, j; inputFile = fopen(INPUT_FILE, READ_ONLY); if (inputFile == NULL) { printf("Error opening file %s", INPUT_FILE); getch(); exit(3); } outputFile = fopen(OUTPUT_FILE, WRITE_ONLY); if (outputFile == NULL) { printf("Error opening file %s", OUTPUT_FILE); getch(); if (inputFile != NULL) { fclose(inputFile); } exit(4); } ...
В простых случаях можно действовать влоб, как в предыдущем куске кода. В более сложных случаях используются методы, подменяющиее RAII из С++: обёртки, или особенности компилятора (cleanup в GCC) и т.п.
Буферизация данных
Как уже говорилось ранее, когда мы выводим данные, они сначала помещаются в буфер. Очистка буфера осуществляется
- 1) Если он заполнен
- 2) Если поток закрывается
- 3) Если мы явно указываем, что необходимо очистить буфер (здесь тоже есть исключения:)).
- 4) Также очищается, если программа завершилась удачно. Вместе с этим закрываются и все файлы. В случае ошибки выполнения этого может не произойти.
Форсировать выгрузку буфера можно с помощью вызова функции fflush(File *). Рассмотрим два примера – с очисткой и без.
#include
Раскомментируйте вызов fflush. Во время выполнения откройте текстовый файл и посмотрите на поведение.
Буфер файла можно назначить самостоятельно, задав свой размер. Делается это при помощи функции
Void setbuf (FILE * stream, char * buffer);
которая принимает уже открытый FILE и указатель на новый буфер. Размер нового буфера должен быть не меньше чем BUFSIZ (к примеру, на текущей рабочей станции BUFSIZ равен 512 байт). Если передать в качестве буфера NULL, то поток станет небуферизированным. Можно также воспользоваться функцией
Int setvbuf (FILE * stream, char * buffer, int mode, size_t size);
которая принимает буфер произвольного размера size. Режим mode может принимать следующие значения
- _IOFBF - полная буферизация. Данные записываются в файл, когда он заполняется. На считывание, буфер считается заполненным, когда запрашивается операция ввода и буфер пуст.
- _IOLBF - линейная буферизация. Данные записываются в файл когда он заполняется, либо когда встречается символ новой строки. На считывание, буфер заполняется до символа новой строки, когда запрашивается операция ввода и буфер пуст.
- _IONBF – без буферизации. В этом случае параметры size и buffer игнорируются.
Пример: зададим свой буфер и посмотрим, как осуществляется чтение из файла. Пусть файл короткий (что-нибудь, типа Hello, World!), и считываем мы его посимвольно
#include
Видно, что данные уже находятся в буфере. Считывание посимвольно производится уже из буфера.
feof
Функция int feof (FILE * stream); возвращает истину, если конец файла достигнут. Функцию удобно использовать, когда необходимо пройти весь файл от начала до конца. Пусть есть файл с текстовым содержимым text.txt. Считаем посимвольно файл и выведем на экран.
#include
Всё бы ничего, только функция feof работает неправильно... Это связано с тем, что понятие "конец файла" не определено. При использовании feof часто возникает ошибка, когда последние считанные данные выводятся два раза. Это связано с тем, что данные записывается в буфер ввода, последнее считывание происходит с ошибкой и функция возвращает старое считанное значение.
#include
Этот пример сработает с ошибкой (скорее всего) и выведет последний символ файла два раза.
Решение – не использовать feof. Например, хранить общее количество записей или использовать тот факт, что функции fscanf и пр. обычно возвращают число верно считанных и сопоставленных значений.
#include
Примеры
1. В одном файле записаны два числа - размерности массива. Заполним второй файл массивом случайных чисел.
#include
2. Пользователь копирует файл, при этом сначала выбирает режим работы: файл может выводиться как на консоль, так и копироваться в новый файл.
#include
3. Пользователь вводит данные с консоли и они записываются в файл до тех пор, пока не будет нажата клавиша esc. Проверьте программу и посмотрите. как она себя ведёт в случае, если вы вводите backspace: что выводится в файл и что выводится на консоль.
#include
4. В файле записаны целые числа. Найти максимальное из них. Воспользуемся тем, что функция fscanf возвращает число верно прочитанных и сопоставленных объектов. Каждый раз должно возвращаться число 1.
#include
Другое решение считывать числа, пока не дойдём до конца файла.
#include
5. В файле записаны слова: русское слово, табуляция, английское слово, в несколько рядов. Пользователь вводит английское слово, необходимо вывести русское.
Файл с переводом выглядит примерно так
Солнце sun
карандаш pen
шариковая ручка pencil
дверь door
окно windows
стул chair
кресло armchair
и сохранён в кодировке cp866 (OEM 866). При этом важно: последняя пара cлов также заканчивается переводом строки.
Алгоритм следующий - считываем строку из файла, находим в строке знак табуляции, подменяем знак табуляции нулём, копируем русское слово из буфера, копируем английское слово из буфера, проверяем на равенство.
#include
6. Подсчитать количество строк в файле. Будем считывать файл посимвольно, считая количество символов "\n" до тех пор, пока не встретим символ EOF. EOF - это спецсимвол,
который указывает на то, что ввод закончен и больше нет данных для чтения. Функция возвращает отрицательное значение в случае ошибки.
ЗАМЕЧАНИЕ: EOF имеет тип int, поэтому нужно использовать int для считывания символов. Кроме того, значение EOF не определено стандартом.
#define _CRT_SECURE_NO_WARNINGS
#include
Ru-Cyrl 18- tutorial Sypachev S.S. 1989-04-14 [email protected] Stepan Sypachev students
Всё ещё не понятно? – пиши вопросы на ящик
Последнее обновление: 31.10.2015
Класс FileStream представляет возможности по считыванию из файла и записи в файл. Он позволяет работать как с текстовыми файлами, так и с бинарными.
Рассмотрим наиболее важные его свойства и методы:
array - массив байтов, куда будут помещены считываемые из файла данные
offset представляет смещение в байтах в массиве array, в который считанные байты будут помещены
count - максимальное число байтов, предназначенных для чтения. Если в файле находится меньшее количество байтов, то все они будут считаны.
array - массив байтов, откуда данные будут записываться в файла
offset - смещение в байтах в массиве array, откуда начинается запись байтов в поток
count - максимальное число байтов, предназначенных для записи
Свойство Length : возвращает длину потока в байтах
Свойство Position : возвращает текущую позицию в потоке
Метод Read : считывает данные из файла в массив байтов. Принимает три параметра: int Read(byte array, int offset, int count) и возвращает количество успешно считанных байтов. Здесь используются следующие параметры:
Метод long Seek(long offset, SeekOrigin origin) : устанавливает позицию в потоке со смещением на количество байт, указанных в параметре offset.
Метод Write : записывает в файл данные из массива байтов. Принимает три параметра: Write(byte array, int offset, int count)
FileStream представляет доступ к файлам на уровне байтов, поэтому, например, если вам надо считать или записать одну или несколько строк в текстовый файл, то массив байтов надо преобразовать в строки, используя специальные методы. Поэтому для работы с текстовыми файлами применяются другие классы.
В то же время при работе с различными бинарными файлами, имеющими определенную структуру FileStream может быть очень даже полезен для извлечения определенных порций информации и ее обработки.
Посмотрим на примере считывания-записи в текстовый файл:
Console.WriteLine("Введите строку для записи в файл:"); string text = Console.ReadLine(); // запись в файл using (FileStream fstream = new FileStream(@"C:\SomeDir\noname\note.txt", FileMode.OpenOrCreate)) { // преобразуем строку в байты byte array = System.Text.Encoding.Default.GetBytes(text); // запись массива байтов в файл fstream.Write(array, 0, array.Length); Console.WriteLine("Текст записан в файл"); } // чтение из файла using (FileStream fstream = File.OpenRead(@"C:\SomeDir\noname\note.txt")) { // преобразуем строку в байты byte array = new byte; // считываем данные fstream.Read(array, 0, array.Length); // декодируем байты в строку string textFromFile = System.Text.Encoding.Default.GetString(array); Console.WriteLine("Текст из файла: {0}", textFromFile); } Console.ReadLine();
Разберем этот пример. И при чтении, и при записи используется оператор using . Не надо путать данный оператор с директивой using, которая подключает пространства имен в начале файла кода. Оператор using позволяет создавать объект в блоке кода, по завершению которого вызывается метод Dispose у этого объекта, и, таким образом, объект уничтожается. В данном случае в качестве такого объекта служит переменная fstream .
Объект fstream создается двумя разными способами: через конструктор и через один из статических методов класса File.
Здесь в конструктор передается два параметра: путь к файлу и перечисление FileMode . Данное перечисление указывает на режим доступа к файлу и может принимать следующие значения:
Append : если файл существует, то текст добавляется в конец файл. Если файла нет, то он создается. Файл открывается только для записи.
Create : создается новый файл. Если такой файл уже существует, то он перезаписывается
CreateNew : создается новый файл. Если такой файл уже существует, то он приложение выбрасывает ошибку
Open : открывает файл. Если файл не существует, выбрасывается исключение
OpenOrCreate : если файл существует, он открывается, если нет - создается новый
Truncate : если файл существует, то он перезаписывается. Файл открывается только для записи.
Статический метод OpenRead класса File открывает файл для чтения и возвращает объект FileStream.
Конструктор класса FileStream также имеет ряд перегруженных версий, позволяющий более точно настроить создаваемый объект. Все эти версии можно посмотреть на msdn.
И при записи, и при чтении применяется объект кодировки Encoding.Default из пространства имен System.Text . В данном случае мы используем два его метода: GetBytes для получения массива байтов из строки и GetString для получения строки из массива байтов.
В итоге введенная нами строка записывается в файл note.txt . По сути это бинарный файл (не текстовый), хотя если мы в него запишем только строку, то сможем посмотреть в удобочитаемом виде этот файл, открыв его в текстовом редакторе. Однако если мы в него запишем случайные байты, например:
Fstream.WriteByte(13); fstream.WriteByte(103);
То у нас могут возникнуть проблемы с его пониманием. Поэтому для работы непосредственно с текстовыми файлами предназначены отдельные классы - StreamReader и StreamWriter.
Произвольный доступ к файлам
Нередко бинарные файлы представляют определенную стрктуру. И, зная эту структуру, мы можем взять из файла нужную порцию информации или наоброт записать в определенном месте файла определенный набор байтов. Например, в wav-файлах непосредственно звуковые данные начинаются с 44 байта, а до 44 байта идут различные метаданные - количество каналов аудио, частота дискретизации и т.д.
С помощью метода Seek() мы можем управлять положением курсора потока, начиная с которого производится считывание или запись в файл. Этот метод принимает два параметра: offset (смещение) и позиция в файле. Позиция в файле описывается тремя значениями:
SeekOrigin.Begin : начало файла
SeekOrigin.End : конец файла
SeekOrigin.Current : текущая позиция в файле
Курсор потока, с которого начинается чтение или запись, смещается вперед на значение offset относительно позиции, указанной в качестве второго параметра. Смещение может отрицательным, тогда курсор сдвигается назад, если положительное - то вперед.
Рассмотрим на примере:
Using System.IO; using System.Text; class Program { static void Main(string args) { string text = "hello world"; // запись в файл using (FileStream fstream = new FileStream(@"D:\note.dat", FileMode.OpenOrCreate)) { // преобразуем строку в байты byte input = Encoding.Default.GetBytes(text); // запись массива байтов в файл fstream.Write(input, 0, input.Length); Console.WriteLine("Текст записан в файл"); // перемещаем указатель в конец файла, до конца файла- пять байт fstream.Seek(-5, SeekOrigin.End); // минус 5 символов с конца потока // считываем четыре символов с текущей позиции byte output = new byte; fstream.Read(output, 0, output.Length); // декодируем байты в строку string textFromFile = Encoding.Default.GetString(output); Console.WriteLine("Текст из файла: {0}", textFromFile); // worl // заменим в файле слово world на слово house string replaceText = "house"; fstream.Seek(-5, SeekOrigin.End); // минус 5 символов с конца потока input = Encoding.Default.GetBytes(replaceText); fstream.Write(input, 0, input.Length); // считываем весь файл // возвращаем указатель в начало файла fstream.Seek(0, SeekOrigin.Begin); output = new byte; fstream.Read(output, 0, output.Length); // декодируем байты в строку textFromFile = Encoding.Default.GetString(output); Console.WriteLine("Текст из файла: {0}", textFromFile); // hello house } Console.Read(); } }
Консольный вывод:
Текст записан в файл Текст из файл: worl Текст из файла: hello house
Вызов fstream.Seek(-5, SeekOrigin.End) перемещает курсор потока в конец файлов назад на пять символов:
То есть после записи в новый файл строки "hello world" курсор будет стоять на позиции символа "w".
После этого считываем четыре байта начиная с символа "w". В данной кодировке 1 символ будет представлять 1 байт. Поэтому чтение 4 байтов будет эквивалентно чтению четырех сиволов: "worl".
Затем опять же перемещаемся в конец файла, не доходя до конца пять символов (то есть опять же с позиции символа "w"), и осуществляем запись строки "house". Таким образом, строка "house" заменяет строку "world".
Закрытие потока
В примерах выше дл закрытия потока применяется конструкция using . После того как все операторы и выражения в блоке using отработают, объект FileStream уничтожается. Однако мы можем выбрать и другой способ:
FileStream fstream = null; try { fstream = new FileStream(@"D:\note3.dat", FileMode.OpenOrCreate); // операции с потоком } catch(Exception ex) { } finally { if (fstream != null) fstream.Close(); }
Если мы не используем конструкцию using, то нам надо явным образом вызвать метод Close() : fstream.Close()
Для программиста открытый файл представляется как последовательность считываемых или записываемых данных. При открытии файла с ним связывается поток ввода-вывода . Выводимая информация записывается в поток, вводимая информация считывается из потока.
Когда поток открывается для ввода-вывода, он связывается со стандартной структурой типа 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.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 на экран
//увеличение количества считанных чисел
//закрытие потока
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<
// закрываем файл
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");