Input/output library

 

C++

Language

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

Input/output library

I/O manipulators

C-style I/O

Buffers

basic_streambuf

basic_filebuf

basic_stringbuf

strstreambuf (deprecated)

Streams

Abstractions

ios_base

basic_ios

basic_istream

basic_ostream

basic_iostream

File I/O

basic_ifstream

basic_ofstream

basic_fstream

String I/O

basic_istringstream

basic_ostringstream

basic_stringstream

Array I/O

istrstream (deprecated)

ostrstream (deprecated)

strstream (deprecated)

Types

streamoff

streamsize

fpos

Error category interface

iostream_category (C++11)

io_errc (C++11)

 

C++ includes two input/output libraries: a modern, stream-based I/O library and the standard set of C-style I/O functions.

Stream-based I/O

The stream-based input/output library is organized around abstract input/output devices. These abstract devices allow the same code to handle input/output to files, memory streams, or custom adaptor devices that perform arbitrary operations (e.g. compression) on the fly.

Most of the classes are templated, so they can be adapted to any basic character type. Separate typedefs are provided for the most common basic character types (char and wchar_t). The classes are organized into the following hierarchy:

Inheritance diagram

Abstraction
ios_base	manages formatting flags and input/output exceptions (class)
basic_ios	manages an arbitrary stream buffer (class template)
basic_streambuf	abstracts a raw device (class template)
basic_istream	wraps a given abstract device (std::basic_streambuf) and provides high-level input interface (class template)
basic_ostream	wraps a given abstract device (std::basic_streambuf) and provides high-level output interface (class template)
basic_iostream	wraps a given abstract device (std::basic_streambuf) and provides high-level input/output interface (class template)
File I/0 implementation
basic_filebuf	implements raw file device (class template)
basic_ifstream	implements high-level file stream input operations (class template)
basic_ofstream	implements high-level file stream output operations (class template)
basic_fstream	implements high-level file stream input/output operations (class template)
String I/0 implementation
basic_stringbuf	implements raw string device (class template)
basic_istringstream	implements high-level string stream input operations (class template)
basic_ostringstream	implements high-level string stream output operations (class template)
basic_stringstream	implements high-level string stream input/output operations (class template)
Array I/O implementations
strstreambuf (deprecated)	implements raw character array device (class)
istrstream (deprecated)	implements character array input operations (class)
ostrstream (deprecated)	implements character array output operations (class)
strstream (deprecated)	implements character array input/output operations (class)

Typedefs

The following typedefs for common character types are provided:

typedef basic_ios<char>                ios;
typedef basic_ios<wchar_t>            wios;
 
typedef basic_streambuf<char>     streambuf;
typedef basic_streambuf<wchar_t> wstreambuf;
typedef basic_filebuf<char>         filebuf;
typedef basic_filebuf<wchar_t>     wfilebuf;
typedef basic_stringbuf<char>     stringbuf;
typedef basic_stringbuf<wchar_t> wstringbuf;
 
typedef basic_istream<char>         istream;
typedef basic_istream<wchar_t>     wistream;
typedef basic_ostream<char>         ostream;
typedef basic_ostream<wchar_t>     wostream;
typedef basic_iostream<char>       iostream;
typedef basic_iostream<wchar_t>   wiostream;
 
typedef basic_ifstream<char>       ifstream;
typedef basic_ifstream<wchar_t>   wifstream;
typedef basic_ofstream<char>       ofstream;
typedef basic_ofstream<wchar_t>   wofstream;
typedef basic_fstream<char>         fstream;
typedef basic_fstream<wchar_t>     wfstream;
 
typedef basic_istringstream<char>     istringstream;
typedef basic_istringstream<wchar_t> wistringstream;
typedef basic_ostringstream<char>     ostringstream;
typedef basic_ostringstream<wchar_t> wostringstream;
typedef basic_stringstream<char>       stringstream;
typedef basic_stringstream<wchar_t>   wstringstream;

Predefined standard stream objects:

extern  istream  cin;   //standard input (stdin)
extern wistream wcin;
extern  ostream  cout;  //standard output (stdout)
extern wostream wcout;
extern  ostream  cerr;  //standard error (stderr)
extern wostream wcerr;
extern  ostream  clog;  //standard log (stdlog)
extern wostream wclog;

I/O Manipulators

The stream-based I/O library uses I/O manipulators (e.g. std::boolalpha, std::hex, etc.) to control how streams behave.

Types

The following auxiliary type are defined:

Defined in header <ios>
streamoff	represents relative file/stream position (offset from fpos), sufficient to represent any file size (typedef)
streamsize	represents the number of characters transferred in an I/O operation or the size of an I/O buffer (typedef)
fpos	represents absolute position in a stream or a file (class template)

Four specializations of std::fpos are provided:

Defined in header <ios>
Type	Definition
streampos	std::fpos<std::char_traits<char>::state_type>
u16streampos	std::fpos<std::char_traits<char16_t>::state_type>
u32streampos	std::fpos<std::char_traits<char32_t>::state_type>
wstreampos	std::fpos<std::char_traits<wchar_t>::state_type>

Error category interface

Defined in header <ios>
io_errc (C++11)	the IO stream error codes (enum)
iostream_category (C++11)	identifies the iostream error category (function)

C-style IO

C++ also includes the input/output functions defined by C, such as std::fopen, std::getc, etc.