8.1. Классы ввода-вывода.

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

Для поддержки столь разных видов обработки ввода-вывода, кроме уже использованных ранее типов istream и ostream, библиотека определяет целую коллекцию типов ввода-вывода. Эти типы (табл. 8.1) определены в трех отдельных заголовках: заголовок iostream определяет базовые типы, используемые для чтения и записи в поток, заголовок fstream определяет типы, используемые для чтения и записи в именованные файлы, заголовок sstream определяет типы, используемые для чтения и записи в строки, расположенные в оперативной памяти.

Таблица 8.1. Типы и заголовки библиотеки ввода-вывода 

Заголовок	Тип
iostream	istream, wistream — читают данные из потока
ostream, wostream — записывают данные в поток
iostream, wiostream — читают и записывают данные в поток
fstream	ifstream, wifstream — читают данные из файла
оfstrеаm, wofstream — записывают данные в файл
fstream, wfstream — читают и записывают данные в файл
sstream	istringstream, wistringstream — читают данные из строки
ostringstream, wostringstream — записывают данные в строку
stringstream, wstringstream — читают и записывают данные в строку

Для поддержки языков, использующих расширенные символы, библиотека определяет набор типов и объектов, манипулирующих данными типа wchar_t (см. раздел 2.1.1). Имена версий для расширенных символов начинаются с буквы w. Например, объекты wcin, wcout и wcerr соответствуют обычным объектам cin, cout и cerr, но для расширенных символов. Такие объекты определяются в том же заголовке, что и типы для обычных символов. Например, заголовок fstream определяет типы ifstream и wifstream.

Взаимоотношения между типами ввода и вывода.

Концептуально ни вид устройства, ни размер символов не влияют на операции ввода-вывода. Например, оператор >> можно использовать для чтения данных из окна консоли, из файла на диске или из строки. Точно так же этот оператор можно использовать независимо от того, читаются ли символы типа char или wchar_t.

Используя наследование (inheritance), библиотека позволяет игнорировать различия между потоками различных видов. Подобно шаблонам (см. раздел 3.3), связанные наследованием классы можно использовать, не вникая в детали того, как они работают. Более подробная информация о наследовании в языке С++ приведена в главе 15 и в разделе 18.3.

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

Типы ifstream и istringstream происходят от класса istream. Таким образом, объект типа ifstream или istringstream можно использовать так, как будто это объект класса istream. Объекты этих типов можно использовать теми же способами, что и объект cin. Например, можно вызвать функцию getline() объекта ifstream или istringstream либо использовать их оператор >> для чтения данных. Точно так же типы ofstream и ostringstream происходят от класса ostream. Следовательно, объекты этих типов можно использовать теми же способами, что и объект cout.

Все, что рассматривается в остальной части этого раздела, одинаково применимо как к простым, файловым и строковым потокам, а также к потокам для символов типа char или wchar_t.

8.1.1. Объекты ввода-вывода не допускают копирования и присвоения.

Как упоминалось в разделе 7.1.3, объекты ввода-вывода не допускают копирования и присвоения:

ofstream out1, out2;

out1 = out2;        // ошибка: нельзя присваивать потоковые объекты

ofstream print(ofstream); // ошибка: нельзя инициализировать параметр

                          // типа ofstream

out2 = print(out2); // ошибка: нельзя копировать потоковые объекты

Поскольку объекты типа ввода-вывода нельзя копировать, не может быть параметра или типа возвращаемого значения одного из потоковых типов (см. раздел 6.2.1). Функции, осуществляющие ввод-вывод, получают и возвращают поток через ссылки. Чтение или запись в объект ввода-вывода изменяет его состояние, поэтому ссылка не должна быть константой.

8.1.2. Флаги состояния.

В связи с наследованием классов ввода-вывода возможно возникновение ошибок. Некоторые из ошибок исправимы, другие происходят глубоко в системе и не могут быть исправлены в области видимости программы. Классы ввода-вывода определяют функции и флаги, перечисленные в табл. 8.2, позволяющие обращаться к флагам состояния (condition state) потока и манипулировать ими.

Таблица 8.2. Флаги состояния библиотеки ввода-вывода

strm::iostate	strm — один из типов ввода-вывода, перечисленных в табл. 8.1. iostate — машинно-зависимый целочисленный тип, представляющий флаг состояния потока
strm::badbit	Значение флага strm::iostate указывает, что поток недопустим
strm::failbit	Значение флага strm::iostate указывает, что операция ввода- вывода закончилась неудачей
strm::eofbit	Значение флага strm::iostate указывает, что поток достиг конца файла
strm::goodbit	Значение флага strm::iostate указывает, что поток не находится в недопустимом состоянии. Это значение гарантированно будет нулевым
s.eof()	Возвращает значение true, если для потока s установлен флаг  eofbit
s.fail()	Возвращает значение true, если для потока s установлен флаг  failbit
s.bad()	Возвращает значение true, если для потока s установлен флаг  badbit
s.good()	Возвращает значение true, если поток s находится в допустимом состоянии
s.clear()	Возвращает все флаги потока s в допустимое состояние
s.clear(флаг)	Устанавливает определенный флаг (флаги) потока s в допустимое состояние. Флаг имеет тип strm::iostate
s.setstate(флаг)	Добавляет в поток s определенный флаг. Флаг имеет тип  strm::iostate
s.rdstate()	Возвращает текущее состояние потока s как значение типа  strm::iostate

В качестве примера ошибки ввода-вывода рассмотрим следующий код:

int ival;

cin >> ival;

Если со стандартного устройства ввода ввести, например, слово Boo, то операция чтения потерпит неудачу. Оператор ввода ожидал значение типа int, но получил вместо этого символ В. В результате объект cin перешел в состояние ошибки. Точно так же объект cin окажется в состоянии ошибки, если ввести символ конца файла.

Как только произошла ошибка, последующие операции ввода-вывода в этом потоке будут терпеть неудачу. Читать или писать в поток можно только тогда, когда он находится в неошибочном состоянии. Поскольку поток может оказаться в ошибочном состоянии, код должен проверять его, прежде чем использовать. Проще всего определить состояние потокового объекта — это использовать его в условии:

while (cin >> word)

 // ok: операция чтения успешна ...

Условие оператора while проверяет состояние потока, возвращаемого выражением >>. Если данная операция ввода успешна, состояние остается допустимым и условие выполняется.

Опрос состояния потока.

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

Библиотека ввода-вывода определяет машинно-зависимый целочисленный тип iostate, используемый для передачи информации о состоянии потока. Этот тип используется как коллекция битов, подобно переменной quiz1 в разделе 4.8. Классы ввода-вывода определяют четыре значения constexpr (разделе 2.4.4) типа iostate, представляющие конкретные битовые схемы. Эти значения используются для указания конкретных видов состояний ввода-вывода. Они используются с побитовыми операторами (см. раздел 4.8) для проверки или установки нескольких флагов за раз.

Флаг badbit означает отказ системного уровня, такой как неисправимая ошибка при чтении или записи. Как только флаг badbit установлен, использовать поток обычно больше невозможно. Флаг failbit устанавливается после исправимой ошибки, такой как чтение символа, когда ожидались числовые данные. Как правило, такие проблемы вполне можно исправить и продолжить использовать поток. Достижение конца файла устанавливает флаги и eofbit и failbit. Флаг goodbit, у которого гарантированно будет значение 0, не означает отказа в потоке. Если любой из флагов badbit, failbit или eofbit будет установлен, то оценивающее данный поток условие окажется ложным.

Библиотека определяет также набор функций для опроса состояния этих флагов. Функция good() возвращает значение true, если ни один из флагов ошибок не установлен. Функции bad(), fail() и eof() возвращает значение true, когда установлен соответствующий бит. Кроме того, функция fail() возвращает значение true, если установлен флаг badbit. Корректный способ определения общего состояния потока подразумевал бы использование функции good() или fail(). На самом деле код проверки потока в условии эквивалентен вызову !fail(). Функции bad() и eof() оповещают только о конкретной ошибке.

Управление флагами состояния.

Функция-член rdstate() возвращает значение типа iostate, соответствующее текущему состоянию потока. Функция setstate() позволяет установить указанные биты состояния, чтобы указать возникшую проблему. Функция clear() перегружена (см. раздел 6.4): одна ее версия не получает никаких аргументов, а вторая получает один аргумент типа iostate.

Версия функции clear(), не получающая никаких аргументов, сбрасывает все биты отказа. После ее вызова функция good() возвращает значение true. Эти функции-члены можно использовать следующим образом:

// запомнить текущее состояние объекта cin

auto old_state = cin.rdstate();

cin.clear();             // сделать объект cin допустимым

process_input(cin);      // использовать объект cin

cin.setstate(old_state); // вернуть объект cin в прежнее состояние

Версия функции clear(), получающая аргумент, ожидает значение типа iostate, представляющее новое состояние потока. Для сброса отдельного флага используется функция-член rdstate() и побитовые операторы, позволяющие создать новое желаемое состояние.

Например, следующий код сбрасывает биты failbit и badbit, а бит eofbit оставляет неизменным:

// сбросить биты failbit и badbit, остальные биты оставить неизменными

cin.clear(cin.rdstate() & ~cin.failbit & ~cin.badbit);

Упражнения раздела 8.1.2.

Упражнение 8.1. Напишите функцию, получающую и возвращающую ссылку на объект класса istream. Функция должна читать данные из потока до тех пор, пока не будет достигнут конец файла. Функция должна выводить прочитанные данные на стандартное устройство вывода. Перед возвращением потока верните все значения его флагов в допустимое состояние.

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

Упражнение 8.3. В каких случаях завершится следующий цикл while?

while (cin >> i) /* ... */

8.1.3. Управление буфером вывода.

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

os << "please enter a value: ";

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

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

• Программа завершается нормально. Все буфера вывода освобождаются при выходе из функции main().

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

• Сброс буфера можно осуществить явно, использовав такой манипулятор, как endl (см. раздел 1.2).

• Используя манипулятор unitbuf, можно установить такое внутреннее состояние потока, чтобы буфер освобождался после каждой операции вывода. Для объекта cerr манипулятор unitbuf установлен по умолчанию, поэтому запись в него приводит к немедленному выводу.

• Поток вывода может быть связан с другим потоком. В таком случае буфер привязанного потока сбрасывается при каждом чтении или записи другого потока. По умолчанию объекты cin и cerr привязаны к объекту cout. Следовательно, чтение из потока cin или запись в поток cerr сбрасывает буфер потока cout.

Сброс буфера вывода.

В приведенных ранее программах уже не раз использовался манипулятор endl, который записывает символ новой строки и сбрасывает буфер. Существуют еще два подобных манипулятора: flush и ends. Манипулятор flush используется для сброса буфер потока без добавления символов в вывод. Манипулятор ends добавляет в буфер нулевой символ, а затем сбрасывает его.

cout << "hi!" << endl;  // выводит hi, новую строку и сбрасывает буфер

cout << "hi!" << flush; // выводит hi и сбрасывает буфер, ничего не

                        // добавляя

cout << "hi!" << ends;  // выводит hi, нулевой символ

                        // и сбрасывает буфер

Манипулятор unitbuf.

Если сброс необходим при каждом выводе, лучше использовать манипулятор unitbuf, который сбрасывает буфер потока после каждой записи. Манипулятор nounitbuf восстанавливает для потока использование обычного управляемого системой сброса буфера:

cout << unitbuf;   // при любой записи буфер будет сброшен немедленно

// любой вывод сбрасывается немедленно, без всякой буферизации

cout << nounitbuf; // возвращение к обычной буферизации

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

Связывание потоков ввода и вывода.

Когда поток ввода связан с потоком вывода, любая попытка чтения данных из потока ввода приведет к предварительному сбросу буфера, связанного с потоком вывода. Библиотечные объекты cout и cin уже связаны, поэтому оператор cin >> ival; заставит сбросить буфер, связанный с объектом cout.

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

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

Вторая версия функции tiе() получает указатель на объект класса ostream и связывает себя с ним. Таким образом, код x.tie(&o) связывает поток x с потоком вывода o.

Объект класса istream или ostream можно связать с другим объектом класса ostream:

cin.tie(&cout); // только для демонстрации: библиотека

                // автоматически связывает объекты cin и cout

// old_tie указывает на поток (если он есть),

// в настоящее время связанный с объектом cin

ostream *old_tie = cin.tie(nullptr); // объект cin больше не связан

// связь cin и cerr; не лучшая идея, поскольку объект cin должен быть

// привязан к объекту cout

cin.tie(&cerr);   // чтение в cin сбрасывает объект cerr, а не cout

cin.tie(old_tie); // восстановление обычной связи между cin и cout

Чтобы связать данный поток с новым потоком вывода, функции tie() передают указатель на новый поток. Чтобы разорвать существующую связь, достаточно передать в качестве аргумента значение 0. Каждый поток может быть связан одновременно только с одним потоком. Однако несколько потоков могут связать себя с тем же объектом ostream.