Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      Input/output library

      From cppreference.com
      <cpp
       
       
       

      C++ includes the following input/output libraries: anOOP-stylestream-based I/O library,print-based family of functions(since C++23), and the standard set ofC-style I/O functions.

      Contents

      [edit]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 andwchar_t). The classes are organized into the following hierarchy:

      std-io-complete-inheritance.svg
      Abstraction
      Defined in header<ios>
      manages formatting flags and input/output exceptions
      (class)[edit]
      manages an arbitrary stream buffer
      (class template)[edit]
      Defined in header<streambuf>
      abstracts a raw device
      (class template)[edit]
      Defined in header<ostream>
      wraps a given abstract device (std::basic_streambuf)
      and provides high-level output interface
      (class template)[edit]
      Defined in header<istream>
      wraps a given abstract device (std::basic_streambuf)
      and provides high-level input interface
      (class template)[edit]
      wraps a given abstract device (std::basic_streambuf)
      and provides high-level input/output interface
      (class template)[edit]
      File I/O implementation
      Defined in header<fstream>
      implements raw file device
      (class template)[edit]
      implements high-level file stream input operations
      (class template)[edit]
      implements high-level file stream output operations
      (class template)[edit]
      implements high-level file stream input/output operations
      (class template)[edit]
      String I/O implementation
      Defined in header<sstream>
      implements raw string device
      (class template)[edit]
      implements high-level string stream input operations
      (class template)[edit]
      implements high-level string stream output operations
      (class template)[edit]
      implements high-level string stream input/output operations
      (class template)[edit]
      Array I/O implementations
      Defined in header<spanstream>
      implements raw fixed character buffer device
      (class template)[edit]
      implements fixed character buffer input operations
      (class template)[edit]
      implements fixed character buffer output operations
      (class template)[edit]
      implements fixed character buffer input/output operations
      (class template)[edit]
      Defined in header<strstream>
      (deprecated in C++98)(removed in C++26)
      		 implements raw character array device
      (class)[edit]
      (deprecated in C++98)(removed in C++26)
      		 implements character array input operations
      (class)[edit]
      (deprecated in C++98)(removed in C++26)
      		 implements character array output operations
      (class)[edit]
      (deprecated in C++98)(removed in C++26)
      		 implements character array input/output operations
      (class)[edit]
      Synchronized output(since C++20)
      Defined in header<syncstream>
      synchronized output device wrapper
      (class template)[edit]
      synchronized output stream wrapper
      (class template)[edit]

      [edit]Typedefs

      The following typedefs for common character types are provided in namespacestd:

      Type Definition
      Defined in header<ios>
      std::iosstd::basic_ios<char>
      std::wiosstd::basic_ios<wchar_t>
      Defined in header<streambuf>
      std::streambufstd::basic_streambuf<char>
      std::wstreambufstd::basic_streambuf<wchar_t>
      Defined in header<istream>
      std::istreamstd::basic_istream<char>
      std::wistreamstd::basic_istream<wchar_t>
      std::iostreamstd::basic_iostream<char>
      std::wiostreamstd::basic_iostream<wchar_t>
      Defined in header<ostream>
      std::ostreamstd::basic_ostream<char>
      std::wostreamstd::basic_ostream<wchar_t>
      Defined in header<fstream>
      std::filebufstd::basic_filebuf<char>
      std::wfilebufstd::basic_filebuf<wchar_t>
      std::ifstreamstd::basic_ifstream<char>
      std::wifstreamstd::basic_ifstream<wchar_t>
      std::ofstreamstd::basic_ofstream<char>
      std::wofstreamstd::basic_ofstream<wchar_t>
      std::fstreamstd::basic_fstream<char>
      std::wfstreamstd::basic_fstream<wchar_t>
      Defined in header<sstream>
      std::stringbufstd::basic_stringbuf<char>
      std::wstringbufstd::basic_stringbuf<wchar_t>
      std::istringstreamstd::basic_istringstream<char>
      std::wistringstreamstd::basic_istringstream<wchar_t>
      std::ostringstreamstd::basic_ostringstream<char>
      std::wostringstreamstd::basic_ostringstream<wchar_t>
      std::stringstreamstd::basic_stringstream<char>
      std::wstringstreamstd::basic_stringstream<wchar_t>
      Defined in header<spanstream>
      std::spanbuf(C++23)std::basic_spanbuf<char>
      std::wspanbuf(C++23)std::basic_spanbuf<wchar_t>
      std::ispanstream(C++23)std::basic_ispanstream<char>
      std::wispanstream(C++23)std::basic_ispanstream<wchar_t>
      std::ospanstream(C++23)std::basic_ospanstream<char>
      std::wospanstream(C++23)std::basic_ospanstream<wchar_t>
      std::spanstream(C++23)std::basic_spanstream<char>
      std::wspanstream(C++23)std::basic_spanstream<wchar_t>
      Defined in header<syncstream>
      std::syncbuf(C++20)std::basic_syncbuf<char>
      std::wsyncbuf(C++20)std::basic_syncbuf<wchar_t>
      std::osyncstream(C++20)std::basic_osyncstream<char>
      std::wosyncstream(C++20)std::basic_osyncstream<wchar_t>

      [edit]Predefined standard stream objects

      Defined in header<iostream>
      reads from the standard C input streamstdin
      (global object)[edit]
      writes to the standard C output streamstdout
      (global object)[edit]
      writes to the standard C error streamstderr, unbuffered
      (global object)[edit]
      writes to the standard C error streamstderr
      (global object)[edit]

      [edit]I/O Manipulators

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

      [edit]Types

      The following auxiliary types are defined:

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

      The following typedef names forstd::fpos<std::mbstate_t> are provided:

      Defined in header<iosfwd>
      Type Definition
      std::streamposstd::fpos<std::char_traits<char>::state_type>
      std::wstreamposstd::fpos<std::char_traits<wchar_t>::state_type>
      std::u8streampos(C++20)std::fpos<std::char_traits<char8_t>::state_type>
      std::u16streampos(C++11)std::fpos<std::char_traits<char16_t>::state_type>
      std::u32streampos(C++11)std::fpos<std::char_traits<char32_t>::state_type>

      [edit]Error category interface(since C++11)

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

      [edit]Print functions(since C++23)

      The Unicode-aware print-family functions that perform formatted I/O on text that is already formatted. They bring all the performance benefits ofstd::format, are locale-independent by default, reduce global state, avoid allocating a temporarystd::string object and callingoperator<<, and in general make formatting more efficient compared toiostreams andstdio.

      The following print-like functions are provided:

      Defined in header<print>
      (C++23)
      		 prints tostdout or a file stream usingformatted representation of the arguments
      (function template)[edit]
      (C++23)
      		 same asstd::print except that each print is terminated by additional new line
      (function template)[edit]
      prints to Unicode capablestdout or a file stream usingtype-erased argument representation
      (function)[edit]
      prints tostdout or a file stream usingtype-erased argument representation
      (function)[edit]
       
      Defined in header<ostream>
      outputsformatted representation of the arguments
      (function template)[edit]
      outputsformatted representation of the arguments with appended'\n'
      (function template)[edit]

      [edit]C-style I/O

      C++ also includes theinput/output functions defined by C, such asstd::fopen,std::getc, etc.

      [edit]See also

      Filesystem library(since C++17)
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/io&oldid=179905"
      [8]ページ先頭
      ©2009-2025 Movatter.jp