Механизм ввода-вывода, разработанный , не соответствует общепринятому сегодня стилю объектно-ориентированного программирования, кроме того, он активно использует операции с указателями, считающиеся потенциально небезопасными в современных защищённых средах выполнения кода. Альтернативой при разработке прикладных приложений является механизм стандартных классов ввода-вывода, предоставляемый стандартом языка C++.

Открытие файлов

Наиболее часто применяются классы ifstream для чтения, ofstream для записи и fstream для модификации файлов.

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

Enum open_mode { app, binary, in, out, trunc, ate };

Ниже приведены возможные значения флагов и их назначение.

Например, чтобы открыть файл с именем test.txt для чтения данных в бинарном виде, следует написать:

Ifstream file; file.open ("test.txt", ios::in | ios::binary);

Оператор логического ИЛИ (|) позволяет составить режим с любым сочетанием флагов. Так, чтобы, открывая файл по записи, случайно не затереть существующий файл с тем же именем, надо использовать следующую форму:

Ofstream file; file.open ("test.txt", ios::out | ios::app);

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

#include

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

If (!file) { //Обработка ошибки открытия файла }

Операторы включения и извлечения

Переопределённый в классах работы с файлами оператор включения (<<) записывает данные в файловый поток. Как только вы открыли файл для записи, можно записывать в него текстовую строку целиком:

File << "Это строка текста";

Можно также записывать текстовую строку по частям:

File << "Это " << "строка " << "текста";

Оператор endl завершает ввод строки символом "возврат каретки":

File << "Это строка текста" << endl;

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

Ofstream file ("Temp.txt"); char buff = "Текстовый массив содержит переменные"; int vx = 100; float pi = 3.14159; file << buff << endl << vx << endl << pi << endl;

В результате выполнения кода образуется три строки текстового файла Temp.txt:

Текстовый массив содержит переменные 100 3.14159

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

Оператор извлечения (>>)производит обратные действия. Казалось бы, чтобы извлечь символы из файла Temp.txt , записанного ранее, нужно написать код наподобие следующего:

Ifstream file ("Temp.txt"); char buff; int vx; float pi; file >> buff >> vx >> pi;

Однако оператор извлечения остановится на первом попавшемся разделителе (символе пробела, табуляции или новой строки). Таким образом, при разборе предложения "Текстовый массив содержит переменные" только слово "Текстовый" запишется в массив buff , пробел игнорируется, а слово "массив" станет значением целой переменной vx и исполнение кода "пойдет вразнос" с неминуемым нарушением структуры данных. Далее, при обсуждении класса ifstream , будет показано, как правильно организовать чтение файла из предыдущего примера.

Класс ifstream: чтение файлов

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

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

Ifstream file("Temp.txt"); char buff; int vx; float pi; file.getline(buff, sizeof(buff)); file >> vx >> pi:

Метод getline прочитает первую строку файла до конца, а оператор >> присвоит значения переменным.

Следующий пример показывает добавление данных в текстовый файл с последующим чтением всего файла. Цикл while (1) используется вместо while(!file2.eof()) по причинам, которые обсуждались в .

#include #include using namespace std; int main() { ofstream file; file.open("test.txt",ios::out|ios::app); if (!file) { cout << "File error - can"t open to write data!"; cin.sync(); cin.get(); return 1; } for (int i=0; i<10; i++) file << i << endl; file.close(); ifstream file2; file2.open("test.txt", ios::in); if (!file2) { cout << "File error - can"t open to read data!"; cin.sync(); cin.get(); return 2; } int a,k=0; while (1) { file2 >> a; if (file2.eof()) break; cout << a << " "; k++; } cout << endl << "K=" << k << endl; file2.close(); cin.sync(); cin.get(); return 0; }

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

#include #include using namespace std; int main() { ifstream file; // создать поточный объект file file.open("test.txt"); // открыть файл на чтение if (!file) return 1; // возврат по ошибке отрытия char str; // статический буфер строки // Считывать и отображать строки в цикле, пока не eof while (!file.getline(str, sizeof(str)).eof()) cout << str << endl; // вывод прочитанной строки на экран cin.sync(); cin.get(); return 0; }

Этот код под ОС Windows также зависит от наличия в последней строке файла символа перевода строки, надежнее было бы сделать так:

While (1) { if (file.eof()) break; file.getline(str, sizeof(str)); cout << str << endl; }

Явные вызовы методов open и close не обязательны. Действительно, вызов конструктора с аргументом позволяет сразу же, в момент создания поточного объекта file , открыть файл:

Ifstream file("test.txt");

Вместо метода close можно использовать оператор delete , который автоматически вызовет деструктор объекта file и закроет файл. Код цикла while обеспечивает надлежащую проверку признака конца файла.

Класс ofstream: запись файлов

Класс ofstream предназначен для вывода данных из файлового потока. Далее перечислены основные методы данного класса.

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

Ofstream file ("temp.txt"); if (!file) return; for (int i=1; i<=3; i++) file << "Строка " << i << endl; file.close();

Бинарные файлы

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

Первый параметр методов write и read (адрес блока записи/чтения) должен иметь тип символьного указателя char * , поэтому необходимо произвести явное преобразование типа адреса структуры void * . Второй параметр указывает, что бинарные блоки файла имеют постоянный размер байтов независимо от фактической длины записи. Следующее приложение дает пример создания и отображения данных простейшей записной книжки. Затем записи файла последовательно считываются и отображаются на консоли.

#include #include #include using namespace std; struct Notes { // структура данных записной книжки char Name; // Ф.И.О. char Phone; // телефон int Age; // возраст }; int main() { setlocale(LC_ALL, "Russian"); Notes Note1= { "Грозный Иоанн Васильевич", "не установлен", 60 }; Notes Note2= { "Годунов Борис Федорович ", "095-111-2233 ", 30 }; Notes Note3= { "Романов Петр Михайлович ", "812-333-2211 ", 20 }; ofstream ofile("Notebook.dat", ios::binary); ofile.write((char*)&Note1, sizeof(Notes)); // 1-й блок ofile.write((char*)&Note2, sizeof(Notes)); // 2-й блок ofile.write((char*)&Note3, sizeof(Notes)); // 3-й блок ofile.close(); // закрыть записанный файл ifstream ifile("Notebook.dat", ios::binary); Notes Note; // структурированная переменная char str; // статический буфер строки // Считывать и отображать строки в цикле, пока не eof while (!ifile.read((char*)&Note, sizeof(Notes)).eof()) { sprintf(str, "%s\tТел: %s\tВозраст: %d", Note.Name, Note.Phone, Note.Age); cout << str << endl; } ifile.close(); // закрыть прочитанный файл cin.sync(); cin.get(); return 0; }

В результате выполнения этого кода образуется бинарный файл Notebook.dat из трех блоков размером по 80 байт каждый (при условии, что символы - однобайтовые). Естественно, вы можете использовать другие поточные методы и проделывать любые операции над полями определенной структуры данных.

Класс fstream: произвольный доступ к файлу

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

Ifstream ifile("Notebook.dat", ios::binary); int pos = 49 * sizeof(Notes); ifile.seekg(pos); // поиск 50-й записи Notes Note; //Notes – описанная выше структура "запись" ifile.read((char*)&Note, sizeof(Notes));

Подобные операции поиска эффективны, если файл состоит из записей известного и постоянного размера. Чтобы заменить содержимое произвольной записи, надо открыть поток вывода в режиме модификации:

Ofstream ofilе ("Notebook.dat", ios::binary | ios::ate); int pos = 49 * sizeof(Notes); ofile seekp(pos); // поиск 50-й записи Notes Note50 = {"Ельцин Борис Николаевич", "095-222-3322", 64}; ofile.write((char*)&Note, sizeof(Notes)); // замена

Если не указать флаг ios::ate (или ios::app), то при открытии бинарного файла Notebook.dat его предыдущее содержимое будет стерто!

Наконец, можно открыть файл одновременно для чтения/записи, используя методы, унаследованные поточным классом fstream от своих предшественников. Поскольку класс fstream произведен от istream и ostream (родителей ifstream и ofstream соответственно), все упомянутые ранее методы становятся доступными в приложении.

В следующем примере показана перестановка первой и третьей записей файла Notebook.dat .

#include #include #include using namespace std; struct Notes { char Name; char Phone; int Age; }; int main() { setlocale(LC_ALL, "Russian"); Notes Note1, Note3; // Открыть файл на чтение/запись одновременно fstream file("Notebook.dat", ios::binary | ios::in | ios::out); file.seekg(2 * sizeof(Notes)); // найти и считать Note3 file.read((char*)&Note3, sizeof(Notes)); file.seekg(0); // найти и считать Note1 file.read((char*)&Note1, sizeof(Notes)); file.seekg(0); // Note1 <== Note3 file.write((char*)&Note3, sizeof(Notes)); file.seekg(2 * sizeof(Notes)); // Note3 <== Note1 file.write((char*)&Note1, sizeof(Notes)); char str; // Считывать и отображать записи в цикле, пока не eof file.seekg(0); // вернуться к началу файла while (!file.read((char*)&Note1, sizeof(Notes)).eof()) { sprintf(str, "%s\tТел: %s\tВозраст: %d", Note1.Name, Note1.Phone, Note1.Age); cout << str << endl; } file.close(); cin.sync(); cin.get(); return 0; }

В конструкторе объекта file надо указать флаги ios::in и ios::out , разрешая одновременное выполнение операций чтения и записи. В результате выполнения этого кода первая и третья записи бинарного файла Notebook.dat поменяются местами.

Дополнительные примеры по теме есть .

Текстовые файлы

Рассмотрим работу с текстовым файлом в Си на примере. Создайте на диске С текстовый файл с именем TextFile.txt. Наберите в этом файле такие строки:

String_1 123 String_11, 456
String_2
String_3

Сохраните файл.

А это код программы на C, которая открывает наш файл и считывает из него строки:

/* *Author: @author Subbotin B.P..h> #include #define LEN 50 int main(void) { puts("Text file operations"); char cArray; FILE *pTextFile = fopen("C:\\TextFile.txt", "r"); if(pTextFile == NULL) { puts("Problems"); return EXIT_FAILURE; } while(fgets(cArray, LEN, pTextFile) != NULL) { printf("%s", cArray); } fclose(pTextFile); return EXIT_SUCCESS; }

Чтоб открыть текстовый файл в C используем функцию fopen:

FILE *pTextFile = fopen("C:\\TextFile.txt", "r");

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

Строки считываем с помощью функции fgets:

fgets(cArray, LEN, pTextFile);

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

После завершения работы с файлом, его надо закрыть:

fclose(pTextFile);

Получаем:

Русские буквы в строках тоже проходят.

Кстати, эту программу я сделал в Eclipse. Как работать с C/C++ в Eclipse можно посмотреть .

Итак, мы открыли и считали данные из текстового файла.

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

/* Author: @author Subbotin B.P..h> #include int main(void) { FILE *pTextFile = fopen("C:\\TextFileW.txt", "w"); char *cString = "This is a string"; char cNewLine = "\n"; int nVal = 123; if(pTextFile == NULL) { puts("Problems"); return EXIT_FAILURE; } fprintf(pTextFile, "%s%c", cString, cNewLine); fprintf(pTextFile, "%d", nVal); return EXIT_SUCCESS; }

Создаем текстовый файл для записи в него данных:

FILE *pTextFile = fopen("C:\\TextFileW.txt", "w");

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

C-строка cString, и число nVal записываются программой в текстовый файл. cNewLine - это просто переход на новую строку.

Записываем данные в текстовый файл с помощью функции fprintf:

fprintf(pTextFile, "%s%c", cString, cNewLine);

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

Работа с текстовыми файлами в C++.

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

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

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

Для работы с файлами используются специальные типы данных , называемые потоками . Поток ifstream служит для работы с файлами в режиме чтения, а ofstream в режиме записи. Для работы с файлами в режиме как записи, так и чтения служит поток fstream .

В программах на C++ при работе с текстовыми файлами необходимо подключать библиотеки iostream и fstream.

Для того чтобы записывать данные в текстовый файл, необходимо:

описать переменную типа ofstream.

вывести информацию в файл.

обязательно закрыть файл.

Для считывания данных из текстового файла, необходимо:

описать переменную типа ifstream.

открыть файл с помощью функции open.

закрыть файл.

Запись информации в текстовый файл

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

Будет создана переменная F для записи информации в файл.

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

F.open(«file», mode);

Здесь F - переменная, описанная как ofstream,

file - полное имя файла на диске,

mode - режим работы с открываемым файлом.

Обратите внимание на то, что при указании полного имени файла нужно ставить двойной слеш. Например, полное имя файла noobs.txt, находящегося в папке game на диске D:, нужно будет записать так:

D:\\game\\noobs.txt.

Файл может быть открыт в одном из следующих режимов:

ios::in - открыть файл в режиме чтения данных, этот режим является режимом по умолчанию для потоков ifstream;

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

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

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

ios::trunc - очистить файл, это же происходит в режиме ios::out;

ios::nocreate - не выполнять операцию открытия файла, если он не существует;

ios::noreplace - не открывать существующий файл.

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

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

Открыть файл (в качестве примера возьмем файл D:\\game\\noobs.txt) в режиме записи можно одним из следующих способов:

// первый способ

ofstream F;

F.open("D:\\game\\noobs.txt", ios::out);

//второй способ, режим ios::out является режимом по умолчанию

// для потока ofstream

ofstream F;

//третий способ объединяет описание переменной и типа поток

//и открытие файла в одном операторе

ofstream F ("D:\\game\\noobs.txt", ios::out);

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

Если вы хотите открыть существующий файл в режиме до записи, то в качестве режима следует использовать значение ios::app.

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

Например, для записи в поток F переменной a, оператор вывода будет иметь вид:

Для последовательного вывода в поток G переменных b, c, d оператор вывода станет таким:

G<

Закрытие потока осуществляется с помощью оператора:

ПРИМЕР:

Создать текстовый файл D:\\game\\noobs.txt и записать в него n вещественных чисел.

#include "stdafx.h"

#include

#include

#include

using namespace std;

int main()

setlocale (LC_ALL, "RUS");

int i, n;

double a;

//описывает поток для записи данных в файл

ofstream f ;

//открываем файл в режиме записи,

//режим ios :: out устанавливается по умолчанию

f.open("D:\\game\\noobs.txt", ios::out);

//вводим количество вещественных чисел

cout <<" n ="; cin >> n ;

//цикл для ввода вещественных чисел

//и записи их в файл

for (i=0; i

cout<<"a=";

//ввод числа

cin>>a;

f<

//закрытие потока

f.close();

system("pause");

return 0;

_______________________________________________________________

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

F.open("D:\\game\\noobs.txt", ios::in);

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

Например, для чтения из потока F в переменную a, оператор ввода будет выглядеть так:

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

Здесь F - имя потока функция возвращает логическое значение: true или false, в зависимости от того достигнут ли конец файла. Следовательно, цикл для чтения содержимого всего файла можно записать так:

//организуем для чтения значений из файла, выполнение

//цикла прервется, когда достигнем конец файла,

//в этом случае F.eof() вернет истину

while (!F.eof())

ПРИМЕР:

В текстовом файле D:\\game\\noobs.txt хранятся вещественные числа, вывести их на экран и вычислить их количество.

#include "stdafx.h"

#include

#include

#include

#include

using namespace std;

int main()

setlocale (LC_ALL, "RUS");

int n=0;

float a;

fstream F;

//открываем файл в режиме чтения

F.open("D:\\game\\noobs.txt");

//если открытие файла прошло корректно, то

//цикл для чтения значений из файла; выполнение цикла прервется,

//когда достигнем конца файла, в этом случае F.eof() вернет истину.

while (!F.eof())

//чтение очередного значения из потока F в переменную a

F>>a;

//вывод значения переменной a на экран

cout<

//увеличение количества считанных чисел

//закрытие потока

F.close();

//вовод на экран количества считанных чисел

cout<<"n="<

//если открытие файла прошло некорректно, то вывод

//сообщения об отсутствии такого файла

else cout<<" Файл не существует"<

system("pause");

return 0;

C++. Обработка двоичных файлов

При записи информации в двоичный файл символы и числа записываются в виде последовательности байт.

Для того чтобы записать данные в двоичный файл, необходимо:

описать файловую переменную типа FAIL * с помощью оператора FILE *filename;. Здесь filename - имя переменной, где будет храниться указатель на файл.

записать информацию в файл с помощью функции fwrite

Для того чтобы считат ь данные из двоичного файла, необходимо:

описать переменную типа FILE *

открыть файл с помощью функции fopen

закрыть файл с помощью функции fclose

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

Для открытия файла предназначена функция fopen.

FILE *fopen(const *filename, const char *mode)

Здесь filename - строка, в которой хранится полное имя открываемого файла, mode - строка, определяющая режим работы с файлом; возможны следующие значения:

«rb» - открываем двоичный файл в режиме чтения;

«wb» - создаем двоичный файл для записи; если он существует, то его содержимое очищается;

«ab» - создаем или открываем двоичный файл для дозаписи в конец файла;

«rb+» - открываем существующий двоичный файл в режиме чтения и записи;

«wb+» - открываем двоичный файл в режиме чтения и записи, существующий файл очищается;

«ab+» - двоичный файл открывается или создается для исправления существующий информации и добавления новой в конец файла.

Функция возвращает в файловой переменной f значение NULL в случае неудачного открытия файла. После открытия файла доступен 0-й его байт, указатель файла равен 0, значение которого по мере чтения или записи смещается на считанное (записанное) количество байт. Текущие значение указателя файла - номер байта, начиная с которого будет происходить операция чтения или записи.

Для закрытия файла предназначена функция fclose

int fclose(FILE *filename);

Возвращает 0 при успешном закрытие файла и NULL в противном случае.

Функция remove предназначена для удаления файлов.

int remove(const char *filename);

Эта функция удаляет с диска файл с именем filenema. Удаляемый файл должен быть закрыт. Функция возвращает ненулевое значение, если файл не удалось удалить.

Для переименования файлов предназначена функция rename:

int rename(const char *oldfilename, const char *newfilename);

Первый параметр - старое имя файла, второй - новое. Возвращает 0 при удачном завершении программы.

Чтение из двоичного файла осуществляется с помощью функции fread:

fread(void *ptr, size, n, FILE *filename);

Функция fread считывает из файла filename в массив ptr n элементов размера size. Функция возвращает количество считанных элементов. После чтения из файла его указатель смещается на n*size байт.

Запись в двоичный файл осуществляется с помощью функции fwrite:

fwrite(const void *ptr, size, n, FILE *filename);

Функция fwrite записывает в файл filename из массива ptr n элементов размера size. Функция возвращает количество записанных элементов. После записи информации в файл указатель смещается на n*size байт.

Для контроля достижения конца файла есть функция feof:

int feof(FILE *filename);

Она возвращает ненулевое значение если достигнут конец файла.

ПРИМЕР:

Создать двоичный файл D:\\game\\noobs.dat и записать в него целое число n и n вещественных чисел.

#include "stdafx.h"

#include

using namespace std;

int main()

setlocale (LC_ALL, "RUS");

int n, i;

double a;

//создаем двоичный файл в режиме записи

f=fopen("D:\\game\\noobs.dat", "wb");

// ввод числа n

cout<<"n="; cin>>n;

fwrite(&n, sizeof(int), 1, f);

//цикл для ввода n вещественных чисел

for (i=0; i

//ввод очередного вещественного числа

cout<<"a=";

cin>>a;

//запись вешественного числа в двоичный файл

fwrite(&a, sizeof(double), 1, f);

// закрываем файл

fclose(f);

system("pause");

return 0;

ПРИМЕР:

Вывести на экран содержимого созданного в прошлой задаче двоичного файла D:\\game\\noobs.dat

#include "stdafx.h"

#include

using namespace std;

int main()

setlocale (LC_ALL, "RUS");

int n, i;

double *a;

FILE *f; //описываем файловую переменную

//открываем существующий двоичный файл в режиме чтения

//считываем из файла одно целое число в переменную n

//вывод n на экран

cout<<"n="<

//выделение памяти для массива из n чисел

a=new double[n];

//чтение n вещественных чисел из файла в массив a

//вывод массива на экран

for (i=0; i

cout<

cout<

// закрываем файл

fclose(f);

system("pause");

return 0;

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

int n, i;

double a;

FILE *f;

f=fopen("D:\\game\\noobs.dat", "rb");

for (i=0; i<15; i++)

fclose(f);

f=fopen("D:\\game\\noobs.dat", "rb");

fread(&a, sizeof(double), 1, f);

fclose(f);

Как видно, такое чтение чисел из файла, а затем повторное открытие файла - не самый удобный способ. Гораздо удобнее будет использовать функцию fseek перемещения указателя файла к заданному байту.

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

Функция устанавливает указатель текущий позиции файла F в соответствии со значением начала отсчета origin и смещения offset. Параметр offset равен количеству байтов, на которые будет смещен указатель файла относительно начала отсчета, заданного параметром origin. В качестве значения для параметра origin должно быть взято одно из следующих значений отсчета смещения offset, определенных в заголовке stdio.h:

SEEK_SET - с начала файла;

SEEK_CUR - с текущей позиции;

SEEK_END - с конца файла.

Функция возвращает нулевое значение при успешном выполнение операции, ненулевое - при возникновении сбоя при выполнении смещения

Функция fseek фактически реализует прямой доступ к любому значению в файле. Необходимо только знать месторасположение (номер байта) значения в файле. Рассмотрим использование прямого доступа в двоичных файлах на примере решения следующей задачи.

ПРИМЕР

В созданном раннее двоичном файле D:\\game\\noobs.dat, поменять местами наибольшее и наименьшее из вещественных чисел.

Алгоритм решения задачи состоит из следующих этапов:

чтение вещественных из файла в массив a.

поиск в массиве а максимального (max) и минимального (min) значения и их номеров (imax, imin).

перемещения указателя файла к максимальному значению и запись min.

перемещения указателя файла к минимальному значению и запись max.

Ниже приведен текст программы решения задачи с комментариями.

#include "stdafx.h"

#include

using namespace std;

int main()

setlocale (LC_ALL, "RUS");

int n, i, imax, imin;

double *a, max, min;

FILE *f;

//открытие файла в режиме чтения и записи

f=fopen("D:\\game\\noobs.dat", "rb+");

//считываем из файла в переменную n количество

//вещественных чисел в файле

fread(&n, sizeof(int), 1, f);

cout<<"n="<

//выделяем память для хранения вещественных чисел,

//которые будут храниться в массиве a

a=new double[n];

//считываем из файла в массив а вещественные числа

fread(a, sizeof(double), n, f);

//поиск максимального и минимального элементов

//в массиве а и их индексов

for (imax=imin=0, max=min=a, i=1; i

if (a[i]>max)

max=a[i];

if (a[i]

min=a[i];

// перемещение указателя к максимальному элементу

fseek(f, sizeof(int)+imax*sizeof(double), SEEK_SET);

//запись min вместо максимального элемента файла

fwrite(&min, sizeof(double), 1, f);

// перемещение указателя к минимальному элементу

fseek(f, sizeof(int)+imin*sizeof(double), SEEK_SET);

//запись max вместо минимального элемента файла

fwrite(&max, sizeof(double), 1, f);

//закрытие файла

fclose(f);

//освобождение памяти

delete [ ]a;

system("pause");