Добавил:
Upload Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз: Предмет: Файл:
Лафоре Р. - Объектно-ориентированное программир...doc
Скачиваний:
154
Добавлен:
01.04.2025
Размер:
41 Мб
Скачать
☆

Глава 12

Потоки и файлы

  • Потоковые классы

  • Ошибки потоков

  • Потоковый ввод/вывод дисковых файлов

  • Указатели файлов

  • Обработка ошибок файлового ввода/вывода

  • Файловый ввод/вывод с помощью методов

  • Перегрузка операций извлечения и вставки

  • Память как поток

  • Аргументы командной строки

  • Вывод на печатающее устройство

Эта глава посвящена потоковым классам в C++. Мы начнем с иерархии, в соот- ветствии с которой организуются эти классы, и сведем вместе знания обо всех их важных особенностях. Наибольшее внимание в главе уделено тому, чтобы пока- зать, как выполняются действия, связанные с файлами, с использованием пото- ков. Мы покажем, как выполняется чтение и запись файлов различными спосо- бами, как обрабатывать ошибки ввода/вывода, как связано ООП с файлами. Затем мы рассмотрим некоторые другие особенности C++, связанные с файла- ми, включая форматирование текста «в памяти» (файл «в памяти» ведет себя, как дисковый, хотя находится в оперативной памяти), работу с аргументами ко- мандной строки, перегрузку операторов вставки и извлечения, посылку данных на принтер.

Потоковые классы

Поток — это общее название, как ни странно, потока данных. В C++ поток пред- ставляет собой объект некоторого класса. Именно поэтому вы могли встретить в листингах потоковые объекты cin и cout. Разные потоки предназначены для

представления разных видов данных. Например, класс 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' - прочитать все данные из файла