Iostream c что это

iostream

iostream — заголовочный файл с классами, функциями и переменными для организации ввода-вывода в языке программирования C++. Он включён в стандартную библиотеку C++. Название образовано от Input/Output Stream («поток ввода-вывода»). В языке C++ и его предшественнике, языке программирования Си, нет встроенной поддержки ввода-вывода, вместо этого используется библиотека функций. iostream управляет вводом-выводом, как и stdio.h в Cи. iostream использует объекты cin, cout, cerr и clog для передачи информации в и из стандартных потоков ввода, вывода, ошибок (без буферизации) и ошибок (с буферизацией) соответственно. Являясь частью стандартной библиотеки C++, эти объекты также являются частью стандартного пространства имён — std.

Некоторые новые компиляторы (например, компилятор Visual C++ из Visual Studio .NET 2003 [1] ) старые библиотеки <iostream.h> больше не поддерживают, вместо них нужно использовать только новые: #include <iostream> .

Содержание

Пример

Простейшая программа «Hello, world!» (с использованием библиотеки iostream) может быть записана так:

Форматирование вывода

Функции

Манипуляторы

Стандартная библиотека предлагает большое количество манипуляторов, среди них:

Лекция 10: Библиотека iostream

Библиотека потокового ввода-вывода iostream может быть использована в качестве альтернативы известной стандартной библиотеки ввода-вывода языка С — stdio. Для нас библиотека iostream интересна как прекрасный пример объектно-ориентированного проектирования, так как содержит многие характерные приемы и конструкции.

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

При пользовании библиотекой iostream ошибки, связанные с «перепутыванием» типов данных, исключены. Если вы используете в операции ввода-вывода переменную типа unsigned long, то вызывается подпрограмма, ответственная именно за этот тип.

Библиотека stdio поддерживает средства языка С, позволяющее использовать переменное число параметров. Но такая гибкость дается не даром — на этапе компиляции проверка соответствия между спецификацией формата, как в функциях printf() и scanf(), не выполняется.

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

Библиотека iostream более медленная, чем stdio, но это небольшая плата за надежность и расширяемость, базирующиеся на возможностях объектно-ориентированных средств вывода.

Для начала рассмотрим основы применения iostream, то есть, как читать и писать данные встроенных в С++ типов. Затем обсудим, как строить собственные операции потокового ввода и вывода (операторы внесения и извлечения) для разработанных вами типов данных.

Простое внесение

Начнем с простой программы, обращающейся к стандартным средствам языка С, а затем преобразуем применяя для ввода-вывода средства библиотеки iostream. (Это был наш первый пример программы на С++)

Вариант на стандартном С

#include <stdio.h> int i; char buff[80]; printf («Введите число:»); scanf(«%d», &i); printf («Введите символьную строку:»); gets (buff); printf («Вы ввели число: %d\n Вы ввели строку: %s\n», i, buff);

#include <iostream.h> int i; char buff[80]; cout << «Введите число и символьную строку:»; cin >> i >> buff; cout << «Вы ввели число:» << i << «\n» << «Вы ввели строку:» << buff << «\n»;

Оставим пока в стороне вопросы ввода (к этому мы еще вернемся), и остановимся на выводе информации.

Сообщения, выводимые программой, будут иметь вид:

Вы ввели число: 12 Вы ввели строку: My string

При этом, применяя стандартной библиотечной функций printf(), мы использовали в качестве одного из параметров этой функции строку формата, которая содержит два спецификатора: %d, %s, которые предписывают оператору printf() осуществить вывод целого числа и строки. Но все вы прекрасно знаете, что такая конструкция весьма чувствительна к ошибкам. Стоит только неправильно указать спецификатор типа или пропустить какой-либо из аргументов, то на выходе получается бессмыслица, а на поиск ее причин и исправление ошибки уйдет время.

И посмотрите, как все те же операции могут быть реализованы с применением iostream.

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

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

Объект cout — это предопределенный объект класса iostream, который используется для вывода. Корме него существуют еще cin — стандартный поток ввода cerr — поток для вывода сообщений об ошибках.

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

cout<<«Вы ввели число:»

В процессе анализа этого выражения компилятор пытается отыскать функцию — operator<<(), имеющую в качестве левого операнда объект класса ostream, а в качестве правого — целое. Описание переопределяемой функции operator << (ostream &, char*) содержится в заголовочном файле iostream.h. Здесь компилятор С++ преобразует исходное выражение в более пригодное для дальнейшей обработки. В результате получается следующее

operator<<(cout, «Вы ввели число:»)

Когда функция operator << (ostream &, char*) будет выполнена, она выведет свой аргумент (строку) и примет значение объекта cout (ее первый аргумент). «Вы ввели число:» выведется на экран, и подвыражением, находящимся на самом глубоком уровне вложенности, станет

Теперь компилятор ищет функцию operator <<(ostream &, int). Мы уже говорили, что iostream содержит функции операторы для всех встроенных типов. Процесс продолжается до тех пор, пока выражение внесения не будет сведено к набору вызовов функции operatop << ().

В итоге, выполнение этой сточки приведет к последовательному вызову нескольких функций-операторов

operator (ostream &, char*)

operator (ostream &, int)

operator (ostream &, char*)

«\n Вы ввели строку:»

operator (ostream &, char*)

operator (ostream &, char*)

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

Выражение извлечения

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

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

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

А что будет в случае ошибочного выражения? Конечно, ошибочные данные — это всегда ошибочные данные, и ни один язык не сможет их исправить. Но средствами языка можно создать программу, устойчивую к разрушительному действию ошибочных данных. Пусть, к примеру, наша программа ожидает на вводе строку «12 строчечка».

Если на вход поступит «строчечка 12», то программа будет в большом затруднении при попытке интерпретировать «строчечка» как число. Однако библиотека iostream, в отличие от scanf(), производит контроль ошибок после ввода каждого значения. Кроме того, iostream может быть расширена введением операторов для новых типов.

Одна из наиболее распространенных ошибок при использовании scanf() — это задание вместо адресов аргументов их значений. Другая распространенная ошибка — путаница в использовании модификаторов форматов. При работе с iostream такого не бывает, так как проверка соответствия типов — неотъемлемая часть процесса ввода-вывода. Компилятор обеспечивает вызов функций-операторов, строго соответствующих используемым типам.

Создание собственных функций внесения и извлечения

Мы уже говорили, что операторы >> и << можно перегружать, причем, вы сами можете создать свои операторы извлечения и внесения для создаваемых вами типов.

В общем виде, операция внесения имеет следующую форму

Аналогичным образом может быть определена функция извлечения

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

Эти функции не могут быть методами класса, для работы с которым они создаются. Если бы это было так, то левым аргументом, при вызове операции << (или >>), должен стоять объект, генерирующий вызов этой функции.

cout << «Моя строка»; а сout.operator << («Моя строка»); // ошибка

Получается, что функция внесения, определяемая для объектов вашего класса, должна быть методом объекта cout.

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

ostream& operator << (ostream& stream, _3d& obj)

Хотя в функции внесения (или извлечения) может выполняться любая операция, лучше ограничить ее работу только выводом (или вводом) информации.

Функции библиотеки iostream

Основное отличие профессионального программиста от любителя заключается в том, что он проверяет все входные данные. В библиотеке iostream для этого используются специальные методы класса ios и двух его наследников istream и ostream. Всего в этих классах находится порядка 25 методов, позволяющих получить информацию о состоянии объектов и управлять их поведением. Вот некоторые из них.

возвращает 1, если ошибок не обнаружено

возвращает 1, если поток находится в состоянии «коней файла»

возвращает 1, если обнаружена восстановимая ошибка ввода-вывода (обычно, ошибка преобразования данных)

возвращает 1, если обнаружена невосстановимая ошибка ввода-вывода

сбрасывает состояние ошибки ввода-вывода

int precision (int i)

устанавливает точность вывода чисел с плавающей точкой

int width (int i)

устанавливает ширину поля вывода

Как теперь можно изменить нашу программу, усилив ее проверкой на ошибки при вводе.

Обратите внимание на условие повторения цикла. Условие повторение цикла означает, что нужно повторить цикл, если произошла восстановимая ошибка (как правило, это ошибка преобразования), но только в том случае, если есть возможность восстановления. Единственная ошибка, которая может вызвать аварийное завершение — это переполнение 80-символьного буфера для ввода строки. Можно решить и эту проблему, указав объекту cin размер буфера, используя метод width() класса ios.

cin.width(sizeof(buff)); cin >> buff;

Манипуляторы ввода -вывода

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

В прошлый раз мы накладывали ограничение на размер буфера cin, применяя метод width():

cin.width(sizeof(buff)); cin >> buff;

Теперь, используя манипулятор setw(), можно определить размер буфера так

cin >> setw (sizeof (buff)) >> buff;

Существует два вида манипуляторов ввода-вывода: параметризованные и непараметризованные. Вот список стандартных манипуляторов библиотеки iostream()

устанавливает базу для преобразования чисел к 10-,

и 16-ичной форме

пропуск начальных пробелов

выводит нулевой символ

Выводит признак конца строки

Устанавливает точность вывода чисел с плав точкой (знаков после запятой)

устанавливает ширину поля для последующей операции

устанавливает базу для преобразования числовых значений

setiosflags (int f)

устанавливает отдельные флаги потока

resetiosflags (int f)

сбрасывает отдельные флаги потока

Вот некоторые из флагов потока

выравнивание по левому краю

выравнивание по правому краю

устанавливают базу для ввода-вывода

выводить показатель базы

выводить десятичную точку для чисел с плав точкой

16-ричные большие буквы

показать «+» для положительных целых чисел

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

установить формат чисел с фиксированной плав точкой

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

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

Если вы пишите манипулятор только для вывода, ios замените на ostream, если для ввода — на istream.

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

Вот пример манипулятора для вывода с выравниванием по правому краю:

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

Таким образом, выражение cout << setw(20) << right<< 1234 << endl; означает следующее. Манипулятор setw(20) установит поле вывода шириной 20 символов, манипулятор right установит выравнивание по правой границе поля вывода, выведется число, а манипулятор endl вызовет переход к следующей строке.

Параметризованные манипуляторы более сложны в написании, так как в этом случае необходимо создать класс, содержащий указатель на функцию — манипулятор и указатель на аргументы функции манипулятора. Макроопределения, которые облегчат процесс разработки параметризованных манипуляторов, содержатся в заголовочном файле iomanip.h.

Файловые и строковые потоки

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

Первостепенная задача при создании таких объектов — это организация буфера и связывание его с потоком.

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

filebuf mybuff; // создаем буферный объект // увязывем этот буфер с файлом output для вывода mybuff.open(«output», ios::out); ostream mycout(&mybuff); // новый потоковый объект mycout <<12<<ends; mybuff.close();

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

ifstream — для ввода, ofstream — для вывода, fstream — для ввода и вывода.

int i; // сразу создается буферизованный потоковый объект, связанный // с файлом input ifstream mycout(«input»); mycin >> i;

Если в своей программе собираетесь использовать файловые потоки, то не забудьте внести в нее заголовочный файл fstream.h.

Если будите применять строковые потоки, то нужно подключить заголовочный файл strstrea.h.

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

char mybuff[128]; ostrstream mycout (mybuff, sizeof(mybuff)); mycout << 123 << ends;

При этом mybuff примет значение «123».

Аналогично для ввода,

int i; char mybuff[128]= «123»; istrstream mycin (mybuff, sizeof(mybuff)); mycin >> i;

После этого i примет значение 123.

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

Name already in use

cpp-docs / docs / standard-library / iostream.md

• Go to file T
• Go to line L
• Copy path
• Copy permalink

• Open with Desktop
• View raw
• Copy raw contents Copy raw contents

Copy raw contents

Copy raw contents

Declares objects that control reading from and writing to the standard streams. This include is often the only header you need to do input and output from a C++ program.

[!NOTE] The <iostream> library uses the #include <ios> , #include <streambuf> , #include <istream> , and #include <ostream> statements.

The objects fall into two groups:

cin , cout , cerr , and clog are byte oriented, doing conventional byte-at-a-time transfers.

wcin , wcout , wcerr , and wclog are wide oriented, translating to and from the wide characters that the program manipulates internally.

Once you do certain operations on a stream, such as the standard input, you can’t do operations of a different orientation on the same stream. Therefore, a program can’t operate interchangeably on both cin and wcin , for example.

All the objects declared in this header share a peculiar property — you can assume they’re constructed before any static objects you define, in a translation unit that includes <iostream> . Equally, you can assume that these objects aren’t destroyed before the destructors for any such static objects you define. (The output streams are, however, flushed during program termination.) Therefore, you can safely read from or write to the standard streams before program startup and after program termination.

This guarantee isn’t universal, however. A static constructor may call a function in another translation unit. The called function can’t assume that the objects declared in this header have been constructed, given the uncertain order in which translation units participate in static construction. To use these objects in such a context, you must first construct an object of class ios_base::Init .

Global Stream Objects

The object cerr controls output to a stream buffer associated with the object stderr , declared in <cstdio> .

The object controls unbuffered insertions to the standard error output as a byte stream. Once the object is constructed, the expression cerr.flags & unitbuf is nonzero, and cerr.tie() == &cout . For more details, see cerr.flags and unitbuf .

Specifies the cin global stream.

The object controls extractions from the standard input as a byte stream. Once the object is constructed, the call cin.tie returns &cout .

In this example, cin sets the fail bit on the stream when it comes across non-numeric characters. The program clears the fail bit and strips the invalid character from the stream to continue.

Input/Output

The iostream library is an object-oriented library that provides input and output functionality using streams.

A stream is an abstraction that represents a device on which input and ouput operations are performed. A stream can basically be represented as a source or destination of characters of indefinite length.

Streams are generally associated to a physical source or destination of characters, like a disk file, the keyboard, or the console, so the characters gotten or written to/from our abstraction called stream are physically input/output to the physical device. For example, file streams are C++ objects to manipulate and interact with files; Once a file stream is used to open a file, any input or output operation performed on that stream is physically reflected in the file.

To operate with streams, C++ provides the standard iostream library, which contains the following elements:

Basic class templates The base of the iostream library is the hierarchy of class templates. The class templates provide most of the functionality of the library in a type-independent fashion.

This is a set of class templates, each one having two template parameters: the char type (charT) parameter, that determines the type of elements that are going to be manipulated and the traits parameter, that provides additional characteristics specific for a particular type of elements.

The class templates in this class hierarchy have the same name as their char-type instantiations but with the prefix basic_. For example, the class template which istream is instantiated from is called basic_istream, the one from which fstream is is called basic_fstream, and so on. The only exception is ios_base, which is by itself type-independent, and therefore is not based on a template, but is a regular class.

Class template instantiations The library incorporates two standard sets of instantiations of the entire iostream class template hierarchy: one is narrow-oriented, to manipulate elements of type char and another one, wide-oriented, to manipulate elements of type wchar_t.

The narrow-oriented (char type) instantiation is probably the better known part of the iostream library. Classes like ios, istream and ofstream are narrow-oriented. The diagram on top of this page shows the names and relationships of narrow-oriented classes.

The classes of the wide-oriented (wchar_t) instatiation follow the same naming conventions as the narrow-oriented instantiation but with the name of each class and object prefixed with a w character, forming wios, wistream and wofstream, as an example.

Standard objects As part of the iostream library, the header file <iostream> declares certain objects that are used to perform input and output operations on the standard input and output.

They are divided in two sets: narrow-oriented objects, which are the popular cin, cout, cerr and clog and their wide-oriented counterparts, declared as wcin, wcout, wcerr and wclog.

Types The iostream classes barely use fundamental types on their member’s prototypes. They generally use defined types that depend on the traits used in their instantiation. For the default char and wchar_t instantiations, types streampos, streamoff and streamsize are used to represent positions, offsets and sizes, respectively.
Manipulators Manipulators are global functions designed to be used together with insertion (<<) and extraction (>>) operators performed on iostream stream objects. They generally modify properties and formatting settings of the streams. endl, hex and scientific are some examples of manipulators.

Organization

• <ios>, <istream>, <ostream>, <streambuf> and <iosfwd> aren’t usually included directly in most C++ programs. They describe the base classes of the hierarchy and are automatically included by other header files of the library that contain derived classes.
• <iostream> declares the objects used to communicate through the standard input and output (including cin and cout).
• <fstream> defines the file stream classes (like the template basic_ifstream or the class ofstream) as well as the internal buffer objects used with these (basic_filebuf). These classes are used to manipulate files using streams.
• <sstream>: The classes defined in this file are used to manipulate string objects as if they were streams.
• <iomanip> declares some standard manipulators with parameters to be used with extraction and insertion operators to modify internal flags and formatting options.

Compatibility notes

The names, prototypes and examples included in this reference for the iostream classes mostly describe and use the char instantiations of the class templates instead of the templates themselves, even though these classes are only one of their possible instantiations. We believe this provides a better readability and is arguably as easy to obtain the names and prototypes of the basic template from the char instantiation as the opposite.