Standard library header <iosfwd>

C++

Language

Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

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)

Filesystem library (C++17)

Technical Specifications

Standard Library header files

Language Support
<cstddef> <limits> <climits> <contract>	<cfloat> <cstdint> <new> <version>	<typeinfo> <exception> <initializer_list>	<csignal> <csetjmp> <cstdarg>
Concepts
<concepts>
Diagnostics
<stdexcept>	<cassert>	<cerrno>	<system_error>
General utilities
<utility> <memory> <memory_resource> <scoped_allocator> <compare>	<bitset> <tuple> <optional> <any> <variant>	<type_traits> <ratio> <chrono> <typeindex> <functional>	<ctime> <cstdlib>
Strings
<string> <string_view>	<cctype> <cwctype>	<cwchar> <cuchar>	<cstring> <charconv>
Localization
<locale>	<codecvt>	<clocale>
Containers
<span> <array> <vector>	<deque> <forward_list> <list>	<map> <set> <queue>	<unordered_map> <unordered_set> <stack>
Iterators
<iterator>
Algorithms
<algorithm>	<execution>
Numerics
<complex> <random>	<valarray> <numeric>	<cfenv> <cmath>	<bit>
Input/Output
<iosfwd> <ios> <iomanip> <streambuf>	<istream> <ostream> <iostream>	<sstream> <fstream> <syncstream>	<cstdio> <cinttypes> <strstream>
Regular expressions
<regex>
Filesystem support
<filesystem>
Thread support
<thread> <atomic>	<mutex> <shared_mutex>	<condition_variable> <future>
C compatibility
<ciso646> <cstdalign>	<cstdbool> <ccomplex>	<ctgmath>

This header contains forward declarations for the Input/output library.

Forward declarations
Defined in header <string>
std::char_traits	Class Template which describes properties of a character type (class template)
std::char_traits<char>	(class template specialization)
std::char_traits<wchar_t>	(class template specialization)
std::char_traits<char16_t> (C++11)	(class template specialization)
std::char_traits<char32_t> (C++11)	(class template specialization)
Defined in header <memory>
allocator	the default allocator (class template)
Defined in header <ios>
basic_ios	manages an arbitrary stream buffer (class template)
fpos	represents absolute position in a stream or a file (class template)
Defined in header <streambuf>
basic_streambuf	abstracts a raw device (class template)
Defined in header <ostream>
basic_ostream	wraps a given abstract device (std::basic_streambuf) and provides high-level output interface (class template)
Defined in header <istream>
basic_istream	wraps a given abstract device (std::basic_streambuf) and provides high-level input interface (class template)
basic_iostream	wraps a given abstract device (std::basic_streambuf) and provides high-level input/output interface (class template)
Defined in header <fstream>
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)
Defined in header <sstream>
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)
Defined in header <syncstream>
basic_syncbuf (C++20)	synchronized output device wrapper (class template)
basic_osyncstream (C++20)	synchronized output stream wrapper (class template)
Defined in header <strstream>
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 and specializations
std::streampos	fpos<char_traits<char>::state_type>
std::wstreampos	fpos<char_traits<wchar_t>::state_type>
In addition, for each class template std::basic_T declared in this header, std::T and std::wT are declared as a synonym of std::basic_T<char> and std::basic_T<wchar_t> respectively.

Synopsis

namespace std {

    template<class charT> class char_traits;
    template<> class char_traits<char>;
    template<> class char_traits<char16_t>;
    template<> class char_traits<char32_t>;
    template<> class char_traits<wchar_t>;

    template<class T> class allocator;

    template <class charT, class traits = char_traits<charT> >
        class basic_ios;

    template <class charT, class traits = char_traits<charT> >
        class basic_streambuf;
    template <class charT, class traits = char_traits<charT> >
        class basic_istream;
    template <class charT, class traits = char_traits<charT> >
        class basic_ostream;
    template <class charT, class traits = char_traits<charT> >
        class basic_iostream;
    template <class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT> >
        class basic_stringbuf;

    template <class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT> >
        class basic_istringstream;
    template <class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT> >
        class basic_ostringstream;
    template <class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT> >
        class basic_stringstream;

    template <class charT, class traits = char_traits<charT> >
        class basic_filebuf;
    template <class charT, class traits = char_traits<charT> >
        class basic_ifstream;
    template <class charT, class traits = char_traits<charT> >
        class basic_ofstream;
    template <class charT, class traits = char_traits<charT> >
        class basic_fstream;

    template <class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT> >
        class basic_syncbuf;
    template <class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT> >
        class basic_osyncstream;

    template <class charT, class traits = char_traits<charT> >
        class istreambuf_iterator;
    template <class charT, class traits = char_traits<charT> >
        class ostreambuf_iterator;


    typedef basic_ios<char>     ios;    
    typedef basic_ios<wchar_t>  wios;   

    typedef basic_streambuf<char>     streambuf;
    typedef basic_istream<char>       istream;
    typedef basic_ostream<char>       ostream;
    typedef basic_iostream<char>      iostream;

    typedef basic_stringbuf<char>     stringbuf;
    typedef basic_istringstream<char> istringstream;
    typedef basic_ostringstream<char> ostringstream;
    typedef basic_stringstream<char>  stringstream;

    typedef basic_filebuf<char>       filebuf;
    typedef basic_ifstream<char>      ifstream;
    typedef basic_ofstream<char>      ofstream;
    typedef basic_fstream<char>       fstream;

    typedef basic_syncbuf<char>       syncbuf;
    typedef basic_osyncstream<char>   osyncstream;

    typedef basic_streambuf<wchar_t>     wstreambuf;
    typedef basic_istream<wchar_t>       wistream;
    typedef basic_ostream<wchar_t>       wostream;
    typedef basic_iostream<wchar_t>      wiostream;

    typedef basic_stringbuf<wchar_t>     wstringbuf;
    typedef basic_istringstream<wchar_t> wistringstream;
    typedef basic_ostringstream<wchar_t> wostringstream;
    typedef basic_stringstream<wchar_t>  wstringstream;

    typedef basic_filebuf<wchar_t>       wfilebuf;        
    typedef basic_ifstream<wchar_t>      wifstream;      
    typedef basic_ofstream<wchar_t>      wofstream;      
    typedef basic_fstream<wchar_t>       wfstream;

    typedef basic_syncbuf<wchar_t>       wsyncbuf;
    typedef basic_osyncstream<wchar_t>   wosyncstream;

    template <class state> class fpos;      
    typedef fpos<char_traits<char>::state_type> streampos;  
    typedef fpos<char_traits<wchar_t>::state_type> wstreampos;  

}