Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/io"

From cppreference.com
< cpp
(+ios_base, basic_ios)
m (Text replace - "{{cpp|" to "{{c|")
Line 2: Line 2:
 
{{cpp/io/sidebar}}
 
{{cpp/io/sidebar}}
  
−
Standard input/output library is organized in such a way that the underlying device of an input/output operation is abstracted. In this way the same code can handle input/output to a file, memory stream, or custom adaptor device interpreting the data on the fly, e.g. compressing it. 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 ({{cpp|char}} and {{cpp|wchar_t}}).
+
Standard input/output library is organized in such a way that the underlying device of an input/output operation is abstracted. In this way the same code can handle input/output to a file, memory stream, or custom adaptor device interpreting the data on the fly, e.g. compressing it. 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 ({{c|char}} and {{c|wchar_t}}).
  
 
{{inheritance diagram|image=std-io-complete-inheritance.png|map=
 
{{inheritance diagram|image=std-io-complete-inheritance.png|map=
Line 23: Line 23:
 
{{dcl list tclass | cpp/io/basic_ios | manages an arbitrary stream buffer}}
 
{{dcl list tclass | cpp/io/basic_ios | manages an arbitrary stream buffer}}
 
{{dcl list tclass | cpp/io/basic_streambuf | abstracts a raw device}}
 
{{dcl list tclass | cpp/io/basic_streambuf | abstracts a raw device}}
−
{{dcl list tclass | cpp/io/basic_istream | wraps a given abstract device ({{cpp|std::basic_streambuf}})<br/> and provides high-level input interface}}
+
{{dcl list tclass | cpp/io/basic_istream | wraps a given abstract device ({{c|std::basic_streambuf}})<br/> and provides high-level input interface}}
−
{{dcl list tclass | cpp/io/basic_ostream | wraps a given abstract device ({{cpp|std::basic_streambuf}})<br/> and provides high-level output interface}}
+
{{dcl list tclass | cpp/io/basic_ostream | wraps a given abstract device ({{c|std::basic_streambuf}})<br/> and provides high-level output interface}}
−
{{dcl list tclass | cpp/io/basic_iostream | wraps a given abstract device ({{cpp|std::basic_streambuf}})<br/> and provides high-level input/output interface}}
+
{{dcl list tclass | cpp/io/basic_iostream | wraps a given abstract device ({{c|std::basic_streambuf}})<br/> and provides high-level input/output interface}}
 
{{dcl list h2 | File I/0 implementation}}
 
{{dcl list h2 | File I/0 implementation}}
 
{{dcl list tclass | cpp/io/basic_filebuf | implements raw file device}}
 
{{dcl list tclass | cpp/io/basic_filebuf | implements raw file device}}
Line 104: Line 104:
 
{{dcl list end}}
 
{{dcl list end}}
  
−
Four specializations of {{cpp|std::fpos}} are provided:  
+
Four specializations of {{c|std::fpos}} are provided:  
 
{{tdcl list begin}}
 
{{tdcl list begin}}
 
{{tdcl list header | ios}}
 
{{tdcl list header | ios}}
 
{{tdcl list hitem | Type | Definition}}
 
{{tdcl list hitem | Type | Definition}}
−
{{tdcl list item | {{tt|streampos}} | {{cpp|std::fpos<std::char_traits<char>::state_type>}}}}
+
{{tdcl list item | {{tt|streampos}} | {{c|std::fpos<std::char_traits<char>::state_type>}}}}
−
{{tdcl list item | {{tt|u16streampos}} | {{cpp|std::fpos<std::char_traits<char16_t>::state_type>}}}}
+
{{tdcl list item | {{tt|u16streampos}} | {{c|std::fpos<std::char_traits<char16_t>::state_type>}}}}
−
{{tdcl list item | {{tt|u32streampos}} | {{cpp|std::fpos<std::char_traits<char32_t>::state_type>}}}}
+
{{tdcl list item | {{tt|u32streampos}} | {{c|std::fpos<std::char_traits<char32_t>::state_type>}}}}
−
{{tdcl list item | {{tt|wstreampos}} | {{cpp|std::fpos<std::char_traits<wchar_t>::state_type>}}}}
+
{{tdcl list item | {{tt|wstreampos}} | {{c|std::fpos<std::char_traits<wchar_t>::state_type>}}}}
 
{{tdcl list end}}
 
{{tdcl list end}}
  
Line 120: Line 120:
 
{{dcl list template | cpp/io/dcl list iostream_category}}
 
{{dcl list template | cpp/io/dcl list iostream_category}}
 
<!-- TODO: these three specializations go inside the io_errc page  
 
<!-- TODO: these three specializations go inside the io_errc page  
−
{{dcl list ptfun | cpp/io/is_error_code_enum  | title=is_error_code_enum{{dcl small|(std::io_errc)}}| notes={{mark c++11}} | extends the type trait {{cpp|std::is_error_code_enum}} to identify iostream error codes}}
+
{{dcl list ptfun | cpp/io/is_error_code_enum  | title=is_error_code_enum{{dcl small|(std::io_errc)}}| notes={{mark c++11}} | extends the type trait {{c|std::is_error_code_enum}} to identify iostream error codes}}
 
{{dcl list fun | cpp/io/make_error_code | title=make_error_code{{dcl small|(std::io_errc)}} | notes={{mark c++11}} | constructs an iostream error code}}
 
{{dcl list fun | cpp/io/make_error_code | title=make_error_code{{dcl small|(std::io_errc)}} | notes={{mark c++11}} | constructs an iostream error code}}
 
{{dcl list fun | cpp/io/make_error_condition  | title=make_error_condition{{dcl small|(std::io_errc)}} | notes={{mark c++11}} | constructs an iostream error_condition}}
 
{{dcl list fun | cpp/io/make_error_condition  | title=make_error_condition{{dcl small|(std::io_errc)}} | notes={{mark c++11}} | constructs an iostream error_condition}}

Revision as of 18:59, 19 April 2012

Template:cpp/io/sidebar

Standard input/output library is organized in such a way that the underlying device of an input/output operation is abstracted. In this way the same code can handle input/output to a file, memory stream, or custom adaptor device interpreting the data on the fly, e.g. compressing it. 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).

Error: Image is invalid or non-existent.

Inheritance diagram

Contents

Abstraction
manages formatting flags and input/output exceptions
(class)
manages an arbitrary stream buffer
(class template)
abstracts a raw device
(class template)
wraps a given abstract device (std::basic_streambuf)
and provides high-level input interface
(class template)
wraps a given abstract device (std::basic_streambuf)
and provides high-level output interface
(class template)
wraps a given abstract device (std::basic_streambuf)
and provides high-level input/output interface
(class template)
File I/0 implementation
implements raw file device
(class template)
implements high-level file stream input operations
(class template)
implements high-level file stream output operations
(class template)
implements high-level file stream input/output operations
(class template)
String I/0 implementation
implements raw string device
(class template)
implements high-level string stream input operations
(class template)
implements high-level string stream output operations
(class template)
implements high-level string stream input/output operations
(class template)
Array I/O implementations
(deprecated)
 implements raw character array device
(class)
(deprecated)
 implements character array input operations
(class)
(deprecated)
 implements character array output operations
(class)
(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

Types

The following auxiliary type are defined:

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

Four specializations of std::fpos are provided: Template:tdcl list begin Template:tdcl list header Template:tdcl list hitem Template:tdcl list item Template:tdcl list item Template:tdcl list item Template:tdcl list item Template:tdcl list end

Error category interface

Template:cpp/io/dcl list io errcTemplate:cpp/io/dcl list iostream category
Defined in header <ios>

C-style input/output

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/io&oldid=23665"