# Standard library header <iosfwd>

From cppreference.com
< cpp‎ | header

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<char8_t> (C++20) | (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 in C++98) | implements raw character array device (class)
istrstream (deprecated in C++98) | implements character array input operations (class)
ostrstream (deprecated in C++98) | implements character array output operations (class)
strstream (deprecated in C++98) | 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<char8_t>;
        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;

    }

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/header/iosfwd&oldid=107847"