- •Р. Лафоре
- •Глава 1. Общие сведения 32
- •Глава 3. Циклы и ветвления 92
- •Глава 4. Структуры 142
- •Глава 5. Функции 168
- •Глава 6. Объекты и классы 217
- •Глава 7. Массивы и строки 261
- •Глава 8. Перегрузка операций 312
- •Глава 10. Указатели 411
- •Глава 9. Наследование 361
- •Глава 11. Виртуальные функции 476
- •Глава 12. Потоки и файлы 536
- •Глава 13. Многофайловые программы 596
- •Глава 14. Шаблоны и исключения 640
- •Глава 15. Стандартная библиотека шаблонов (stl) 681
- •Глава 16. Разработка объектно-ориентированного по 752
- •Глава 1 «Общие сведения» включает список тем, касающихся uml, с указа- нием их расположения в книге.
- •Глава 1
- •Глава 2
- •Глава 3
- •If внутри циклов
- •If и else во вложенных ветвлениях
- •Глава 4
- •Глава 5 Функции
- •Глава 6
- •Глава 7
- •123456. Россия
- •123456. Россия
- •Глава 8
- •Глава 9
- •Глава 10 Указатели
- •Main() передает адрес переменной var в ptrd в centimize()
- •Centimize() использует этот адрес для доступа к var
- •Глава 11
- •Глава 12
- •Тип:менеджер Фамилия: Александров Номер:1111
- •Тип:Ученый Фамилия: Лебедев Номер:2222
- •Тип:рабочий Фамилия:Шевелев Номер:3333
- •Глава 13
- •Глава 14
- •Много объектов разных классов в памяти Рис. 14.2. Шаблон класса
- •Алгоритмы используют итераторы для работы с объектами контейнеров. Рис. 15.1. Контейнеры, алгоритмы и итераторы
- •Глава 16
- •Глава 1
- •Глава 2
- •Глава 3
- •Глава 4
- •Глава 5
- •Глава 6
- •Глава 7
- •Глава 8
- •Глава 9
- •Глава 10 Ответы на вопросы
- •Глава 11
- •Глава 12 Ответы на вопросы
- •Глава 13 Ответы на вопросы
- •Глава 14 Ответы на вопросы
- •Глава 15 Ответы на вопросы
- •Глава 16
Потоки
и файлы
Потоковые
классы
Ошибки
потоков
Потоковый
ввод/вывод
дисковых файлов
Указатели
файлов
Обработка
ошибок файлового ввода/вывода
Файловый
ввод/вывод с помощью методов
Перегрузка
операций извлечения и вставки
Память
как поток
Аргументы
командной строки
Вывод
на печатающее устройство
Эта глава посвящена
потоковым классам в C++.
Мы начнем с иерархии, в соот-
ветствии
с которой организуются эти классы, и
сведем вместе знания обо всех их
важных
особенностях. Наибольшее внимание в
главе уделено тому, чтобы пока-
зать,
как выполняются действия, связанные с
файлами, с использованием пото-
ков.
Мы покажем, как выполняется чтение и
запись файлов различными спосо-
бами,
как обрабатывать ошибки ввода/вывода,
как связано ООП с файлами.
Затем мы
рассмотрим некоторые другие особенности
C++,
связанные с файла-
ми, включая
форматирование текста «в памяти» (файл
«в памяти» ведет себя,
как дисковый,
хотя находится в
оперативной
памяти),
работу с аргументами ко-
мандной
строки, перегрузку операторов вставки
и извлечения, посылку данных
на
принтер.
Потоковые классы
Поток
— это общее название, как ни странно,
потока данных. В C++
поток пред-
ставляет собой объект
некоторого класса. Именно поэтому вы
могли встретить
в листингах потоковые
объекты
cin
и
cout.
Разные потоки
предназначены дляГлава 12
представления
разных видов данных. Например, класс
ifstream
олицетворяет
со-
бой поток данных от входного
дискового файла.
Преимущества
потоков
Программисты на C
могут удивиться, какие же преимущества
дает использование
потоковых классов
для ввода/вывода
вместо традиционных функций C
printf(),
scanf(),
для файлов —
fprintf(),
fscanf()...
Одним из аргументов
в пользу потоков является простота
использования.
Если вам приходилось
когда-нибудь использовать символ
управления форма-
том %d
при форматировании
вывода с помощью %f
в printf(),
вы оцените
это.
Ничего подобного в потоках вы
не встретите, ибо каждый объект сам
знает, как
он должен выглядеть на
экране. Это избавляет программиста от
одного из ос-
новных источников
ошибок.
Другой причиной
является то, что можно перегружать
стандартные операто-
ры и функции
вставки (<<)
и извлечения (>>)
для работы с создаваемыми клас-
сами.
Это позволяет работать с собственными
классами как со стандартными
типами,
что, опять же, делает программирование
проще и избавляет от множе-
ства
ошибок, не говоря уж об эстетическом
удовлетворении.
Но неужели потоковый
ввод/вывод
так важен при работе в среде с графиче-
ским
интерфейсом пользователя, такой, как,
например, Windows,
где
непосред-
ственный вывод текста на
экран не используется вообще? Неужели
в наше вре-
мя еще нужны потоки C++?
Оказывается, да, нужны. Потому что это
лучший
способ записывать данные в
файл, лучший способ организации данных
в памя-
ти для последующего использования
при вводе/выводе
текста в окошках и дру-
гих элементах
графического интерфейса пользователя
(GUI).
Иерархия
потоковых классов
Потоковые классы имеют довольно сложную
иерархическую структуру. На рис.
12.1
показана организация важнейших
из них.
Мы уже встречались
с использованием некоторых потоковых
классов. Опе-
рация извлечения >>
является методом класса istream,
операция вставки
<<
—
методом класса ostream.
Оба этих класса
являются наследниками ios.
Объект
cout,
представляющий
собой стандартный выходной поток,
который обычно вы-
водит на экран
данные, является предопределенным
объектом класса ostream_
withassign,
являющегося
наследником класса ostream.
Аналогично,
cin
—
объект
istream_withassign,
наследника
istream.
Классы, используемые
для вывода данных на экран и ввода с
клавиатуры,
описаны в заголовочном
файле IOSTREAM,
который мы
всегда подключали в на-
ших примерах
из предыдущих глав. Классы, используемые
для ввода/вывода
файлов,
объявлены в файле FSTREAM.
На рис. 12.1 видно,
в каких заголовочных
файлах что
хранится. (К
сказанному можно добавить, что некоторые
манипу-
ляторы описаны в IOMANIP,
а некоторые
классы для работы с объектами «в
па-
мяти» определены в STRSTREAM.)
В качестве
полезного упражнения можно рас-
печатать
эти заголовочные файлы и проследить
взаимоотношения различных
IOSTREAM
FSTREAM
Рис.
12.1. Иерархия потоковых классов
На рис. 12.1 видно,
что класс ios
является базовым
для всей иерархии. Он
содержит
множество констант и методов, общих
для операций ввода/вывода
любых
видов. Некоторые из них, такие, как флаги
форматирования showpoint
и
fixed,
мы уже встречали.
В классе ios
есть также
указатель на класс streambuf,
значением
которого является адрес текущего буфера
памяти. С помощью буфе-
ра производится
обмен данными (запись
или чтение).
Кроме того, ios
содержит
некоторые
низкоуровневые программы для обработки
этих данных. В обычной
ситуации вам
не нужно заботиться о классе streambuf,
обращение к
которому из
других классов происходит
автоматически.
Классы istream
и ostream
являются
наследниками ios
и предназначены
для
ввода и вывода соответственно.
Класс istream
содержит такие
функции, как get(),
getline(),
read()
и перегружаемую
операцию извлечения (>>),
тогда как класс
ostream
содержит функции
put(),
write()
и перегружаемую
операцию вставки (<<).
Класс iostream
— наследник
одновременно классов istream
и ostream
(пример
множественного
наследования).
Его производные классы могут использоваться
классов. Файлы
хранятся в директории INCLUDE
вашего
компилятора. При
изучении хранящихся
в этих файлах классов можно найти ответы
на многие
вопросы, касающиеся потоков.
при работе с такими
объектами, как дисковые файлы, которые
могут быть откры-
ты одновременно
для записи и чтения. Три класса —
istream_withassign,
ostream_
withassign
и iostream_withassign
— являются
наследниками istream,
ostream
и
iostream
соответственно.
Они добавляют к этим классам операторы
присваивания.
Приведенный ниже свод классов может
показаться довольно абстрактным.
Его
можно пока пропустить, чтобы вернуться
к нему при осуществлении каких-
либо
конкретных действий с использованием
потоков.
Класс
ios
ios
является
дедушкой всех потоковых классов и
обладает большинством осо-
бенностей,
без которых работа с потоками была бы
невозможна. Три его главных
направления
— это флаги форматирования, флаги
ошибок и режим работы с фай-
лами.
Сначала мы обратимся к рассмотрению
флагов форматирования, затем
флагов
состояния ошибки. Рассмотрение режима
работы с файлами мы отложим
до тех
пор, пока не познакомимся с дисковыми
файлами.
Флаги
форматирования
Флаги форматирования
— это набор определений enum
(перечисляемого
типа)
в
классе ios.
Они работают
переключателями, определяющими различные
фор-
маты и способы ввода/вывода.
Мы не будем обсуждать подробно каждый
флаг,
так как одни мы уже использовали,
а названия других говорят сами за себя.
Не-
которые мы обсудим позднее в этой
же главе. В табл. 12.1 приводится
полный
список флагов форматирования.
Таблица 12.1. Флаги форматирования класса ios
|
|
Флаг |
Значение |
skipws |
Пропуск пробелов при вводе |
left |
Выравнивание по левому краю |
right |
Выравнивание по правому краю |
internal |
Заполнение между знаком или основанием числа и самим числом |
dec |
Перевод в десятичную форму |
oct |
Перевод в восьмеричную форму |
hex |
Перевод в шестнадцатеричную форму |
boolalpha |
Перевод логического 0 и 1 соответственно в «false» и «true» |
showbase
|
Выводить индикатор основания системы счисления (0 для восьмеричной, 0x для шестнадцатеричной) |
showpoint |
Показывать десятичную точку при выводе |
uppercase |
Переводить в верхний регистр буквы X, Е и буквы шестнадцатеричной системы счисления (ABCDEF) (по умолчанию — в нижнем регистре) |
showpos |
Показывать «+» перед положительными целыми числами |
scientific |
Экспоненциальный вывод чисел с плавающей запятой |
fixed |
Фиксированный вывод чисел с плавающей запятой |
unitbuf |
Сброс потоков после вставки |
stdio |
сброс stdout, sterror после вставки |
Есть несколько способов установки флагов форматирования, для каждого свои. Так как они являются компонентами класса ios, обычно к ним обращаются посредством написания имени класса и оператора явного задания (например, ios::skipws). Все без исключения флаги могут быть выставлены с помощью мето- дов setf() и unsetf(). Взгляните на следующий пример:
cout.setf(ios::left); // выравнивание текста по левому краю
cout << "Этот текст выровнен по левому краю"
cout.unsetf(ios::left); // вернуться к прежнему форматированию
Многие флаги могут быть установлены с помощью манипуляторов, давайте рассмотрим их.
Манипуляторы
Манипуляторы — это инструкции форматирования, которые вставляются прямо в поток. Мы уже видели некоторые из них, например endl, который посылает символ разделителя строк в поток и сбрасывает буфер:
cout << "Jedem Das Seine." << endl;
Мы встречали в программе SALEMON, глава 7 «Массивы и строки», манипуля- тор setiosflags(). Вспомним, как он выглядит:
cout << setiosflags(ios::fixed) // использовать
// фиксированный вывод << setiosflags(ios::showpoint) // показывать десятичную
// точку
<< var;
Как показывают эти примеры, манипуляторы бывают двух видов — с аргу- ментами и без. В табл. 12.2 сведены вместе все важные манипуляторы без аргу- ментов.
Таблица 12.2. Манипуляторы ios без аргументов |
|
Манипулятор |
Назначение |
ws |
Включает пропуск пробелов при вводе |
dec |
Перевод в десятичную форму |
oct |
Перевод в восьмеричную форму |
hex |
Перевод в шестнадцатеричную форму |
endl |
Вставка разделителя строк и очистка выходного потока |
ends |
Вставка символа отсутствия информации для окончания выходной строки |
flush |
Очистка выходного потока |
lock |
Закрыть дескриптор файла |
unlock |
Открыть дескриптор файла |
Вставляются эти манипуляторы прямо в поток. Например, чтобы вывести var в шестнадцатеричной форме, надо указать:
cout << hex << var;
Имейте в виду, что манипуляторы действуют только на те данные, которые следуют за ними в потоке, а не на те, которые находятся перед ними. На то он и поток. В табл. 12.3 представлены важнейшие из манипуляторов с аргументами. Для доступа к этим функциям вам потребуется заголовочный файл IOMANIP.
Таблица 12.3. Манипуляторы ios с аргументами
Манипулятор |
Аргумент |
Назначение |
setw() |
ширина поля (int) |
Устанавливает ширину поля для вывода данных |
setfill() |
символ заполнения (int) |
Устанавливает символ заполнения (по умолчанию, пробел) |
setprecision() |
точность (int) |
Устанавливает точность(число выводимых знаков) |
setiosflags() |
Флаги форматирования (long) |
Устанавливает указанные флаги форматирования |
resetiosflags() |
Флаги форматирования (long) |
Сбрасывает указанные флаги форматирования |
Функции
Класс ios содержит набор функций, с помощью которых можно выставлять флаги форматирования и выполнять некоторые другие действия. Таблица 12.4 содержит большинство этих функций, кроме тех, которые обрабатывают ошиб- ки. К последним мы обратимся позднее.
Таблица 12.4. Функции ios
Функция |
Назначение |
ch = fill(); |
Возвращает символ заполнения (символ, которым заполняется неиспользуемая часть текстового поля; по умолчанию — пробел) |
fill(ch); |
Устанавливает символ заполнения |
p = precision(); |
Возвращает значение точности (число выводимых знаков для формата с плавающей запятой) |
precision(p); |
Устанавливает точность р |
w = width(); |
Возвращает текущее значение ширины поля (в символах) |
width(w); |
Устанавливает ширину текущего поля |
setf(flags); |
Устанавливает флаг форматирования (например, ios::left) |
unsetf(flags); |
Сбрасывает указанный флаг форматирования |
setf(flags, field); |
Очищает поле, затем устанавливает флаги форматирования |
Эти функции вызываются для нужных потоковых объектов обычным спосо- бом — через точку. Например, чтобы установить ширину поля 12, можно написать:
cout.width(14);
Следующее выражение делает символом заполнения звездочку (как при тес- тировании печати):
cout.fill('*');
Можно использовать некоторые функции, чтобы манипулировать напрямую установкой флагов форматирования. Например, так можно установить вырав- нивание по левому краю:
cout.setf(ios:: left);
Чтобы восстановить выравнивание по правому краю, напишем:
cout.unsetf(ios::left);
Версия setf() с двумя аргументами использует второй из них для сбрасы- вания всех флагов указанного типа (в поле). При этом установится флаг, ука- занный в качестве первого аргумента. Таким образом, проще сбросить флаги перед установкой нового. В табл. 12.5 показан способ обращения с этой функ- цией Например:
cout.setf(ios::left, ios::adjustfield);
сбрасывает все флаги, связанные с выравниванием текста, а затем устанавливает флаг left для выравнивания по левому краю.
Таблица 12.5. Версия setf() с двумя аргументами
Первый аргумент: устанавливаемые флаги |
Второй аргумент: сбрасываемые флаги |
dec, oct, hex |
basefield |
left, right, internal |
adjustfield |
scientific, fixed |
floatfield |
С использованием указанной техники можно создать способ форматирован- ного ввода/вывода не только с клавиатуры и на дисплей, но, как мы увидим позднее в этой главе, также и для файлов.
Класс istream
Класс istream, наследник класса ios, выполняет специфические действия по вводу данных — извлечение. Очень легко спутать извлечение и связанное с ним дейст- вие по выводу данных — вставку. Рисунок 12.2 показывает разницу. В табл. 12.6 собраны функции istream, которые вам могут пригодиться.
Таблица 12.6. Функции istream
Функция |
Назначение |
>> |
Форматированное извлечение данных всех основных (и перегружаемых) типов из потока |
get(ch) |
Извлекает один символ в ch |
get(str) |
Извлекает символы в массив str до ограничителя '\n' |
get(str, MAX) |
Извлекает до MAX числа символов в массив |
Функция |
Назначение |
get(str, DELIM)
|
Извлекает символы в массив str до указанного ограничителя (обычно '\n'). Оставляет ограничитель в потоке |
get(str, MAX, DELIM) |
Извлекает в массив str до MAX символов или до символа DELIM. Оставляет ограничитель в потоке |
getline(str,MAX, DELIM) |
Извлекает в массив str до MAX символов или символа DELIM. Извлекает ограничитель из потока |
putback(ch) |
Вставляет последний прочитанный символ обратно во входной поток |
ignore(MAX,DELIM)
|
Извлекает и удаляет до MAX числа символов до ограничителя включительно (обычно '\n'). С извлеченными данными ничего не делает |
peek(ch) |
Читает один символ, оставляя его в потоке |
count = gcount()
|
Возвращает число символов, прочитанных только что встретившимися вызовами get(), getline() или read() |
read(str, MAX) |
(Для файлов.) Извлекает вплоть до MAX числа символов в массив str |
seekg() |
Устанавливает расстояние (в байтах) от начала файла до файлового указателя |
seekg(pos,seek_dir)
|
Устанавливает расстояние (в байтах) от указанной позиции в файле до указателя файла. seek_dir может принимать значения ios::beg, ios::cur, ios::end |
pos = tellg(pos) |
Возвращает позицию (в байтах) указателя файла от начала файла |
Дисковый файл
Рис. 12.2. Файловый ввод/вывод
Там уже встречались некоторые из этих функций, например get(). Большин- ство из них рассчитаны на работу с объектом cin, обычно представляющим со- бой поток данных, вводимых с клавиатуры. А последние четыре функции пред- назначены только для работы с дисковыми файлами.
Класс ostream
Класс ostream предназначен для вывода (вставки в поток) данных. Таблица 12.7 содержит наиболее общие методы этого класса. Как и в предыдущем случае, по- следние четыре функции работают только с файлами.
Таблица 12.7. Функции ostream
|
|
Функция |
Назначение |
<< |
Форматированная вставка данных любых стандартных (и перегруженных) типов |
put(ch) |
Вставка символа ch в поток |
flush() |
Очистка буфера и вставка разделителя строк |
write(str, SIZE) |
Вставка SIZE символов из массива str в файл |
seekp(position) |
Устанавливает позицию в байтах файлового указателя относительно начала файла |
seekp(position, seek_dir) |
Устанавливает позицию в байтах файлового указателя относительно указанного места в файле, seek_dir может принимать значения ios::beg, ios::cur, ios::end |
pos = tellp() |
Возвращает позицию указателя файла в байтах |
Классы iostream и _withassign
Класс iostream является порожденным по отношению к istream и ostream. Его единственное предназначение — выступать в качестве базового класса для дру- гих специфических классов вида iostream_withassign. У него нет собственных ме- тодов, кроме конструктора и деструктора. Его порожденные классы могут осу- ществлять как ввод, так и вывод данных.
Существуют три класса вида _withassign:
istream_withassign — наследник istream;
ostream_withassign — наследник ostream;
iostream_withassign — наследник iostream.
Эти классы очень похожи на своих предков. Разница лишь в том, что в них, в отличие от породивших их классов, имеются перегружаемые операции при- сваивания, благодаря чему их объекты могут быть скопированы.
Для чего нужны потоковые классы с возможностью копирования и без тако- вой? Вообще-то, это не самая лучшая идея — копировать объекты потоковых классов. Причина заключается в том, что каждый такой объект ассоциирован с конкретным объектом streambuf, включающим в себя область памяти для хра- нения данных объекта. Если вместе с потоковым объектом копировать объект streambuf, возникнет некая неразбериха. Тем не менее бывают случаи, когда важ- но иметь возможность копировать потоки.
Соответственно, классы istream, ostream и iostream созданы так, что их объек- ты нельзя копировать — операторы присваивания и конструкторы копирования сделаны скрытыми. А их наследники с хвостиком _withassign имеют возмож- ность копирования своих объектов.
Предопределенные потоковые объекты
В этой книге уже приводились примеры использования двух предопределенных потоковых объектов, порожденных классами вида _withassign: cin и cout. Обычно
они связаны с клавиатурой и монитором соответственно. Еще двумя предопреде- ленными объектами являются cerr и clog:
cin, объект istream_withassign, используется для операций ввода с клавиатуры;
cout, объект ostream_withassign, используется для операций вывода на эк- ран монитора;
cerr, объект ostream_withassign, используется для сообщений об ошибках;
clog, объект ostream_withassign, используется для ведения журнала. Объект cerr часто используется для сообщений об ошибках и программной
диагностики. Поток, посланный в него, немедленно выводится на экран, минуя буферизацию. Этим cerr отличается от cout. К тому же этот поток не может быть перенаправлен (подробнее об этом вы узнаете позже). Поэтому у вас есть не- большой шанс увидеть последнее сообщение неожиданно умершей программы. Другой объект, clog, похож на cerr в том, что также не может быть перенаправ- лен. Но его вывод проходит буферизацию.
Ошибки потоков
До сих пор в нашей книге мы использовали довольно прямолинейный подход к вводу/выводу, используя выражения вида:
cout << "Доброе утро, страна!"; и
cin >> var;
Такой подход, как вы могли заметить, предполагает, что во время процесса ввода/вывода ничего нехорошего не случится. К сожалению, не всегда все прохо- дит гладко, особенно в отношении ввода. Что будет, если наш дорогой пользова- тель введет строчку «девять» вместо числа 9, что будет, если он нажмет Enter, ничего не введя? А что случится, если произойдет скачок напряжения в элек- трической сети или просто возникнут какие-то неполадки с техникой? В про- цессе изучения этой темы мы коснемся всех этих проблем. Множество приемов, которые мы изучим, применимы и к файловому вводу/выводу.
Биты статуса ошибки
Флаги статуса ошибок потоков определяют компонент ios enum, который сообщает об ошибках, произошедших в операциях ввода/вывода. Все эти флаги собраны в табл. 12.8. Рисунок 12.3 показывает, как они выглядят. Для чтения (и даже установ- ки) флагов могут использоваться различные функции ios, как показано в табл. 12.9.
Таблица 12.8. Флаги статуса ошибок
Название |
Значение |
goodbit |
Ошибок нет (флаги не установлены, значение = 0) |
eofbit |
Достигнут конец файла |
Таблица 12.8 (продолжение) |
|
Название |
Значение |
failbit |
Операция не выполнена (пользовательская ошибка, преждевременный EOF) |
badbit |
Недопустимая операция (нет ассоциированного streambuf) |
hardfail |
Неисправимая ошибка |
Таблица 12.9. Функции для флагов ошибок
Функция |
Назначение |
int = eof(); |
Возвращает true, если установлен флаг EOF |
int = fail(); |
Возвращает true, если установлены флаги failbit, badbit или hardfail |
int = bad(); |
Возвращает true, если установлены флаги badbit или hardfail |
int = good(); |
Возвращает true, если ошибки не было |
clear(int = 0); |
При использовании без аргумента снимает все флаги ошибок, в противном случае устанавливает указанный флаг, например clear(ios::failbit) |
Ввод чисел
Посмотрим, как обрабатываются ошибки при вводе чисел. Приводимый ниже подход применяется к числам, прочитанным с клавиатуры или с диска. Идея со- стоит в том, чтобы проверять значение goodbit, сообщать об ошибке, если его зна- чение не равно true, и давать возможность пользователю ввести корректное число.
while(true) // Цикл до тех пор. пока
// ввод не будет корректным
{
cout << "\nВведите целое число: "; cin >> i;
if(cin.good()) // если нет ошибок
{
cin.ignore(10, '\n'); // удалить разделитель строк break;
} // выйти из цикла
cin.clear(); // Очистить биты ошибок
cout << "Неправильный ввод данных";
cin.ignore(10, '\n'); // Удалить разделитель строк }
cout << "целое число: " << i;// целое без ошибок
Самая общая ошибка, которая определяется по этой схеме, это ввод не цифр, а каких-либо символов (например, «девять» вместо «9»). Это приводит к уста-
Рис. 12.3. Флаги состояния потока
новке флага failbit. Но определяются и системные ошибки, наиболее типичные при работе с дисковыми файлами.
Числа в формате с плавающей запятой (float, double и long double) могут ана- лизироваться на предмет неправильного ввода так же, как и целые числа.
Переизбыток символов
Проблема превышения при вводе допустимого числа символов встречается до- вольно часто. Обычно это происходит при передаче входного потока с ошибка- ми. Лишние символы все еще остаются в потоке после того, как ввод уже счита- ется завершенным. Затем они передаются еще и в следующую операцию ввода, несмотря на то, что совершенно для этого не предназначены. Часто в конце оста- ется символ новой строки, но иногда и другие. Чтобы избежать случайного из- влечения из потока лишних символов, используется метод istream — функция ignore(MAX, DELIM). Она считывает и выкидывает вплоть до MAX числа символов, включая указанный ограничитель. В нашем примере выражение
cin.ignore(10, '\n');
приводит к считыванию до 10 символов, включая ограничитель '\n', и удалению их из входного потока.
Ввод при отсутствии данных
Символы, не несущие смысловой нагрузки, — пробелы и '\n' — обычно пропуска- ются при вводе данных. Это может привести к некоторым нежелательным по- бочным эффектам. Например, пользователи вместо ввода значения могут просто случайно нажать Enter, думая, что тем самым введут ноль, или просто запутав- шись. Приведенный выше код также, как и выражение
cin >> i;
после нажатия клавиши Enter приведет к переводу курсора на новую строку, в то время как поток все еще будет ожидать ввода данных. В чем проблема с перево- дом курсора на новую строку? Дело в том, что, не увидев адекватной реакции на свои действия, пользователь может подумать, что компьютер вышел из строя. Кроме того, обычно повторные нажатия клавиши Enter приводят к тому, что курсор сдвигается все ниже и ниже, пока не дойдет до конца экрана, после чего экран начинает прокручиваться вверх. Хорошо еще, если пользователь и программа взаимодействуют в этаком телеграфном стиле, просто печатая друг другу сооб- щения. Но если нечто подобное произойдет в программе, в которой используется графика, основанная на тексте (как в программе ELEV из главы 13 «Многофайло- вые программы»), прокручивание окна приведет к полной неразберихе на экране.
Таким образом, важно иметь возможность дать команду входному потоку не игнорировать разделители. Это делается с помощью флага skipws:
cout << "\nВведите целое число: ";
cin.unsetf(ios::skipws); // не игнорировать разделители
cin
>>
i;
if(cin.good())
{
//
ошибок нет
}
//
ОШИБКА!
Уж теперь если
пользователь и нажмет Enter,
забыв ввести
данные, то будет
установлен флаг
failbit
и тем самым
сгенерирован признак ошибки. После
этого
можно попросить пользователя
ввести данные повторно или перемещать
курсор
так, чтобы экран не прокручивался.
Ввод
строк и символов
Пользователь не
может, на самом деле, сделать больших
ошибок при вводе строк
и символов,
так как ввод любых данных, даже чисел,
можно интерпретировать,
как ввод
строк. Тем не менее, если поток пришел
из дискового файла, символы и
строки
должны проверяться на наличие ошибок,
так как не всегда все бывает
ладно
с признаком окончания файла (EOF).
В отличие от
ситуации ввода чисел
здесь вам как
раз необходимо игнорировать разделители.
Отладка
примера с английскими расстояниями
Давайте взглянем
на программу, в которой ввод пользователем
данных в класс
Distance
проверяется
на наличие ошибок. Забудем на время про
перевод расстоя-
ний из одних единиц
в другие и про работу с ними. Пусть наша
программа будет
просто получать от
пользователя данные в футах и дюймах
и выводить их на эк-
ран. Если же
пользователь ошибается, нужно отклонить
введенные данные, объ-
яснить ему,
где он ошибся, и попросить ввести данные
заново.
Программа очень
проста, за исключением того, что метод
getdist()
расширен
и
направлен на поддержку обработки
ошибок. Частично эта программа
исполь-
зует подход, показанный в
приведенном выше коде. Кроме того, мы
еще ввели
выражение, которое следит
за тем, чтобы пользователь не вводил
футы в формате
чисел с плавающей
запятой. Это действительно важно, так
как дюймы могут
иметь дробную часть,
а футы — нет, и пользователь может
слегка запутаться.
Обычно, ожидая ввод
целочисленных значений, оператор
извлечения просто
прерывает свою
работу, увидев точку в десятичной дроби.
При этом сообщение
об ошибке не
выдается. Мы же хотим узнать о совершенной
ошибке, поэтому
будем считывать
значение числа футов не в виде int,
а в виде строки.
Затем мы
проверяем введенную строку
при помощи созданной нами функции
isFeet(),
возвращающей
true,
если число
футов введено корректно. Для одобрения
нашей
функцией введенное число
должно содержать только цифры, и его
значение
должно лежать в пределах
от -999 до 999 (мы
просто предполагаем, что более
далекие
расстояния измерять не будем).
Если с введенными футами все в по-
рядке,
конвертируем строку в int
с помощью
стандартной библиотечной функ-
ции
atoi().
Число дюймов
вполне может быть дробным. Мы будем
проверять
только их значения — они
должны лежать в пределах от 0 до 12.0.
Кроме того,
будем
отслеживать наличие флагов ошибок ios.
В общем случае
будет установлен
failbit
при вводе
каких-либо символов вместо числа.
Приведем листинг ENGLERR1.
Листинг
12.1.
Программа ENGLERR
//
englerr.cpp
//
контроль ввода данных для класса
английских расстояний
#include
<iostream>
#include
<string>
#include
<cstdlib>
//
для atoi(), atof()
using
namespace std;
int
isFeet(string);
//
объявление
///////////////////////////////////////////////////////////
class
Distance
//
Класс английских расстояний
{
private:
int
feet;
float
inches;
public:
Distance()
//
конструктор (без аргументов)
{
feet = 0; inches = 0.0; }
Distance(int
ft, float
in) //
конструктор (2 арг.)
{
feet = ft; inches = in; }
void
showdist() //
вывод расстояния
{
cout
<< feet << "\'-"
<<
inches << '\"';
}
void
getdist();
//
запросить длину у пользователя
};
//---------------------------------------------------------
void
Distance::getdist()
//
получение длины от пользователя
{
string
instr;
//
для входной строки
while(true)
//
цикл, пока футы не будут правильными
{
cout
<< "\n\nВведите
футы: ";
cin.unsetf(ios::skipws);//
не пропускать разделители
cin
>>
instr;
//
получить футы как строку
if(isFeet(instr))
//
правильное значение? да
{
cin.ignore(10,
'\n');
//
съесть символы, включая разделитель
строк
feet
= atoi(instr.c_str());
//
перевести значение в целочисленное
break;
//
выход из цикла 'while'
}
//
нет, не целое
cin.ignore(10,
'\n');
//
съесть символы, включая разделитель
строк
cout
<< "Футы
должны быть целыми < 1000\n";
}
//
конец цикла while
для футов
while(true)
//
цикл проверки дюймов
{
cout
<< "Введите
дюймы: ";
cin.unsetf(ios::skipws);//
не пропускать разделители
cin
>>
inches; //
получить
дюймы
(тип
float)
if(inches
>= 12.0 || inches < 0.0)
{
cout
<< "Дюймы
должны быть между 0.0 и 11.99\n";
cin.clear(ios::failbit);//
"искусственно" установить флаг
ошибки
}
if(cin.good())
//
все ли хорошо с cin
{
//
(обычно вводят не цифры)
cin.ignore(10,
'\n');
//
съесть разделитель
break;
//
Ввод корректный, выйти из 'while'
}
cin.clear();
//
ошибка; очистить статус ошибки
cin.ignore(10,
'\n');
//
съесть символы с разделителем
cout
<< "Неверно
введены дюймы\n";
//
заново
}
//
конец while
для дюймов
}
//---------------------------------------------------------
int
isFeet(string
str)
//
true
если введена строка
{
//
с правильным значением футов
int
slen
= str.size();
//
получить длину
if(slen
== 0 || slen
> 5) //
не было или слишком много данных
return
0; //
не целое
for(int
j
= 0; j
< slen;
j++)
//
проверить каждый символ
if((str[j]
< '0'
|| str[j] > '9')
&& str[j] != '-')
//
если не цифра или минус
return
0; //
строка неправильных футов
double
n
= atof(str.c_str());
//
перевод в double
if(n
<-999.0 || n
> 999.0) //
вне допустимых значений?
return
0; //
если да, неправильные футы
return
1; //
правильные футы
}
///////////////////////////////////////////////////////////
int
main()
{
Distance
d; //
создать объект Distance
char
ans;
do
{
d.getdist();
//
получить его значение
cout
<< "\nРасстояние
= ";
d.showdist();
//
вывести его
cout
<< "\nЕще
раз (y/n)?
";
cin
>>
ans;
cin.ignore(10,
'\n');
//
съесть символы и разделитель
}
while(ans
!= 'n');
//
цикл до 'n'
return
0;
}
Мы
использовали еще одну хитрость:
установили флаг ошибки вручную.
Тем
самым мы проверили, входят ли введенные
дюймы в диапазон допустимых
значений.
Если нет, мы устанавливает failbit
с помощью
cin.clear(ios::failbit);
//
установить
failbit
При проверке на
наличие ошибок с помощью функции
cin.good()
флаг failbit
будет
обнаружен и выведется сообщение об
ошибке.
Потоковый
ввод/вывод дисковых файлов
Большинству программ требуется сохранять
данные на диске и считывать их.
Работа
с дисковыми файлами подразумевает
наличие еще одного набора специ-
альных
классов: ifstream
для ввода и ofstream
для вывода. Класс fstream
осуществ-
ляет и ввод, и вывод. Объекты этих классов
могут быть ассоциированы с диско-
выми
файлами, а их методы — использоваться
для обмена данными с ними.
Вернемся к рис.
12.1. На нем видно, что класс
ifstream
является
наследником
класса
istream,
ofstream
— класса
ostream,
fstream
— класса
iostream.
Эти родитель-
ские
классы, в свою очередь, являются
наследниками класса
ios.
Такая
иерархия
вполне логична — классы,
ориентированные на работу с файлами,
могут ис-
пользовать методы более
общих классов. К тому же файловые классы
использу-
ют принцип множественного
наследования, будучи наследниками еще
и класса
fstreambase.
Этот класс
содержит объект класса
filebuf,
являющегося
файловым
буфером, а также ассоциированные
методы, унаследованные от более
общего
класса
streambuf.
Обычно
программисту не приходится заботиться
об этих бу-
ферных классах.
Классы
ifstream,
ofstream
и
fstream
объявлены в
файле FSTREAM.
Программисты
на C наверняка обратят внимание на то,
что подход к диско-
вому вводу/выводу
в C++
оказывается совсем иным. Старые функции
языка С,
такие, как
fread()
и
fwrite()
в
C++,
конечно, работают, но они не так хорошо
впи-
сываются в концепцию
объектно-ориентированной среды
программирования.
Новый подход,
предлагаемый C++,
гораздо прозрачнее и проще в
использова-
нии. Кстати говоря,
остерегайтесь случайного перемешивания
старых функций
С с потоками C++.
Они не всегда в хороших отношениях друг
с другом, хотя
есть возможность
заставить их жить дружно.
Форматированный
файловый ввод/вывод
При форматированном
вводе/выводе
числа хранятся на диске в виде серии
сим-
волов. Таким образом, число 6.02
вместо того, чтобы храниться в виде
четырех-
байтного значения типа
float
или восьмибайтного
double,
хранится в виде
после-
довательности символов '6',
'.',
'0',
'2'.
Это странно с точки зрения экономии
памяти,
особенно в случае многоразрядных чисел,
но зато легко применяется на
практике
и в некоторых ситуациях гораздо удобнее.
Слава Богу, что хоть симво-
лы и строки
хранятся в файлах в более или менее
привычной форме.
Запись
данных
Следующая программа
демонстрирует запись символа, целого
числа, числа типа
double
и двух объектов
типа
string
в дисковый
файл. Вывод на экран не произво-
дится.
Приведем листинг программы FORMATO.
Листинг
12.2.
Программа FORMAT)
//
formato.cpp
//
Форматированный вывод в файл с
использованием <<
#include
<fstream>
//
для файлового ввода/вывода
#include
<iostream>
#include
<string>
using
namespace std;
int
main()
{
char
ch = 'x';
int
j = 77;
double
d = 6.02;
string
str1 = "Kafka";
//
строки без
string
str2 = "Proust";
//
пробелов
ofstream
outfile("fdata.txt");
//
создать объект ofstream
outfile
<< ch //
вставить (записать) данные
<<
j
<<
'
'
//
пробелы между числами
<<
d
<<
str1
<<
'
'
//
пробелы между строками
<<
str2;
cout
<< "Файл
записан\n";
return
0;
}
Здесь мы определили
объект outfile
в качестве
компонента класса ofstream.
В
то же время мы инициализировали его
файлом FDATA.TXT.
Инициализация
резервирует
для дискового файла с данным именем
различные ресурсы и полу-
чает доступ
(или
открывает файл)
к
нему. Если файл не существует, он
созда-
ется. Если файл уже существует,
он переписывается — новые данные в
нем
заменяют старые. Объект outfile
ведет себя
подобно cout
из предыдущих
про-
грамм, поэтому можно использовать
операцию вставки (<<)
для вывода пере-
менных любого из
стандартных типов в файл. Это так
замечательно работает
потому, что
оператор вставки перегружен в классе
ostream,
который
является
родительским для ofstream.
Когда программа
завершается, объект outfile
вызывает свой
деструктор, кото-
рый закрывает файл,
так что нам не приходится делать это
явным образом.
Есть несколько
потенциальных проблем
с
форматированным выводом в дис-
ковые
файлы. Во-первых, надо разделять числа
(77
и 6.02,
например)
нечисло-
выми символами. Поскольку
они хранятся в виде последовательности
симво-
лов, а не в виде полей
фиксированной длины, это единственный
шанс узнать
при извлечении, где
кончается одно и начинается другое
число. Во-вторых, меж-
ду строками
должны быть разделители — по тем же
причинам. Это подразуме-
вает, что
внутри строки не может быть пробелов.
В
этом примере для разделе-
ния данных
мы использовали пробел в обоих случаях.
Радует то, что символы
не нуждаются
в разделителях, хотя они и являются
данными фиксированной
длины.
Посмотреть на
результаты работы программы FORMATO
можно, открыв
файл
FDATA.TXT
с помощью
программы WORDPAD
или команды
DOS
TYPE.
Чтение
данных
Прочитать файл,
созданный программой FORMATO,
можно с
использованием объ-
екта типа
ifstream,
инициализированного
именем файла. Файл автоматически
откры-
вается при создании объекта.
Затем данные из него можно считать с
помощью
оператора извлечения (>>).
Приведем листинг
программы FORMATI,
которая считывает
данные из файла
FDATA.TXT.
Листинг
12.3. Программа FORMATI
//
formati.cpp
//
форматированное чтение из файла с
помощью >>
#include
<fstream>
//
для файлового ввода/вывода
#include
<iostream>
#include
<string>
using
namespace std;
int
main()
{
char
ch;
int
j;
double
d;
string
str1;
string
str2;
ifstream
infile("fdata.txt");
//
создать
объект
ifstream
//
извлечь (прочесть) из него данные
infile
>> ch >> j >> d >> str1 >> str2;
cout
<< ch << endl
//
вывести данные
<<
j << endl
<<
d << endl
<<
str1 << endl
<<
str2 << endl;
return
0;
}
Объект типа
ifstream,
который мы
назвали infile,
действует
примерно так же, как
cin
в
предыдущих программах. Если мы корректно
вставляли данные в файл, то
извлечь
их не составит никаких проблем. Мы
просто сохраняем их в соответст-
вующих
переменных и выводим на экран. Результаты
работы программы:
х
77
6.02
Kafka
Proust
Разумеется, числа
приводятся обратно к своему двоичному
представлению,
чтобы с ними можно
было работать в программе. Так, 77
сохраняется в пере-
менной j
типа int,
это уже теперь
не две семерки символьного типа. 6.02
сохра-
няется в переменной типа
double.
Строки
с пробелами
Подход,
продемонстрированный в последнем
примере, не позволяет обрабаты-
вать
строки с char*,
содержащие
пробелы. Для того чтобы эта ситуация
измени-
лась, после каждой строки
нужно писать специальный символ-ограничитель
и
использовать функцию getline()
вместо оператора
извлечения. Наша следующая
маленькая
программа OLINE
выводит строки
с пробелами. Посмотрите, как это
сделано.
Листинг
12.4.
Программа OLINE
//
oline.cpp
//
файловый вывод строк с пробелами
#include
<fstream>
//
для операций
//
файлового ввода/вывода
using
namespace std;
int
main()
{
ofstream
outfile("TEST.TXT");
//
создать
выходной
файл
//
отправить текст в файл
outfile
<< "Приходит
март. Я сызнова служу.\n";
outfile
<< "В
несчастливом кружении событий \n";
outfile
<< "изменчивую
прелесть нахожу \n";
outfile
<< "в
смешеньи незначительных наитий.\n";
return
0;
}
Когда вы запустите
программу, строки стихотворения И.
Бродского будут
записаны в файл.
Каждая строка заканчивается символом
разделения строк ('\n').
Обратите
внимание, это строки типа char*,
а не объекты
класса string.
Многие
потоковые
операции гораздо легче производить с
этим типом данных.
Чтобы извлечь
строки из файла, мы создадим ifstream
и станем читать
строч-
ку за строчкой функцией
getline(),
которая является
методом класса istream.
Эта
функция
считывает все символы, включая
разделители, пока не дойдет до
спе-
циального символа '\n',
затем помещает результат чтения в
буфер, переданный
ей в качестве
аргумента. Максимальный размер буфера
передается с помощью
второго
аргумента. Его содержимое выводится
на экран после считывания каж-
дой
строки.
Листинг
12.5.
Программа ILINE
//
iline.cpp
//
Файловый ввод (извлечение из файла)
строк
#include
<fstream>
//
для
файловых
функций
#include
<iostream>
using
namespace std;
int
main()
{
const
int
MAX = 80; //
размер
буфера
char
buffer[MAX]; //
буфер
символов
ifstream
infile("TEST.TXT");
//
создать
входной
файл
while(!infile.eof())
//
цикл
до
EOF
{
infile.getline(buffer,
MAX); //
читает строку текста
cout
<< buffer
<< endl;
//
и выводит ее
}
return
0;
}
В результате работы
программы на экране появятся все та же
строфа из сти-
хотворения, которую
мы записали в файл TEST.TXT
в процессе
работы програм-
мы OLINE.
Программе не
дано знать, сколько всего строчек в
тексте, поэтому она
продолжает чтение
до тех пор, пока не встретит признак
окончания файла (EOF).
Учтите,
что эту программу нельзя применять для
чтения произвольных фай-
лов, —
каждая строка текста должна заканчиваться
символом '\n'.
При попытке
прочитать файл иной
структуры программа зависнет.
Определение
признака конца файла (EOF)
Итак, объекты
порожденных из ios
классов содержат
флаги статуса ошибок, с по-
мощью
которых можно проверить результат
выполнения операций. При чтении
файла
небольшими порциями, как в этом примере,
мы рано или поздно наткнем-
ся на
условие окончания файла. Сигнал EOF
посылается в
программу операцион-
ной системой,
когда больше нет данных для чтения. В
программе ILINE
это усло-
вие
встречалось в выражении
while(!infile.eof())
//
Пока не EOF
Это все замечательно,
но надо учитывать, что, проверяя
конкретный флаг при-
знака окончания
файла, мы не проверяем все остальные
флаги ошибок. A
failbit
и
badbit
тоже могут
возникнуть при работе программы, хотя
это случается до-
вольно редко. Чтобы
проверять все, что можно, мы изменим
условие цикла:
while(infile.good())
//
Пока нет ошибок
Можно также проверять
поток напрямую. Любой потоковый объект,
напри-
мер infile,
имеет значение,
которое может тестироваться на предмет
выявления
наиболее распространенных
ошибок, включая EOF.
Если какое-либо
из условий
ошибки имеет значение
true,
объект возвращает
ноль. Если все идет хорошо,
объект
возвращает ненулевое значение. Это
значение на самом деле является
указателем,
но возвращаемый «адрес» никакой
смысловой нагрузки не несет —
он
просто должен быть нулем либо не нулем.
Поэтому запишем еще один вари-
ант
цикла while:
while(infile) //
Пока нет ошибок
На вид это выражение, конечно, очень
простое, но непосвященным, скорее
всего,
будет непонятно, что оно делает.
Ввод/вывод
символов
Функции put()
и get(),
являющиеся
методами ostream
и istream
соответственно,
могут
быть использованы для ввода и вывода
единичных символов. В программе
OCHAR
строка выводится
именно посимвольно.
Листинг
12.6.
Программа OCHAR
//
ochar.cpp
//
Посимвольный файловый вывод
#include
<fstream>
//
для файловых функций
#include
<iostream>
#include
<string>
using
namespace std;
int
main()
{
string
str = "Время
- великий учитель, но, увы, "
"оно
убивает своих учеников. Берлиоз";
ofstream
outfile("TEST.TXT");
//
Создать выходной файл
for(int
j = 0; j < str.size();
j++) //
каждый символ
outfile.put(str[j]);
//
записывать в файл
cout
<< "Файл
записан\n";
return
0;
}
В этой программе
объект ofstream
создается так
же, как в программе OLINE.
Длина
объекта класса string
по имени str
находится с
помощью метода size(),
а
символы выводятся в цикле for
функцией put().
Афоризм Гектора
Берлиоза
(композитора
XIX века)
записывается в файл TEST.TXT.
Считываем и
выводим
этот файл с помощью программы
ICHAR.
Листинг
12.7.
Программа ICHAR
//
ichar.cpp
//
Посимвольный файловый ввод
#include
<fstream>
//
для
файловых
функций
#include
<iostream>
using
namespace std;
int
main()
{
char
ch; //
символ
для
считывания
ifstream
infile("TEST.TXT");
//
входной
файл
while(infile)
//
читать до EOF или ошибки
{
infile.get(ch);
//
считать символ
cout
<< ch; //
и вывести его
}
cout
<< endl;
return
0;
}
В этой программе
используется функция get().
Чтение
производится до при-
знака окончания
файла (или
возникновения ошибки).
Каждый прочитанный
символ выводится
с помощью cout,
поэтому на
экран в результате работы про-
граммы
будет выведен весь афоризм.
Есть и другой способ
читать символы из файла — использовать
функцию
rdbuf()
(она
является методом класса ios).
Функция
возвращает указатель на
объект
класса streambuf
(или
filebuf),
ассоциированный
с потоковым объектом.
В этом объекте
находится буфер символов, считанных
из потока, поэтому мож-
но использовать
указатель на него в качестве объекта
данных.
Листинг
12.8.
Программа ICHAR2
//
ichar2.cpp
//
Файловый ввод символов
#include
<fstream>
//
для
файловых
функций
#include
<iostream>
using
namespace std;
int
main()
{
ifstream
infile("TEST.TXT");
//
создать
входной
файл
cout
<< infile.rdbuf();
//
передать его буфер в cout
cout
<< endl;
return
0;
}
Результат работы
этой программы совпадает с ICHAR.
Можно взять с
полки
пирожок за написание самой
короткой программы чтения из файла.
Обратите
внимание на
то, что функция rdbuf()
сама знает, что
следует прекратить работу
при
достижении EOF.
Двоичный
ввод/вывод
Форматированный
файловый ввод/вывод
чисел целесообразно использовать
только
при их небольшой величине и малом
количестве. В противном случае,
конечно,
гораздо эффективнее использовать
двоичный ввод/вывод,
при котором
числа хранятся таким же
образом, как в ОП компьютера, а не в виде
символьных
строк. Целочисленные
значения занимают 4 байта, тогда как
текстовая версия
числа, например
«12345», занимает 5 байтов. Значения типа
float
также
всегда
занимают 4 байта. А форматированная
версия «6.02314e13»
занимает 10 байтов.
В следующем примере
показано, как в бинарном виде массив
целых чисел запи-
сывается в файл и
читается из него. При этом используются
две функции — write()
(метод
класса ofstream),
а также read()
(метод
ifstream).
Эти функции
думают о дан-
ных в терминах байтов
(тип
char).
Им все равно,
как организованы данные, что они
собой
представляют, — они просто переносят
байты из буфера в файл и обратно.
Параметрами
этих функций являются адрес буфера и
его длина. Адрес должен
быть вычислен
с использованием reinterpret_cast
относительно
типа char*.
Вторым
параметром
является длина в байтах (а
не число элементов данных в буфере).
Листинг
12.9.
Программа BINIO
//
binio.cpp
//
Двоичный ввод/вывод целочисленных
данных
#include
<fstream>
//
для
файловых
потоков
#include
<iostream>
using
namespace std;
const
int
MAX = 100; //
размер
буфера
int
buff[MAX]; //
буфер для целых чисел
int
main()
{
for(int
j = 0; j < MAX; j++) //
заполнить буфер данными
buff[j]
= j; //
(0, 1, 2, ...)
Листинг
12.9 (продолжение)
//
создать выходной поток
ofstream
os("edata.dat",
ios::binary);
//
записать
в
него
os.write(reinterpret_cast<char*>(buff),
MAX*sizeof(int));
os.close();
//
должен закрыть его
for(j
= 0; j < MAX; j++) //
стереть буфер
buff[j]
= 0;
//
создать
входной
поток
ifstream
is("edata.dat",
ios::binary);
//
читать
из
него
is.read(reinterpret_cast<char*>(buff),
MAX*sizeof(int));
for(j
= 0; j < MAX; j++) //
проверка данных
if(buff[j]
!= j)
{
cerr
<< "Некорректные
данные!\n";
return
1; }
cout
<< "Данные
корректны\n";
return
0;
}
При работе с
бинарными данными в качестве второго
параметра write()
и read()
следует
использовать ios::binary.
Это необходимо
по той причине, что текстовый
режим,
используемый по умолчанию, допускает
несколько вольное обращение
с
данными. Например, специальный символ
'\n'
занимает два байта (на
самом
деле это и есть два действия
— перевод каретки и перевод строки).
Это делает
текст более удобным для
чтения в DOS
утилитами типа
TYPE,
но для
бинарных
данных такой подход не
годится вовсе, так как любой байт,
которому не повезло
иметь ASCII-код
10, переводится двумя байтами. Аргумент
ios::binary
— типичный
пример
бита состояния.
Мы еще будем говорить об этом при
обсуждении функ-
ции ореn()
немного позднее в этой главе.
Оператор
reinterpret_cast
Программа BINIO
(как
и многие последующие)
использует оператор reinterpret_
cast
для того, чтобы
буфер данных типа int
выглядел для
функций read()
и write()
как
буфер типа char.
is.read(reinterpret_cast<char*>(buff),
MAX*sizeof(int));
reinterpret_cast
Kaк
бы говорит
компилятору: «Я знаю, что тебе это не
понравится,
и все-таки я это сделаю».
Он изменяет тип данных в определенной
области па-
мяти, совершенно не
задумываясь о том, имеет это смысл или
нет. Поэтому во-
прос целесообразности
использования этого оператора остается
целиком на со-
вести программиста.
Можно использовать
reinterpret_cast
для превращения
указателей в данные
типа int
и обратно. Это
небезопасное занятие, но порой оно
необходимо.
Закрытие
файлов
До сих пор в наших примерах не нужно
было вручную закрывать файлы —
это
делалось автоматически при
окончании работы с ними. Соответствующие
объек-
ты запускали
деструкторы и закрывали ассоциированные
файлы. Но в програм-
ме BINIO
оба потока,
входной is
и выходной os,
связаны с одним
и тем же файлом
EDATA.DAT,
поэтому первый
поток должен быть закрыт до того, как
откроется
второй. Для этого используется
функция close().
Можно запускать эту функцию каждый раз
при закрытии файла, не полага-
ясь
на деструктор потока.
Объектный
ввод/вывод
Так как C++
— это все-таки объектно-ориентированный
язык, было бы интересно
узнать, как
происходит запись объектов в дисковые
файлы и чтение из них. Сле-
дующий
пример демонстрирует этот процесс.
Класс person,
использовавшийся
ра-
нее в нескольких наших программах
(например,
в VIRTPERS,
глава 11,
раздел «Вир-
туальные функции»),
создает объекты, с которыми мы сейчас
будем работать.
Запись
объекта на диск
При записи объекта
мы обычно используем бинарный режим.
При этом на диск
записывается та же
битовая конфигурация, что хранится в
памяти. Это придает
уверенности в
том, что данные объекта будут обработаны
корректно. В приводи-
мой ниже
программе OPERS
у пользователя
запрашивается информация об объек-
те
класса person,
который потом
записывается в файл PERSON.DAT.
Листинг
12.10.
Программа OPERS
//
opers.cpp
//
Сохранение объекта в файле
#include
<fstream>
//
для
файловых
потоков
#include
<iostream>
using
namespace std;
///////////////////////////////////////////////////////////
class
person //
класс
person
{
protected:
char
name[80]; //
имя
человека
short
age; //
возраст
public:
void
getdata() //
получить данные о человеке
{
cout
<< "Введите
имя:
";
cin
>>
name;
cout
<< "Введите
возраст: ";
cin
>>
age;
}
};
///////////////////////////////////////////////////////////
int
main()
{
person
pers; //
создать
объект
pers.getdata();
//
получить данные
//
создать объект ofstream
ofstream
outfile("PERSON.DAT",
ios::binary);
//
записать
в
него
outfile.write(reinterpret_cast<char*>(&pers),
sizeof(pers));
return
0;
}
Метод getdata()
класса person
вызывается для
того, чтобы запросить у поль-
зователя
информацию, которая помещается в объект
pers.
Вот простой
пример
взаимодействия:
Введите
имя: Артур
Введите возраст: 60
Содержимое данного
объекта записывается на диск с помощью
функции write().
Для
нахождения длины данных объекта pers
используется
оператор sizeof.
Чтение
объекта с диска
Для чтения пригодится
метод read(),
что
продемонстрировано в следующем
лис-
тинге.
Листинг
12.11.
Программа IPERS
//
ipers.cpp
//
Чтение объекта из файла
#include
<fstream>
//
для
файловых
потоков
#include
<iostream>
using
namespace std;
///////////////////////////////////////////////////////////
class
person //
класс
person
{
protected:
char
name[80]; //
Имя
человека
short
age; //
его
возраст
public:
void
showData() //
вывести
данные
{
cout
<< "Имя:
"
<< name << endl;
cout
<< "Возраст:
"
<< age << endl;
}
};
///////////////////////////////////////////////////////////
int
main()
{
person
pers; //
переменная
типа
person
ifstream
infile("PERSON.DAT",
ios::binary);//
создать
поток
//
чтение
потока
infile.read(reinterpret_cast<char*>(&pers),
sizeof(pers));
pers.showData();
//
вывести
данные
return
0;
}
В результате работы
программы будет выведено на экран все
то, что было
помещено в файл PERSON.DAT
программой
OPERS:
Имя:
Артур
Возраст: 60
Совместимость
структур данных
Для корректной
работы программы чтения и записи
объектов (такие,
как OPERS
и
IPERS)
должны иметь
в виду один класс объектов. Например,
объекты класса
person
имеют длину
ровно 82 байта, из которых 80 отведено
под имя человека,
2 — под возраст в
формате short.
Если бы программы
не знали длину полей, то
одна из них
не смогла бы корректно прочитать из
файла то, что записала другая.
Несмотря на то что
классы person
в OPERS
и IPERS
имеют одинаковые
компо-
нентные данные, у них могут
быть совершенно разные методы. Скажем,
в первой
программе есть функция
getdata(),
тогда как во
второй — showData().
Не имеет
значения,
какие используются методы в классах,
— они в файл вместе с данными
не
записываются. Это для данных важен
единый формат, а разногласие между
методами
ни к каким последствиям не приводит.
Впрочем, это утверждение спра-
ведливо
только для обычных классов, в которых
не используются виртуальные
функции.
Если вы пишете в
файл и читаете объекты производных
классов, необходи-
мо соблюдать
большую осторожность. В этих объектах
есть загадочное число,
которое
ставится перед началом их области
данных в памяти. Оно помогает
идентифицировать
класс объекта при использовании
виртуальных функций.
Когда вы
записываете объект в файл, это число
записывается наряду с другими
данными.
Если меняются методы класса, идентификатор
также изменяется. Если
в классе
имеются виртуальные функции, то при
чтении объекта с теми же данны-
ми,
но другими методами возникнут большие
трудности. Отсюда мораль: класс,
использующийся
для чтения объекта, должен быть
идентичен
классу, использо-
вавшемуся при его
записи.
Можно даже не
пытаться произвести дисковый ввод/вывод
объектов, компо-
нентами которых
являются указатели. Легко догадаться,
что значения указате-
лей не будут
корректными при чтении объекта в другую
область памяти.
Ввод/вывод
множества объектов
Предыдущие программы записывали и
читали только один объект за раз. В
сле-
дующем примере в файл записывается
произвольное число объектов. Затем
они
считываются, и на экран выводится
целиком содержимое файла.
Листинг
12.12.
Программа DISKFUN
//
diskfun.cpp
//
Чтение из файла и запись нескольких
объектов
#include
<fstream>
//
для файловых потоков
#include
<iostream>
using
namespace std;
///////////////////////////////////////////////////////////
class
person //
класс person
{
protected:
char
name[80]; //
имя человека
int
age; //
его возраст
public:
void
getdata() //
получить данные о человеке
{
cout
<< "\n
Введите имя: ";
cin
>>
name;
cout
<< "
Введите возраст: ";
cin
>>
age;
}
void
showData() //
вывод данных о человеке
Листинг
12.12 (продолжение)
{
cout
<< "\n
Имя: "
<< name;
cout
<< "\n
Возраст:
"
<< age;
}
};
///////////////////////////////////////////////////////////
int
main()
{
char
ch;
person
pers; //
создать
объект
person
fstream
file; //
создать входной/выходной файл
//
открыть для дозаписи
file.open("GROUP.DAT",
ios::app
|
ios::out
|
ios::in
| ios::binary);
do
//
данные от пользователя - в файл
{
cout
<< "\nВведите
данные о человеке:";
pers.getdata();
//
получить данные
//
записать их в файл
file.write(reinterpret_cast<char*>(&pers),
sizeof(pers));
cout
<< "Продолжить
ввод (y/n)? ";
cin
>>
ch;
}
while(ch
== 'y');
//
выход
по
'n'
file.seekg(0);
//
поставить указатель на начало файла
//
считать
данные
о
первом
человеке
file.read(reinterpret_cast<char*>(&pers),
sizeof(pers));
while(!file.eof())
//
Выход по EOF
{
cout
<< "\nПерсона:";//
вывести данные
pers.showData();
//
считать данные о следующем
file.read(reinterpret_cast<char*>(&pers),
sizeof(pers));
}
cout
<< endl;
return
0;
}
Покажем пример
взаимодействия при работе программы
DISKFUN.
Предпола-
гается,
что она уже запускалась и были введены
и записаны в файл данные о
двух
персонах.
Введите
данные о человеке:
Введите
имя:Екатерина
Введите возраст:33
Продолжить
ввод (y/n)?
n
Персона:
Имя:Татьяна
Возраст:17
Персона:
Имя:Артур
Возраст:60
Персона:
Имя:Екатерина
Возраст:17
В этом примере к файлу добавляется один
объект, затем все содержимое, со-
стоящее
из трех объектов, выводится на экран.
Класс
fstream
До сих пор мы
создавали файловые объекты, предназначенные
либо для ввода,
либо для вывода. В
программе DISKFUN
сделана попытка
создать файл, который мо-
жет быть
использован одновременно как входной
и выходной. Это должен быть
объект
класса fstream,
наследник
класса iostream,
порожденного
классами istream
и
ostream,
чтобы была
возможность поддержки одновременно и
ввода, и вывода.
Функция
open()
Раньше мы создавали файловый объект и
инициализировали его таким выраже-
нием:
ofstream
outfile("TEST.TXT");
В программе DISKFUN
использован
следующий подход: одним выражением
мы
создаем файл, а другим его открываем,
используя функцию open()
(метод
класса
fstream).
Так полезно
делать, когда есть вероятность ошибки
при откры-
тии. Можно один раз создать
потоковый объект, а затем циклически
пытаться
открыть его, не ломая голову
над созданием каждый раз нового.
Биты
режимов
Мы уже встречали
бит режима ios::binary.
При написании
функции open()
исполь-
зовали еще несколько. Теперь
сведем их все вместе в табл. 12.10. Биты
режимов,
определенные в ios,
определяют
различные методы открытия потоковых
объектов.
Таблица
12.10.
Биты режимов
Бит режима |
Результат |
in |
Открытие для чтения (по умолчанию для ifstream) |
out |
Открытие для записи (по умолчанию для ofstream) |
ate |
Чтение, начиная с конца файла (AT End) |
app |
Запись, начиная с конца файла (AAPend) |
trunc |
Обрезать файл до нулевой длины, если он уже существует (TRUNCate) |
nocreate |
Не открывать несуществующий файл |
noreplace |
Не открывать для вывода существующий файл, если не установлены ate или app |
binary |
Открыть в бинарном (не текстовом) режиме |
В DISKFUN использовался бит ios::app, потому что нам требовалось сохра- нить все, что было записано в файл до этого. То есть можно записать что-нибудь в файл, завершить программу, запустить ее заново и продолжать записывать данные, сохранив при этом результаты предыдущей сессии. ios::in и ios::out мы используем потому, что хотим осуществлять одновременно и ввод, и вывод. ios::binary также необходим, потому что мы записываем бинарные объекты. Вертикальные палочки между флагами нужны для того, чтобы из битов сфор- мировалось единое целое число. При этом несколько флагов будут применяться одновременно.
За один раз в файл записывается один объект person с помощью функции write(). После окончания записи мы хотим прочитать файл целиком. Для этого нужно вначале установить указатель файла на начало. Этим занимается функ- ция seekg(), к которой мы обратимся в следующем параграфе. После этого мы уже уверены, что чтение начнется с начала файла. Затем в цикле while мы счи- тываем объект из файла и выводим его на экран.
Это продолжается до тех пор, пока не будут прочитаны все объекты класса person, — состояние, определяемое флагом ios::eofbit.
Указатели файлов
У каждого файлового объекта есть два ассоциированных с ним значения, назы- ваемые указатель чтения и указатель записи. Их также называют текущая по- зиция чтения и текущая позиция записи. Или, если так лучше для восприятия, просто текущая позиция. Эти значения определяют номер байта относительно начала файла, с которого будет производиться чтение или запись. (Слово «ука- затель» в этом контексте не следует путать с обычными указателями C++, ис- пользуемыми в качестве адресных переменных.)
Часто требуется начинать чтение файла с начала и продолжать до конца. Во время записи бывает нужно начинать с начала, удаляя существующую ин- формацию, или с конца, для чего файл следует открывать с флагом ios::app. Это действия, которые выполняются по умолчанию, и никаких дополнительных манипуляций с указателями файлов проводить не требуется. Но бывает нужно контролировать указатели вручную, чтобы иметь возможность читать и писать, начиная с произвольного места файла. Функции seekg() и tellg() позволяют уста- навливать и проверять текущий указатель чтения, а функции seekp() и tellp()— выполнять те же действия для указателя записи.
Вычисление позиции
Мы уже видели пример позиционирования указателя чтения в программе DISKFUN, где функция seekg() устанавливала его на начало файла с тем, чтобы чтение на- чиналось оттуда. Этот вариант seekg() имеет один аргумент, представляющий со- бой абсолютную позицию относительно начала файла. Начало принимается за 0, что и использовалось в DISKFUN. Это условно показано на рис. 12.4
Рис. 12.4. Функция seekg() с одним аргументом
Вычисление
сдвига
Функция seekg()
может
использоваться в двух вариантах. Первый
из них мы уже
видели — используется
аргумент для указания позиции относительно
начала
файла. Но можно использовать
эту функцию и с двумя аргументами,
первый из
которых — сдвиг относительно
определенной позиции в файле, а второй
опреде-
ляет позицию, начиная с
которой отсчитывается этот сдвиг.
Второй аргумент мо-
жет иметь три
значения: beg
означает начало
файла, cur
— текущую
позицию ука-
зателя файла, end
— это конец
файла. Например, выражение
seekp(-10.
ios::end);
установит указатель
записи за 10 байтов до конца файла. То,
как это выглядит,
условно изображено
на рис. 12.5
Рис.
12.5. Функция seekp()
с
двумя аргументами
Вот пример, в котором
используется двухаргументный вариант
seekg()
для
нахождения
конкретного объекта (человека)
класса person
в файле
GROUP.DAT
и
для вывода данных об этом человеке.
Листинг
12.13.
Программа SEEKG
//
seekg.cpp
//
Поиск конкретного объекта в файле
#include
<fstream>
//
для файловых потоков
#include
<iostream>
using
namespace std;
///////////////////////////////////////////////////////////
class
person //
класс person
{
Листинг
12.13 (продолжение)
protected:
char
name[80];
//
имя человека
int
age; //
его возраст
public:
void
getdata()
//
получить данные о человеке
{
cout
<< "\n
Введите имя: ";
cin
>>
name;
cout
<< "
Введите возраст: ";
cin
>>
age;
}
void
showData(void)
//
вывод данных о человеке
{
cout
<< "\n
Имя: "
<< name;
cout
<< "\n
Возраст: "
<< age;
}
};
///////////////////////////////////////////////////////////
int
main()
{
person
pers; //
создать объект person
ifstream
infile; //
создать входной файл
infile.open("GROUP.DAT",
ios::in
|
ios::binary);
//
открыть
//
файл
infile.seekg(0,
ios::end);
//
установить указатель на 0
//
байт от конца файла
int
endposition
= infile.tellg();
//
найти позицию
int
n = endposition / sizeof(person);
//
число человек
cout
<< "\nВ
файле "
<< n
<< "
человек(а)";
cout
<< "\nВведите
номер персоны: ";
cin
>>
n;
int
position = (n - 1) * sizeof(person);//
умножить размер
//
данных под персону на число персон
infile.seekg(position);
//
число байт от начала
//
прочитать одну персону
infile.read(reinterpret_cast<char*>(&pers),
sizeof(pers));
pers.showData();
//
вывести одну персону
cout
<< endl;
return
0;
}
Результат работы
программы (при
предположении, что файл GROUP.DAT
—
тот же,
что в DISKFUN):
В
файле 3 человек(а)
Введите номер
персоны: 2
Имя:
Артур
Возраст: 60
Для удобства работы
пользователя мы нумеруем объекты
(персоны),
начиная
с единицы, хотя в программе
нумерация ведется с нуля. Поэтому
персона №2 —
это второй из трех
человек, записи о которых имеются в
файле.
Функция
tellg()
Первое, что делает программа, это
вычисляет количество человек в файле.
Она
делает это установкой указателя
чтения на конец файла с помощью выражения
infile.seekg(0,
ios::end);
Функция tellg()
возвращает
текущую позицию указателя чтения.
Программа
использует ее для вычисления
длины файла в байтах. Так как длина
одной за-
писи известна, то, исходя
из общей длины файла, можно узнать,
сколько всего
объектов хранится в
файле. Результат выводится на экран.
В приведенном выше
примере работы программы пользователь
выбрал вто-
рой объект из файла.
Программа считает с помощью seekg(),
сколько
нужно
отступить от начала файла для
того, чтобы попасть на начало области
данных
выбранного объекта. Затем
она использует функцию read()
для чтения
данных,
начиная с этого места. Наконец,
функция showData()
выводит
информацию на
экран.
Обработка
ошибок файлового
ввода/вывода
В примерах, касающихся
файлового ввода/вывода,
мы до сих пор не заботились
о
возможности возникновения ошибок и
способах их обработки. В частности,
мы
предполагали, что открываемые
для чтения файлы уже существуют, а
открыва-
емые для записи — могут
быть созданы или дозаписаны. Мы также
предполага-
ли, что во время операций
чтения и записи не происходило ошибок.
В реальных
программах, конечно,
нельзя полагаться на случай, ибо если
ошибка может воз-
никнуть, то она
обязательно когда-нибудь возникнет.
Значит, нужны методы об-
работки
соответствующих ситуаций. Если вы
думаете, что файл существует, зна-
чит,
он может и не существовать. А если
считаете, что придумали уникальное
имя
файла, значит, файл с таким именем может
и существовать, и вы перезапи-
шете
своей программой нужные данные. Вероятно,
может кончиться и место на
диске,
гибкий диск окажется неисправным и т.
д.
Реагирование
на ошибки
Наша следующая
программа показывает наиболее удобный
способ обработки
ошибок. Все дисковые
операции проверяются после их выполнения.
Если воз-
никла ошибка, выводится
сообщение об этом, и программа завершает
свою рабо-
ту. Мы использовали технику,
описанную ранее, заключающуюся в
проверке
значения, возвращаемого
из объекта, и определении статуса его
ошибки. Про-
грамма открывает выходной
потоковый объект, записывает целый
массив целых
чисел единственным
вызовом write()
и закрывает
объект. Затем открывает вход-
ной
потоковый объект и считывает массив
вызовом функции read().
Листинг
12.14. Программа REWERR
//
rewerr.cpp
//
Обработка ошибок ввода/вывода
#include
<fstream>
//
для файловых потоков
#include
<iostream>
using
namespace std;
#include
<process.h>
//
для exit()
const
int
MAX = 1000;
int
buff[MAX];
int
main()
{
for(int
j = 0; j < MAX; j++)//
заполнить буфер данными
buff[j]
= j;
ofstream
os; //
создать выходной поток
//
открыть его
os.open("a:edata.dat",
ios::trunc
| ios::binary);
if(!os)
{
cerr
<< "Невозможно
открыть выходной файл\n";
exit(1);
}
cout
<< "Идет
запись...\n";
//
записать в него содержимое
//
буфера
os.write(reinterpret_cast<char*>(buff),
MAX*sizeof(int));
if(!os)
{
cerr
<< "Запись
в файл невозможна\n";
exit(1);
}
os.close();
//
надо закрыть поток
for(j
= 0; j < MAX; j++) //
очистить буфер
buff[j]
= 0;
ifstream
is; //
создать входной поток
is.open("a:edata.dat",
ios::binary);
if(!is)
{
cerr
<< "Невозможно
открыть входной файл\n";exit(1);
}
cout
<< "Идет
чтение...\n";
//
чтение файла
is.read(reinterpret_cast<char*>(buff),
MAX*sizeof(int));
if(!is)
{
cerr
<< "Невозможно
чтение файла\n";
exit(1);
}
for(j
= 0; j < MAX; j++) //
проверять данные
if(buff[j]
!= j)
{
cerr
<< "\nДанные
некорректны\n";
exit(1);
}
cout
<< "Данные
в порядке\n";
return
0;
}
Анализ
ошибок
В этом примере мы
определили наличие ошибки ввода/вывода
проверкой значе-
ния,
возвращаемого потоковым объектом.
if(!is)
//
Возникла ошибка
Здесь is
возвращает
значение указателя, если все прошло
без ошибок. В про-
тивном случае
возвращается 0. Это жесткий подход к
определению ошибок: не
имеет значения,
какая именно ошибка возникла, все ошибки
обрабатываются
одинаково. С помощью
флагов статуса ошибок ios,
тем не менее,
можно извлечь
более подробную
информацию об ошибках файлового
ввода/вывода.
Мы уже видели
некоторые из этих флагов статуса в
работе, когда обсуждали
вывод на
экран и ввод с клавиатуры. В следующем
примере показано, как мож-
но
использовать их при файловом вводе/выводе.
Листинг
12.15. Программа FERRORS
//
ferrors.cpp
//
Проверка ошибок открытия файла
#include
<fstream>
//
для файловых функций
#include
<iostream>
using
namespace std;
int
main()
{
ifstream
file;
file.open("a:test.dat");
if(!file)
cout
<< "\nНевозможно
открыть GROUP.DAT";
else
cout
<< "\nФайл
открыт без ошибок.";
cout
<< "\nfile
= "
<< file;
cout
<< "\nКод
ошибки = "
<< file.rdstate();
cout
<< "\ngood()
= "
<< file.good();
cout
<< "\neof()
= "
<< file.eof();
cout
<< "\nfail()
= "
<< file.fail();
cout
<< "\nbad()
= "
<< file.bad()
<< endl;
file.close();
return
0;
}
Вначале программа проверяет значение
файлового объекта. Если оно нуле-
вое,
значит, файл, возможно, не существует
и поэтому не может быть открыт.
Вот
результат работы программы в такой
ситуации:
Невозможно
открыть GROUP.DAT
file
=
0x1c730000
Код
ошибки = 4
good()
= 0
eof()
=
0
fail()
=
4
bad()
=
4
Код ошибки,
возвращаемый rdstate(),
равен четырем.
Это бит, который гово-
рит о том, что
файл не существует. Он устанавливается
в единицу. Остальные
биты при этом
равны нулю. Функция good()
возвращает 1
(true)
лишь в том
случае,
когда не установлены никакие биты
ошибок, поэтому в нашем примере
она
вернула 0 (false).
Указатель файла
находится не на EOF,
поэтому eof()
воз-
вращает
0. Флаги fail()
и bad()
устанавливаются
в ненулевое значение — это их
реакция
на произошедшую ошибку.
В настоящей,
серьезной программе некоторые из этих
функций должны ис-
пользоваться
после каждой операции ввода/вывода,
и тогда не останется сомне-
ний в
том, что все идет как нужно.
Файловый
ввод/вывод с помощью методов
Ранее мы сводили
все функции работы с файлами в секцию
main()
наших про-
грамм.
Но при написании сложных классов
логичнее включать операции файло-
вого
ввода/вывода
в методы класса. В этом параграфе мы
продемонстрируем две
программы, в
которых это проделано. В первой из них
используются обычные
методы, каждый
объект отвечает за запись самого себя
в файл и чтение из файла.
Вторая
показывает, как файловый ввод/вывод
всех объектов можно осущест-
вить с
помощью статических функций-членов
класса.
Как
объекты записывают и читают сами себя
Иногда имеет смысл
разрешить каждому компоненту класса
читать и записы-
вать самого себя.
Это довольно прозрачный подход и отлично
работает, если
нужно писать и читать
небольшое число объектов. В нашем
примере мы добави-
ли два метода —
diskOut()
и diskIn()
— в класс
person.
Эти функции
позволяют
объектам person
записывать
себя в файл и читать себя же из него.
Примем некоторые
упрощающие допущения. Во-первых, все
объекты будут
храниться в одном и
том же файле PERSFILE.DAT.
Во-вторых, новые
объекты всег-
да будут добавляться
к концу файла. Аргумент функции diskIn()
позволяет
читать
данные о любом человеке из
файла. Для предотвращения попыток
прочитать
данные, выходящие за
пределы файла, мы включаем в программу
статический
метод diskCount(),
возвращающий
число людей, информация о которых
хранится
в файле. При вводе данных
следует использовать только фамилии
людей, про-
белы не допускаются.
Листинг
12.16.
Программа REWOBJ
//
rewobj.cpp
//
Файловый ввод/вывод объектов person
#include
<fstream>
//
Для файловых потоков
#include
<iostream>
using
namespace std;
///////////////////////////////////////////////////////////
class
person //
класс person
{
protected:
char
name[40]; //
имя человека
int
age; //
его возраст
public:
void
getdata(void)
//
получить данные
{
cout
<< "\n
Введите фамилию: ";
cin
>>
name;
cout
<< "
Введите возраст: ";
cin
>>
age;
}
void
showData(void)
//
Вывод данных
{
cout
<< "\n
Имя: "
<< name;
cout
<< "\n
Возраст: "
<< age;
}
void
diskIn(int);
//
чтение из файла
void
diskOut();
//
запись в файл
static
int
diskCount();
//
Число человек в файле
};
//---------------------------------------------------------
void
person::diskIn(int
pn)
//
Чтение данных о числе
//
человек pn
из файла
{
ifstream
infile;
//
создать поток
infile.open("PERSFILE.DAT",
ios::binary);
//
открыть его
infile.seekg(pn*sizeof(person));
//
сдвиг
//
файлового указателя
infile.read((char*)this,
sizeof(*this));
//
чтение данных
//
об одном человеке
}
//---------------------------------------------------------
void
person::diskOut()
//
запись в конец файла
{
ofstream
outfile;
//
создать поток
//
открыть его
outfile.open("PERSFILE.DAT",
ios::app
|
ios::binary);
outfile.write((char*)this,
sizeof(*this));
//
записать в него
}
//---------------------------------------------------------
int
person::diskCount() //
число людей в файле
{
ifstream
infile;
infile.open("PERSFILE.DAT",
ios::binary);
infile.seekg(0,
ios::end);
//
перейти на позицию «0 байт
//
от конца файла»
//
вычислить количество людей
return
(int)infile.tellg()
/ sizeof(person);
}
///////////////////////////////////////////////////////////
int
main()
{
person
p;
//
создать пустую запись
char
ch;
do{
//
сохранение данных на диск
cout
<< "Введите
данные о человеке: ";
p.getdata();
//
Получить данные
p.diskOut();
//
записать на диск
cout
<< "Продолжить
(y/n)?
";
cin
>>
ch;
}
while(ch
== 'y');
//
цикл до 'n'
int
n
= person::diskCount();//
сколько людей в файле?
cout
<< "В
файле "
<< n
<< "
человек(а)\n";
for(int
j
= 0; j
< n;
j++)
//
для каждого
{
cout
<< "\nПерсона
"
<< j;
p.diskIn(j);
//
считать с диска
p.showData();
//
вывести данные
Листинг
12.16 (продолжение)
}
cout
<< endl;
return
0;
}
Здесь для вас не
должно быть новых откровений. Большинство
элементов
этой программы уже
встречались. Она работает примерно по
тому же принципу,
что и DISKFUN.
Тем не менее
имейте в виду, что все подробности
дисковых опе-
раций невидимы для
main(),
они спрятаны
внутрь класса person.
Заранее никогда
неизвестно, где находятся данные, с
которыми мы собираем-
ся работать,
так как каждый объект находится в своей
области памяти. Но указа-
тель this
всегда подскажет,
где мы находимся во время выполнения
какого-либо
метода. В потоковых
функциях read()
и write()
адрес объекта,
который будет
читаться или записываться,
равен *this,
а его размер —
sizeof(*this).
Вот результат работы программы при
предположении, что до начала ее рабо-
ты
в файле уже было две записи:
Введите
данные о человеке:
Введите имя:
Гребеньков
Введите возраст:19
Продолжить
(y/n)?
У
Введите
данные о человеке:
Введите имя:
Андреанов
Введите возраст:20
Продолжить
(y/n)?
N
Персона
#1
Имя:Ершова
Возраст:21
Персона
#2
Имя:Малахова
Возраст:20
Персона
#3
Имя:Гребеньков
Возраст:19
Персона
#4
Имя:Андреанов
Возраст:
20
Чтобы пользователь
мог ввести собственное имя файла, вместо
жесткого закре-
пления его в программе,
как мы делали в предыдущих примерах,
следует создать
статическую
компонентную переменную (например,
charfileName[]),
а также
ста-
тическую функцию для ее установки.
Можно сделать и по-другому: каждый
объ-
ект записывать в свой файл. Для
этого понадобится нестатическая
функция.
Как
классы записывают и читают сами себя
Предположим, что в памяти хранится
большое число объектов, и все их
нужно
записать в файлы. Недостаточно
иметь для каждого из них метод, который
от-
кроет файл, запишет в него объект,
потом закроет файл, как было в предыдущем
примере. Гораздо быстрее и логичнее в
такой ситуации открыть файл, записать
в
него все объекты, которые этого
хотят, потом закрыть файл.
Статические
функции
Одним из способов
записать за один сеанс множество
объектов является упот-
ребление
статической функции, которая применяется
ко всему классу в целом,
а не к
отдельным его объектам. Такая функция
действительно может записать
все
объекты сразу. Но как она узнает, где
находятся объекты? Она обратится
к
массиву указателей на объекты,
который можно хранить в виде статической
пе-
ременной. При создании каждого
объекта его указатель заносится в этот
массив.
Статический элемент данных
также может свято хранить память о том,
сколько
всего объектов было создано.
Статическая функция write()
откроет файл,
в цикле
пройдет по всем ссылкам
массива, записывая по очереди все
объекты, и после
окончания записи
закроет файл.
Размеры
порожденных объектов
Чтобы жизнь медом
не казалась, давайте сделаем следующее
предположение:
объекты, хранящиеся
в памяти, имеют разные размеры. Почему
и когда такое
бывает? Типичной
предпосылкой этого является создание
порожденных клас-
сов. Например,
рассмотрим программу EMPLOY
из главы 9
«Наследование». Там
у нас был класс
employee,
выступавший
как базовый для классов manager,
scientist
и
laborer.
Объекты этих
трех порожденных классов имеют разные
размеры, так
как содержат разные
объемы данных. Например, в дополнение
к имени и поряд-
ковому номеру, которые
присущи всем работникам, у менеджера
есть еще такие
поля данных, как
должность и членские взносы гольф-клуба,
а у ученого есть по-
ле
данных, содержащее количество его
публикаций.
Нам хотелось бы
записать данные из списка, содержащего
все три типа по-
рожденных объектов,
используя простой цикл и метод write()
класса
ofstream.
Но
нам нужно знать размеры объектов, чтобы
передать их в качестве второго
аргумента
этой функции.
Пусть имеется
массив указателей arrар[],
хранящий ссылки на объекты типа
employee.
Указатели могут
ссылаться, таким образом, и на все три
порожденных
класса (см.
программу VIRTPERS
из главы 11,
там тоже имеется массив указате-
лей
на объекты порожденных классов).
При использовании виртуальных функ-
ций
можно использовать выражения типа
arrap[]->putdata();
Тогда будет
поставлена на исполнение во время
работы программы версия
putdata(),
соответствующая
объекту, на который ссылается указатель,
а не та,
что соответствует базовому
классу. Можно ли использовать sizeof()
для вычис-
ления
размера ссылочного аргумента? То есть
можно ли написать, например,
такое
выражение:
ouf.write((char*)arrap[j],
sizeof(*arrap[j]));
//
плохо это
Увы, нельзя, потому
как sizeof()
не является
виртуальной функцией. Она не
в курсе,
что нужно обращаться к типу объекта,
на который ссылается указатель,
а не на тип самого указателя. Эта функция
всегда будет возвращать размер объ-
екта
базового класса.
Использование
функции typeid()
И все-таки, как же
нам найти размер объекта, если все, что
мы имеем, это указа-
тель на него?
Одним из решений является, несомненно,
функция typeid(),
пред-
ставленная
в главе 11. Можно использовать ее для
определения класса объекта,
подставляя
имя этого класса в качестве аргумента
sizeof().
Чтобы
использовать
typeid(),
надо включить
параметр компилятора
RTTI.
(это
существенно только
для компилятора
Microsoft
Visual
C++,
см. приложение В «Microsoft
Visual
C++»).
Наш следующий
пример показывает, как все вышеописанное
работает. Узнав
размер объекта, мы
можем использовать его в функции write()
для записи в
файл.
К программе EMPLOY
добавился
несложный пользовательский
интерфейс.
Некоторые специфические
методы сделаны виртуальными, чтобы
можно было
пользоваться массивом
указателей на объекты. В программу
также включены
некоторые приемы
обнаружения ошибок, описанные в
предыдущем параграфе.
Программа получилась
довольно претенциозной, но, тем не
менее, она дей-
ствительно демонстрирует
многие приемы, которые могут быть
использованы
в настоящем приложении
для работы с базами данных. Она также
показывает
реальные возможности
ООП. Что бы мы делали без него? Как бы
смогли с помо-
щью одного выражения
записывать в файл объекты разных
размеров? Приводим
листинг программы
EMPL_IO
и рекомендуем
вникнуть в каждую строчку кода.
Листинг
12.17.
Программа EMPL_IO
//
empl_io.cpp
//
Файловый ввод/вывод объектов employee
//
Поддержка объектов неодинаковых
размеров
#include
<fstream>
//
для потоковых файловых функций
#include
<iostream>
#include
<typeinfo>
//
для typeid()
using
namespace std;
#include
<process.h>
//
для exit()
const
int
LEN = 32; //
Максимальная длина фамилий
const
int
MAXEM = 100; //
максимальное число работников
enum
employee_type { tmanager,
tscientist,
tlaborer
};
///////////////////////////////////////////////////////////
class
employee
//
класс employee
{
private:
char
name[LEN]; //
фамилия работника
unsigned
long
number; //
номер работника
static
int
n; //
текущее число работников
static
employee* arrap[]; //
массив указателей на класс работников
public:
virtual
void
getdata()
{
cin.ignore(10,
'\n');
cout
<< "
Введите фамилию: ";
cin
>>
name;
cout
<< "
Введите
номер:
";
cin
>>
number;
}
virtual
void
putdata()
{
cout
<< "\n
Фамилия:
"
<< name;
cout
<< "\n
Номер:
"
<< number;
}
virtual
employee_type get_type(); //
получить
тип
static
void
add(); //
добавить работника
static
void
display(); //
вывести данные обо всех
static
void
read();
//
чтение из файла
static
void
write();
//
запись в файл
};
//---------------------------------------------------------
//
статические переменные
int
employee::n; //
текущее число работников
employee*
employee::arrap[MAXEM]; //
массив указателей на класс работников
///////////////////////////////////////////////////////////
//
класс
manager (менеджеры)
class
manager : public
employee
{
private:
char
title[LEN]; //
титул
("вице-президент"
и
т.
п.)
double
dues; //
Налоги
гольф-клуба
public:
void
getdata()
{
employee::getdata();
cout
<< "
Введите
титул:
";
cin
>>
title;
cout
<< "
Введите налоги: ";
cin
>>
dues;
}
void
putdata()
{
employee::putdata();
cout
<< "\n
Титул:
"
<< title;
cout
<< "\n
Налоги гольф-клуба: "
<< dues;
}
};
///////////////////////////////////////////////////////////
//
класс
scientist (ученые)
class
scientist : public
employee
{
private:
int
pubs; //
число
публикаций
public:
void
getdata()
{
employee::getdata();
cout
<< "
Введите
число
публикаций:
";
cin
>>
pubs;
}
void
putdata()
{
employee::putdata();
cout
<< "\n
Число
публикаций:
"
<< pubs;
}
};
Листинг
12.17
(продолжение)
///////////////////////////////////////////////////////////
//
класс laborer (рабочие)
class
laborer : public
employee
{
};
///////////////////////////////////////////////////////////
//
добавить работника в список (хранится
в ОП)
void
employee::add()
{
char
ch;
cout
<< "'m'
для добавления менеджера"
"\n's'
для добавления ученого"
"\n'l'
для добавления рабочего"
"\nВаш
выбор: ";
cin
>>
ch;
switch(ch)
{
//
создать объект указанного типа
case
'm':
arrap[n] = new
manager;
break;
case
's':
arrap[n] = new
scientist; break;
case
'l':
arrap[n] = new
laborer;
break;
default:
cout
<< "\nНеизвестный
тип работника\n";
return;
}
arrap[n++]->getdata();
//
Получить данные от пользователя
}
//---------------------------------------------------------
//
Вывести данные обо всех работниках
void
employee::display()
{
for(int
j = 0; j < n; j++)
{
cout
<< (j
+
1);
//
вывести номер
switch(arrap[j]->get_type())
//
вывести тип
{
case
tmanager:
cout
<< ".
Тип: Менеджер";
break;
case
tscientist:
cout
<< ".
Тип: Ученый";
break;
case
tlaborer:
cout
<< ".
Тип: Рабочий";
break;
default:
cout
<< ".
Неизвестный тип";
}
arrap[j]->putdata();
//
Вывод данных
cout
<< endl;
}
}
//---------------------------------------------------------
//
Возврат типа объекта
employee_type
employee::get_type()
{
if(typeid(*this)
== typeid(manager))
return
tmanager;
else
if(typeid(*this)
== typeid(scientist))
return
tscientist;
else
if(typeid(*this)
== typeid(laborer))
return
tlaborer;
else
{
cerr
<< "\nНеправильный
тип работника";
exit(1);
}
return
tmanager;
}
//---------------------------------------------------------
//
Записать все объекты, хранящиеся в
памяти, в файл
void
employee::write()
{
int
size;
cout
<< "Идет
запись "
<< n << "
работников.\n";
ofstream
ouf; //
открыть ofstream в двоичном виде
employee_type
etype; //
тип
каждого
объекта
employee
ouf.open("EMPLOY.DAT",
ios::trunc
| ios::binary);
if(!ouf)
{ cout
<< "\nНевозможно
открыть
файл\n";
return;
}
for(int
j = 0; j < n; j++) //
Для каждого объекта
{
//
получить его тип
etype
= arrap[j]->get_type();
//
записать данные в файл
ouf.write((char*)&etype,
sizeof(etype));
switch(etype)
//
find its size
{
case
tmanager:
size = sizeof(manager);
break;
case
tscientist:
size = sizeof(scientist);
break;
case
tlaborer:
size = sizeof(laborer);
break;
}
//
запись
объекта
employee в
файл
ouf.write((char*)(arrap[j]),
size);
if(!ouf)
{ cout
<< "\nЗапись
в
файл
невозможна\n";
return;
}
}
}
//---------------------------------------------------------
//
чтение всех данных из файла в память
void
employee::read()
{
int
size; //
размер
объекта
employee
employee_type
etype; //
тип
работника
ifstream
inf; //
открыть
ifstream в
двоичном
виде
inf.open("EMPLOY.DAT",
ios::binary);
if(!inf)
{ cout
<< "\nНевозможно
открыть
файл\n";
return;
}
n
= 0; //
В памяти работников нет
while(true)
{
//
чтение типа следующего работника
inf.read((char*)&etype,
sizeof(etype));
if(inf.eof())
//
выход из цикла по EOF
break;
if(!inf)
//
ошибка чтения типа
{ cout
<< "\nНевозможно
чтение типа\n";
return;
}
switch(etype)
{
//
создать нового работника
case
tmanager:
//
корректного типа
arrap[n]
= new
manager;
size
= sizeof(manager);
break;
case
tscientist:
arrap[n]
= new
scientist;
size
= sizeof(scientist);
break;
Листинг
12.17
(продолжение)
case
tlaborer:
arrap[n]
= new
laborer;
size
= sizeof(laborer);
break;
default:
cout
<< "\nНеизвестный
тип в файле\n";
return;
}
//
чтение данных из файла
inf.read((char*)arrap[n],
size);
if(!inf)
//
ошибка, но не EOF
{ cout
<< "\nЧтение
данных из файла невозможно\n";
return;
}
n++;
//
счетчик работников увеличить
}
//
end
while
cout
<< "Идет
чтение "
<< n
<< "
работников\n";
}
///////////////////////////////////////////////////////////
int
main()
{
char
ch;
while(true)
{
cout
<< "'a'
- добавление сведений о работнике"
"\n'd'
- вывести сведения обо всех работниках"
"\n'w'
- записать все данные в файл"
"\n'r'
- прочитать все данные из файла"
"\n'x'
- выход"
"\nВаш
выбор: ";
cin
>>
ch;
switch(ch)
{
case
'a':
//
добавить работника
employee::add();
break;
case
'd':
//
вывести
все
сведения
employee::display();
break;
case
'w':
//
запись в файл
employee::write();
break;
case
'r':
//
чтение всех данных из файла
employee::read();
break;
case
'x':
exit(0);
//
выход
default:
cout
<< "\nНеизвестная
команда";
}
//
end switch
}
//
end while
return
0;
}
Код
типа объекта
Мы умеем определять
класс объекта, находящегося в памяти,
но как узнать
класс объекта, если мы
собираемся читать его из файла? Никакой
волшебной па-
лочки в виде специальной
функции на этот случай не предусмотрено.
Поэтому
при записи данных на диск
необходимо записывать код (перечисляемую
пере-
менную типа employee_type)
прямо перед
данными объекта. До начала чтения
из
файла надо прочитать его значение
и создать объект соответствующего
типа.
И только после этого можно
копировать данные из файла в этот новый
объект.
И
никаких кустарных объектов, пожалуйста!
В голову иного
программиста может прийти идея считывать
данные объекта
просто «куда-нибудь»,
например в массив типа char,
а затем
устанавливать указа-
тель на этот
массив.
char
someArray[MAX];
aClass*
aPtr_to_obj;
aPtr_to_obj
=
reinterpret_cast<aClass*>(someArray);
//
Никогда
так
не
делайте!
Такой сделанный на коленке объект не
будет создан. И попытки работать
с
указателем, делая вид, что он ссылается
на него, ни к чему хорошему не при-
ведут.
Есть только два легитимных пути создать
объект. Можно определить его
вручную,
тогда он будет создан на этапе компиляции:
aClass
anObj;
Либо, если вы хотите,
чтобы объект создавался в процессе
работы програм-
мы, используйте new
и ассоциируйте
его адрес с указателем:
aptr_to_obj
= new
aClass;
При корректном способе создания объекта
запускается его конструктор. Это
необходимо
даже тогда, когда вы не определяете
собственный, а используете
конструктор
по умолчанию. Ведь объект — это нечто
более глобальное, нежели
просто
область памяти, в которой хранятся
данные. Не забывайте, что это еще и
набор
методов, некоторые из них вы даже не
видите!
Взаимодействие
с программой EMPL_IO
Вот пример
взаимодействия пользователя с нашей
программой. Напоминаем,
что в памяти
у нас созданы объекты классов manager,
scientist
и laborer.
Мы запи-
сываем
их на диск, затем считываем и выводим
на экран. Для простоты названия
из
нескольких слов мы использовать не
будем.
'a'
- добавление сведений о работнике
'd'
- вывести сведения обо всех работниках
'w'
- записать все данные в файл
'r'
- прочитать все данные из файла
'x'
- выход
Ваш
выбор: а
'm'
для добавления менеджера
's'
для добавления ученого
'l'
для добавления рабочего
Ваш выбор:
m
Введите
фамилию: Александров
Введите
номер:1111
Введите титул президент
Введите
налоги:20000
'a' - добавление
сведений о работнике
'd' - вывести
сведения обо всех работниках
'w' - записать
все данные в файл
'r' - прочитать
все данные из файла
