Загрузки 

Создание файла c#. Класс ofstream: запись файлов. Класс ifstream: чтение файлов

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

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

Класс CF ile

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

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

Наиболее часто применяются классы 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 , записанного ранее, нужно написать код наподобие следующего:

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



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

Переместить по содержимому файла: искать и указывать в текстовых файлах

Результат должен быть следующим.

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

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

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

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

Класс 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 поменяются местами.

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

В этом разделе будут рассотрены два способа работы с фыйлами и стандартный класс MFC CFileDialog.


1. Работа с файлами в C (работает и в C++)..


    #include
    #include

Void main(void)
{
FILE *file;
char* file_name = "file.txt";
char load_string = "none";

File = fopen(file_name, "w");

Fputs("string", file);

File = fopen(file_name, "r");
if(file != 0)
{
fgets(load_string, 50 , file);
cout }
else
{
cout }
fclose(file);
} Описание функций работы с файломи находятся в библиотеке stdio.h
Сначала надо создать указатель на переменную типа FILE (FILE* file; ).
Открытие файла производится вызовом функции fopen (file = fopen(file_name, "w"); )
Первый параметр этой функции - имя файла, второй - указывает в каком режиме должен быть открыт файл. "w" - открыть для записи, "r" - открыть для чтения, "a" - дополнение файла(это наиболее используемые режимы, хотя есть и другие). Запись и считывание данных из файла осуществляется следующими функциями: fputc, fputs, fgetc, fgets, fprintf, fscanf (описание этих функций смотрите в stdio.h ).
Закрытие файла осуществляется вызовом функции fclose (fclose(file); ).

Работа с файлами с помощью MFC(классы CFile, CStdioFile, ...) и стандартный класс MFC CFileDialog.


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

CFile .

Класс CF ile

CFile предназначен для обеспечения работы с файлами. Он позволяет упростить использование файлов, представляя файл как объект, который можно создать, читать, записывать и т.д.

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

Open .

Открытие и создание файлов

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

Virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags, CFileException* pError=NULL);

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

Второй параметр nOpenFlags определяет действие, выполняемое методом Open с файлом, а также атрибуты файла. Ниже представлены некоторые возможеые значения параметра nOpenFlags:

  • CFile::modeCreate - Создается новый файл. Если указанный файл существует, то его содержимое стирается и длина файла устанавливается равной нулю.
  • CFile::modeNoTruncate - Этот файл предназначен для использования совместно с файлом CFile::modeCreate. Если создается уже существующий файл, то его содержимое не будет удалено.

  • CFile::modeRead - Файл открывается только для чтения.
  • CFile::modeReadWrite - Файл открывается для записи и для чтения.
  • CFile::modeWrite - Файл открывается только для записи.
  • CFile::typeText - Используется классами, порожденными от класса CFile, например CStdioFile, для работы с файлами в текстовом режиме. Текстовый режим обеспечивает преобразование комбинации символа возврата каретки и символа перевода строки.
  • CFile::Binary - Используется классами, порожденными от класса CFile, например CStdioFile, для работы с файлами в двоичном режиме.

    • Необязательный параметр pError, который является указателем на объект класса CFileException , используется только в том случае, если выполнение операции с файлом вызовет ошибку. При этом в объект, указываемый pError, будет записана дополнительная информация.

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

    Идентификатор открытого файла

    В состав класса CFile входит элемент данных m_hFile типа UINT. В нем хранится идентификатор открытого файла. Если объект класса CFile уже создан, но файл еще не открыт, то в переменной m_hFile записана константа hFileNull.

    Обычно идентификатор открытого файла непосредственно не используется. Методы класса CFile позволяют выполнять практически любые операции с файлами и не требуют указывать идентификатор файла. Так как m_hFile является элементом класса, то реализация его методов всегда имеет свободный доступ к нему.

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

    После завершения работы с файлом, его надо закрыть. Класс CFile имеет для этого специальный метод Close. Нужно заметить, что если был создан объект класса CFile и открыт файл, а затем объект удаляется, то связанный с ним файл закрывается автоматически с помощью деструктора.

    Чтение и запись файлов

    Для доступа к файлам предназначено несколько методов класса CFile : Read, ReadHuge, Write, WriteHuge, Flush . Методы Read и ReadHuge предназначены для чтения данных из предварительно открытого файла. В 32-разрядных операционных системах оба метода могут одновременно считать из файла больше 65535 байт. Спецификация ReadHuge считается устаревшей и оставлена только для совместимости с 16-разрядными операционными системами.

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

    Для записи в файл предназначены методы Write и WriteHuge. В 32-разрядных операционных системах оба метода могут одновременно записывать в файл больше 65535 байт. Методы записывает в открытый файл nCount байт из буфера lpBuf. В случае возникновения ошибки записи, например переполнения диска, методы вызывает обработку исключения.

    Метод Flush

    Когда используется метод Write или WriteHuge для записи данных на диск, они некоторое время могут находиться во временном буфере. Чтобы убедиться, что необходимые изменения внесены в файл на диске, нужно воспользоваться методом Flush.

    Операции с файлами

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

    Для изменения имени файла класс CFile включает статический метод Rename , выполняющий функции этой команды. Метод нельзя использовать для переименования каталогов. В случае возникновения ошибки метод вызывает исключение.

    Для удаления файлов в классе CFile включен статический метод Remove , позволяющий удалить указанный файл. Этот метод не позволяет удалять каталоги. Если удалить файл невозможно, то метод вызывает исключение.

    Чтобы определить дату и время создания файла, его длину и атрибуты, предназначен статический метод GetStatus . Существует две разновидности метода - первый определен как виртуальный, а второй - как статический метод.

    Виртуальная версия метода GetStatus определяет состояние открытого файла, связанного с данным объектом класса CFile. Этот метод вызывается только тогда, когда объект класса CFile создан и файл открыт.

    Статическая версия метода GetStatus позволяет определить характеристики файла, не связанного с объектом класса CFile. Чтобы воспользоваться этим методом, необязательно предварительно открывать файл.

    Блокировка

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

    Установить блокировку можно с помощью метода LockRange . Чтобы снять установленные блокировки, надо воспользоваться методом UnlockRange . Если в одном файле установлены несколько блокировок, то каждая из них должна сниматься отдельным вызовом метода UnlockRange .

    Позиционирование

    Чтобы переместить указатель текущей позиции файла в новое положение, можно воспользоваться одним из следующих методов класса CFile - Seek, SeekToBegin, SeekToEnd. В состав класса CFile также входят методы, позволяющие установить и изменить длину файла, - GetLength, SetLength .

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

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

    Seek . Он позволяет переместить указатель на определенное число байт относительно начала, конца или текущей позиции указателя.

    Чтобы переместить указатель в начало или конец файла, наиболее удобно использовать специальные методы. Метод

    SeekToBegin перемещает указатель в начало файла, а метод SeekToEnd - в его конец.

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

    GetLength . Этот метод также возвращает длину открытого файла в байтах. Метод SetLength позволяет изменить длину открытого файла. Если при помощи этого метода размер файла увеличивается, то значение последних байт не определено.

    Текущую позицию указателя файла можно определить с помощью метода

     GetPosition . Возвращаемое методом GetPosition 32-разрядное значение определяет смещение указателя от начала файла.

    Характеристики открытого файла

    Чтобы определить расположение открытого файла на диске, надо вызвать метод GetFilePath . Этот метод возвращает объект класса CString , в котором содержится полный путь файла, включая имя диска, каталоги, имя файла и его расширение.

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

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

    Класс C

     MemFile

    В библиотеку MFC входит класс

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

    Работая с объектами класса

    CMemFile , можно использовать практически все методы класса CFile , которые были описаны выше. Можно записывать данные в такой файл или считывать их. Кроме этих методов в состав класса CMemFile включены дополнительные методы.

    Для создания объектов класса CMemFile предназначено два различных конструктора. Первый конструктор CMemFile имеет всего один необязательный параметр nGrowBytes:

     CMemFile(UINT nGrowBytes=1024);

    Этот конструктор создает в оперативной памяти пустой файл. После создания файл автоматически открывается (не нужно вызывать метод Ope

     n).

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

    CMemFile вызывают стандартные функции malloc, realloc и free . Если выделенного блока памяти недостаточно, его размер увеличивается. Увеличение блока памяти файла происходит по частям по nGrowBytes байт. После удаления объекта класса CMemFile используемая память автоматически возвращается системе.

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

     CMemFile(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes=0);

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

    Необязательный параметр nGrowBytes используется более комплексно, чем в первом конструкторе класса. Если nGrowBytes содержит нуль, то созданный файл будет содержать данные из буфера lpBuffer. Длина такого файла будет равна nBufferSize.

    Если nGrowBytes больше нуля, то содержимое буфера lpBuffer игнорируется. Кроме того, если в такой файл записывается больше данных, чем помещается в отведенном буфере, то его размер автоматически увеличивается. Увеличение блока памяти файла происходит по частям по nGrowBytes байт.

    CMemFile позволяет получить указатель на область памяти, используемую файлом. Через этот указатель можно непосредственно работать с содержимым файла, не ограничивая себя методами класса CFile . Для получения указателя на буфер файла можно воспользоваться методом Detach. Перед этим полезно определить длину файла (и соответственно размер буфера памяти), вызвав метод GetLength . Detach закрывает данный файл и возвращает указатель на используемый им блок памяти. Если опять потребуется открыть файл и связать с ним оперативный блок памяти, нужно вызвать метод Attach .

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

     CMemFile вызывает стандартные функции malloc, realloc и free . Поэтому, чтобы не нарушать механизм управления памятью, буфер lpBuffer должен быть создан функциями malloc или calloc .

    Класс CStdioFile

    Тем, кто привык пользоваться функциями потокового ввода/вывода из стандартной библиотеки C и C++, следует обратить внимание на класс

    CStdioFile , наследованный от базового класса CFile . Этот класс позволяет выполнять буферизированный ввод/вывод в текстовом и двоичном режиме. Для объектов класса CStdioFile можно вызывать практически все методы класса CFile. CStdioFile входит элемент данных m_pStream, который содержит указатель на открытый файл. Если объект класса CStdioFile создан, но файл еще не открыт, либо закрыт, то m_pStream содержит константу NULL. CStdioFile имеет три различных конструктора. Первый конструктор класса CStdioFile не имеет параметров. Этот конструктор только создает объект класса, но не открывает никаких файлов. Чтобы открыть файл, надо вызвать метод Open базового класса CFile .

    Второй конструктор класса

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

    Третий конструктор можно использовать, если надо создать объект класса

    CStdioFile , открыть новый файл и связать его с только что созданным объектом.

    Для чтения и записи в текстовый файл класс CStdioFile включает два новых метода:

    ReadString и WriteString . Первый метод позволяет прочитать из файла строку символов, а второй метод - записать.

    Примеры записи и чтения из файла

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

    Открытие файла и чтение из него

         CString m_Text; …… // создание стандартной панели выбора файла Open CFileDialog DlgOpen(TRUE,(LPCSTR)"txt",NULL, OFN_HIDEREADONLY,(LPCSTR)" Text Files (*.txt) |*.txt||"); // отображение стандартной панели выбора файла Open if(DlgOpen.DoModal()==IDOK) { // создание объекта и открытие файла для чтения CStdioFile File(DlgOpen.GetPathName(),CFile::modeRead|CFile::typeBinary); // чтение из файла строки CString& ref=m_Text; File.ReadString(ref); // передается ссылка на строку m_Text }

    Открытие файла и запись из него

         CString m_Text; …… // создание стандартной панели выбора файла SaveAs CFileDialog DlgSaveAs(FALSE,(LPCSTR)"txt",NULL, OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT, (LPCSTR)" Text Files (*.txt) |*.txt||"); // отображение стандартной панели выбора файла SaveAs if(DlgSaveAs.DoModal()==IDOK) { // создание объекта и открытие файла для записи CStdioFile File(DlgSaveAs.GetPathName(), CFile::modeCreate|CFile::modeWrite|CFile::typeBinary); // запись в файл строки File.WriteString((LPCTSTR)m_Text); }
      находится рабочий код программы, выполненной для простоты в виде консольного приложения под MFC. Чтобы программа работала не забудте сделать следующее:

      Запустите программу - Build / Rebuild all (будут ошибки), выберите Build / Set active configuration - Win 32 Realise, выберите пункт меню "Project", далее "Settings...", закладку "C/C++", Category - Code Generation и в пункте "Use run-time library" выберите "Multithreaded". После этого сделайте опять Build / Rebuild all и программа будет работать.



    Есть вопросы?

    Сообщить об опечатке

    Текст, который будет отправлен нашим редакторам:

    Отправить