Вредоносное ПО (malware) - это назойливые или опасные программы,...
Записывать информацию в текстовый файл мы уже научились. – Если не научились смотрите прошлую статью. Там рассказывается и подробно описано
Но что если файл уже существует и нам нужно считать с него информацию для обработки? К счастью это тоже достаточно просто. Напоминаю, что вариантов для реализации этой задачи существует несколько, мною описан только один из. Описан тот, который лично мне почему-то кажется наиболее простым для восприятия.
#include
int main
()
{
char s1
//
Переменная будет считывать строку
ifstream in
(“C:\\\FromC\\myfile.txt”
); //
Открываем файл для считывания информации
in
>>s1
; //
считываем строку
in
.close
() //
Закрываем файл
cout
<
return 0
;
}
Вот наипростейшая программа для считывания первой строки из текстового файла, который находится по пути
C:\\\FromC\\myfile.txt
–
Так как это продолжение прошлой статьи , то я решил использовать тот файл, который мы там создавали. Трудностей с этим, наверное возникнуть не должно.
Но вернемся к коду. Сначала мы открываем файл для считывания из него информации, для этого используем команду ifstream
,
в скобках указываем либо название файла, либо путь к файлу, как сделано у меня.(“C:\\\FromC\\myfile.txt”
);
Когда мы открыли файл, чтобы считать из него что-то, мы объявили одну переменную типа char –
char s1
Теперь нам осталось только присвоить переменной значение строки из файла. Это мы делаем командой in
Обращаем внимание на угловые скобки in
>>
Собственно, как должно быть видно из комментариев к коду программы, то чтобы переменная присвоила считываемое значение, мы должны написать её после in
>>
in
>>s1
;
Никакой особо сложной задачей это не представляется, особенно если вы уже прекрасно освоили и научились использовать материал прошлой статьи – всё абсолютно аналогично, только 2 команды другие
Создание файла и запись в него информации С++
ofstream out
(Имя файла
);
out
<< (Записываемая строка
);
out
.close
();
=============================
Чтение текста из файла и вывода текста на экран в C++
ifstream in
(Имя файла
);
in
>>
(Считываем строку
);
in
.close
();
(Закрываем файл
)
============================
Напишем простую программу, которая будет считывать ввод с клавиатуры текста и записывать его в файл:
#include
#include
int main
()
{
\\
3 будущие строки
clrscsr
(); //
Очищаем экран
cout
<<“Wwedi pervuu stroku”
;
cin
>>a
; endl
;
cout
<<“Wwedi wtoruu stroku”
;
cin
>>b
; endl
;
cout
<<“Wwedi tretuu stroku”
;
cin
>>c
; endl
;
clrscr
(); //
/*Начинаем работу с файлом*/
ofstream out
(“C:\\\FromC\\myfile.txt”
); //
Открываем файл для записи
out
<Записываем первую строчку
out
<Записываем вторую строчку
out
<
out
.close
(); //
Закрываем файл
//Обнуляем переменные
for (int i
=0
;i
<=255
;i
++)
{a
=*“”
; b
=*“”
; c
=*“”
;}
ifstream in
(“C:\\\FromC\\myfile.txt”
);
in
>>a
>>b
>>c
; //
Считываем каждую новую строчку в новую переменную
in
.close
(); //
Закрываем файл
/* */
for (i
=0
;a
!=*“”
;i
++)
{
if (i
>sizeof(a
))
break
;
cout
<
}
cout
<<“\n”
; \\
/* */
{
if (i
>sizeof(b
))
break
;
cout
<
}
cout
<<“\n”
; \\
Перевели курсор на новую строчку
/* */
for (i
=0
;с
!=*“”
;i
++)
{
if (i
>sizeof(c
))
break
;
cout
<<с
;
}
return 0
;
}
===================
В приведенных выше примерах есть один такой ОГРОМНЫЙ недостаток. Если мы будем пытаться ввести строчку, содержащую пробелы, то программа будет срабатывать не так как нам нужно. Наверное, на эту ошибку наткнулся не только я, но и многие другие люди. Поэтому я оставляю неверно приведенный код, чтобы было видно с чем можно столкнуться.
Так как книжек дома нет, я снова стал рыскать в интернете и понаходил много всякой мудреной ерунды. Но всё-таки как-то подобрал решение своей проблемы.
Помогло то, что читал о том, что cout
поддерживает свои методы. И в интернете все советы идут на использование функции getline
К моему счастью как использовать эту функцию я нашел очень быстро и потом использовал ее в коде.
Вообще стоит упомянуть и описать эту функцию, но пока что я не особо её понимаю, просто понимаю, что её нужно использовать и понимаю как, поэтому привожу более правильный пример нашей разрабатываемой программы:
#include
#include
int main
()
{
char a
,b
,c
;
\\
3 будущие строки
clrscsr
(); //
Очищаем экран
/* Вводим значения для переменных*/
cout
<<“Wwedi pervuu stroku”
;
cin.getline(a,sizeof(a));
endl
;
cout
<<“Wwedi wtoruu stroku”
;
cin.getline(a,sizeof(b));
endl
;
cout
<<“Wwedi tretuu stroku”
;
cin.getline(a,sizeof(c));
endl
;
clrscr
(); //
После ввода значений очистили экран
/*Начинаем работу с файлом*/
ofstream out
(“C:\\\FromC\\myfile.txt”); //
Открываем файл для записи
out
<Записываем первую строчку
out
<Записываем вторую строчку
out
<
out
.close
(); //
Закрываем файл
//Обнуляем переменные
for (int i
=0
;i
<=255
;i
++)
{a
=*“”
; b
=*“”
; c=*“”
;}
/*Продолжаем работу с файлом*/
if stream in
(“C:\\\FromC\\myfile.txt”
);
in.getline(a,sizeof(a));
//
а
in.getline(b,sizeof(b));
//
Считываем строчку в переменную b
in.getline(c,sizeof(c));
//
Считываем строчку в переменную c
in
.close
(); //
Закрываем файл
/* Считываем посимвольно первую строку и выводим её на экран*/
for (i
=0
;a
!=*“”
;i++)
{
if (i
>sizeof(a
))
break
;
cout
<
}
cout
<<“\n”
; \\
Перевели курсор на новую строчку
/* Считываем посимвольно вторую строку и выводим её на экран*/
for (i
=0
;b
!=*“”
;i
++)
{
if (i
>sizeof(b
))
break
;
cout
<
}
cout
<<“\n”
; \\
Перевели курсор на новую строчку
/* Считываем посимвольно третью строку и выводим её на экран*/
for (i
=0
;с
!=*“”
;i++)
{
if (i>sizeof
(c
))
break
;
cout
<<с[i];
}
getch
(); \\
Ожидаем нажатия клавиши Enter
return 0
;
}
===================
В этом материале разобран пример посимвольного чтения информации. Так как я не описывал работу с перемнными типа char , то у начинающих могут возникнуть некоторые неудобства воспринятия кода. Просто я не знал, что тип char имеет какие-то особенности и думал всё проще. Поэтому некоторые непонятные моменты приведенной программы можно прочитать в следующей статье работа с char в C++ для начинающих
В остальном, приведенный пример, как в C++ считать строки из текстового файла должен быть доступен и вполне понятен. Это сейчас не оптимальный вариант реализации, и я упустил некоторые важные моменты, но так как у нас начало изучения языка C++, то этого пока вполне достаточно. Попозже я наверняка дойду до упущенного, а сейчас нужно воспринимать только самое необходимое.
Если мы вместе с вами поняли этот материал, то значит продвинулись на маленький шажок к своему профессионализму.
Примечание:
break
;
– Это команда, которая выполняет выход из цикла. У нас если счетчик цикла for
становится больше чем объявленный размер переменной char,
то мы принудительно выходим из цикла
!= –
это поставленное нами условие. Обозначает такое условие неравенство
if(a
!=b
)
– Читается как если a
не равно b
endl
; –
Это перевод курсора на новую строку внутри консоли (насколько я понял)
Эта команда похожа на“\n”
Для программиста открытый файл представляется как последовательность считываемых или записываемых данных. При открытии файла с ним связывается поток ввода-вывода . Выводимая информация записывается в поток, вводимая информация считывается из потока.
Когда поток открывается для ввода-вывода, он связывается со стандартной структурой типа 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.
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 включено несколько классов для обеспечения работы с файлами. Рассматриваемые ниже классы наследуются от базового классаРабота с файлами с помощью MFC(классы CFile, CStdioFile, ...) и
стандартный класс MFC CFileDialog.
Класс CF ile
CFile предназначен для обеспечения работы с файлами. Он позволяет упростить использование файлов, представляя файл как объект, который можно создать, читать, записывать и т.д.Чтобы получить доступ к файлу, сначала надо создать объект класса CFile. Конструктор класса позволяет сразу после создания такого объекта открыть файл. Но можно открыть файл и позднее, воспользовавшись методом
Open .Открытие и создание файлов
После создания объекта класса CFile можно открыть файл, вызвав метод Open . Методу надо указать путь к открываемому файлу и режим его использования. Прототип метода Open имеет следующий вид:
Virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags,
CFileException* pError=NULL);
В качестве параметра lpszFileName надо указать имя открываемого файла. Можно указать только имя файла или полное имя файла, включающее полный путь к нему. Второй параметр nOpenFlags определяет действие, выполняемое методом Open с файлом, а также атрибуты файла. Ниже представлены некоторые возможеые значения параметра nOpenFlags:
Необязательный параметр 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 и программа будет работать.
Работа с текстовыми файлами в 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");
Механизм ввода-вывода, разработанный , не соответствует общепринятому сегодня стилю объектно-ориентированного программирования, кроме того, он активно использует операции с указателями, считающиеся потенциально небезопасными в современных защищённых средах выполнения кода. Альтернативой при разработке прикладных приложений является механизм стандартных классов ввода-вывода, предоставляемый стандартом языка 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 В следующем примере показан цикл считывания строк из файла test.txt и их отображения на консоли. #include Этот код под ОС 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 В результате выполнения этого кода образуется бинарный файл 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 В конструкторе объекта file надо указать флаги ios::in и ios::out , разрешая одновременное выполнение операций чтения и записи. В результате выполнения этого кода первая и третья записи бинарного файла Notebook.dat поменяются местами. Дополнительные примеры по теме есть .
