STD::IOSTREAM(3cxx)

📦

version 14-20240412 · 26 versions

💖 `std::basic_iostream< _CharT, _Traits >` from `3cxx` 💖

okay bestie, welcome to the 3cxx manual page for std::basic_iostream< _CharT, _Traits > — yep, that whole template-y name is the manual name, and we're folding it in right here at the top instead of making you read a copied header line. 💅

✨ NAME ✨

std::basic_iostream< _CharT, _Traits > — Template class basic_iostream.

🦋 SYNOPSIS 🦋

#include <istream>

Inherits std::basic_istream< _CharT, _Traits >, and std::basic_ostream< _CharT, _Traits >.

Inherited by std::basic_fstream< _CharT, _Traits >, and std::basic_stringstream< _CharT, _Traits, _Alloc >.

🎀 Public Types 🎀

typedef ctype< _CharT > __ctype_type — the page lists this one twice, so I'm listing it twice too. no cap.
typedef ctype< _CharT > __ctype_type — yep, again 💀
typedef basic_ios< _CharT, _Traits > __ios_type — here's the first one.
typedef basic_ios< _CharT, _Traits > __ios_type — and here's the second one.
typedef basic_istream< _CharT, _Traits > __istream_type
typedef num_get< _CharT, istreambuf_iterator< _CharT, _Traits > > __num_get_type
typedef num_put< _CharT, ostreambuf_iterator< _CharT, _Traits > > __num_put_type
typedef basic_ostream< _CharT, _Traits > __ostream_type
typedef basic_streambuf< _CharT, _Traits > __streambuf_type — first appearance.
typedef basic_streambuf< _CharT, _Traits > __streambuf_type — second appearance, because the page said so.
typedef _CharT char_type
enum event { erase_event, imbue_event, copyfmt_event } — the set of events that may be passed to an event callback.
typedef void(* event_callback) (event __e, ios_base &__b, int __i) — the type of an event callback function.
typedef _Ios_Fmtflags fmtflags — this is a bitmask type.
typedef _Traits::int_type int_type
typedef _Ios_Iostate iostate — this is a bitmask type.
typedef _Traits::off_type off_type
typedef _Ios_Openmode openmode — this is a bitmask type.
typedef _Traits::pos_type pos_type
typedef _Ios_Seekdir seekdir — this is an enumerated type.
typedef _Traits traits_type
typedef num_put< _CharT, ostreambuf_iterator< _CharT, _Traits > > __num_put_type — and yes, the page repeats this one right after traits_type; not me being extra, that's literally what's there 🫶

🌸 Public Member Functions 🌸

basic_iostream (basic_streambuf< _CharT, _Traits > *__sb) — constructor does nothing.
virtual ~basic_iostream () — destructor does nothing.
template<typename _ValueT > basic_istream< _CharT, _Traits > & _M_extract (_ValueT &__v)
const locale & _M_getloc () const — locale access.
template<typename _ValueT > basic_ostream< _CharT, _Traits > & _M_insert (_ValueT __v)
void _M_setstate (iostate __state)
bool bad () const — fast error checking.
void clear (iostate __state=goodbit) — [re]sets the error state.
basic_ios & copyfmt (const basic_ios &__rhs) — copies fields of __rhs into this.
bool eof () const — fast error checking.
iostate exceptions () const — throwing exceptions on errors.
void exceptions (iostate __except) — throwing exceptions on errors.
bool fail () const — fast error checking.
char_type fill () const — retrieves the empty character.
char_type fill (char_type __ch) — sets a new empty character.
fmtflags flags () const — access to format flags.
fmtflags flags (fmtflags __fmtfl) — setting new format flags all at once.
__ostream_type & flush () — synchronizing the stream buffer.
streamsize gcount () const — character counting.
basic_istream< char > & getline (char_type *__s, streamsize __n, char_type __delim) — explicit specialization declarations, defined in src/istream.cc.
basic_istream< wchar_t > & getline (char_type *__s, streamsize __n, char_type __delim)
locale getloc () const — locale access.
bool good () const — fast error checking.
basic_istream< char > & ignore (streamsize __n)
basic_istream< wchar_t > & ignore (streamsize __n)
basic_istream< char > & ignore (streamsize __n, int_type __delim)
basic_istream< wchar_t > & ignore (streamsize __n, int_type __delim)
locale imbue (const locale &__loc) — moves to a new locale.
long & iword (int __ix) — access to integer array.
char narrow (char_type __c, char __dfault) const — squeezes characters.
__ostream_type & operator<< (__streambuf_type *__sb) — extracting from another streambuf.
__ostream_type & operator<< (const void *__p) — pointer arithmetic inserters.
__ostream_type & operator<< (nullptr_t)
__istream_type & operator>> (__streambuf_type *__sb) — extracting into another streambuf.
__istream_type & operator>> (void *&__p) — basic arithmetic extractors.
streamsize precision () const — flags access.
streamsize precision (streamsize __prec) — changing flags.
void *& pword (int __ix) — access to void pointer array.
basic_streambuf< _CharT, _Traits > * rdbuf () const — accessing the underlying buffer.
basic_streambuf< _CharT, _Traits > * rdbuf (basic_streambuf< _CharT, _Traits > *__sb) — changing the underlying buffer.
iostate rdstate () const — returns the error state of the stream buffer.
void register_callback (event_callback __fn, int __index) — add the callback __fn with parameter __index.
__ostream_type & seekp (off_type, ios_base::seekdir) — changing the current write position.
__ostream_type & seekp (pos_type) — changing the current write position.
fmtflags setf (fmtflags __fmtfl) — setting new format flags.
fmtflags setf (fmtflags __fmtfl, fmtflags __mask) — setting new format flags.
void setstate (iostate __state) — sets additional flags in the error state.
pos_type tellp () — getting the current write position.
basic_ostream< _CharT, _Traits > * tie () const — fetches the current tied stream.
basic_ostream< _CharT, _Traits > * tie (basic_ostream< _CharT, _Traits > *__tiestr) — ties this stream to an output stream.
void unsetf (fmtflags __mask) — clearing format flags.
char_type widen (char __c) const — widens characters.
streamsize width () const — flags access.
streamsize width (streamsize __wide) — changing flags.
__istream_type & operator>> (__istream_type &(*__pf)(__istream_type &)) — interface for manipulators.
__istream_type & operator>> (__ios_type &(*__pf)(__ios_type &)) — interface for manipulators.
__istream_type & operator>> (ios_base &(*__pf)(ios_base &)) — interface for manipulators.

⭐ Extractors ⭐

all the operator>> functions (aka formatted input functions) have some common behavior, bestie. each one starts by constructing a temporary object of type std::basic_istream::sentry with the second argument (noskipws) set to false. this has several effects, concluding with the setting of a status flag; see the sentry documentation for more. 💫

if the sentry status is good, the function tries to extract whatever data is appropriate for the type of the argument.

if an exception is thrown during extraction, ios_base::badbit will be turned on in the stream's error state (without causing an ios_base::failure to be thrown) and the original exception will be rethrown if badbit is set in the exceptions mask.

__istream_type & operator>> (bool &__n) — integer arithmetic extractors.
__istream_type & operator>> (short &__n) — integer arithmetic extractors.
__istream_type & operator>> (unsigned short &__n) — integer arithmetic extractors.
__istream_type & operator>> (int &__n) — integer arithmetic extractors.
__istream_type & operator>> (unsigned int &__n) — integer arithmetic extractors.
__istream_type & operator>> (long &__n) — integer arithmetic extractors.
__istream_type & operator>> (unsigned long &__n) — integer arithmetic extractors.
__istream_type & operator>> (long long &__n) — integer arithmetic extractors.
__istream_type & operator>> (unsigned long long &__n) — integer arithmetic extractors.
__istream_type & operator>> (float &__f) — floating point arithmetic extractors.
__istream_type & operator>> (double &__f) — floating point arithmetic extractors.
__istream_type & operator>> (long double &__f) — floating point arithmetic extractors.

🦋 Unformatted Input Functions 🦋

all the unformatted input functions have some common behavior too. each starts by constructing a temporary object of type std::basic_istream::sentry with the second argument (noskipws) set to true. this has several effects, concluding with the setting of a status flag; see the sentry documentation for more. ✨

if the sentry status is good, the function tries to extract whatever data is appropriate for the type of the argument.

the number of characters extracted is stored for later retrieval by gcount().

int_type get () — simple extraction.
__istream_type & get (char_type &__c) — simple extraction.
__istream_type & get (char_type *__s, streamsize __n, char_type __delim) — simple multiple-character extraction.
__istream_type & get (char_type *__s, streamsize __n) — simple multiple-character extraction.
__istream_type & get (__streambuf_type &__sb, char_type __delim) — extraction into another streambuf.
__istream_type & get (__streambuf_type &__sb) — extraction into another streambuf.
__istream_type & getline (char_type *__s, streamsize __n, char_type __delim) — string extraction.
__istream_type & getline (char_type *__s, streamsize __n) — string extraction.
__istream_type & ignore (streamsize __n, int_type __delim) — discarding characters.
__istream_type & ignore (streamsize __n) — simple extraction.
__istream_type & ignore () — simple extraction.
int_type peek () — looking ahead in the stream.
__istream_type & read (char_type *__s, streamsize __n) — extraction without delimiters.
streamsize readsome (char_type *__s, streamsize __n) — extraction until the buffer is exhausted, but no more.
__istream_type & putback (char_type __c) — unextracting a single character.
__istream_type & unget () — unextracting the previous character.
int sync () — synchronizing the stream buffer.
pos_type tellg () — getting the current read position.
__istream_type & seekg (pos_type) — changing the current read position.
__istream_type & seekg (off_type, ios_base::seekdir) — changing the current read position.
operator bool () const — the quick-and-easy status check.
bool operator! () const — the quick-and-easy status check.
__ostream_type & operator<< (__ostream_type &(*__pf)(__ostream_type &)) — the manipulator hook, bestie 💅 this is how stuff like <kbd>-style stream manipulators get applied to a basic_ostream.
__ostream_type & operator<< (__ios_type &(*__pf)(__ios_type &)) — same deal, manipulator interface but for the __ios_type flavour.
__ostream_type & operator<< (ios_base &(*__pf)(ios_base &)) — and the third one, manipulator interface taking ios_base &. Three flavours, all iconic, all slaying ✨

🎀 Inserters 🎀

Okay so literally all the operator<< functions (aka the formatted output functions, iykyk) share some common behavior, and the way that works is:

Every single one starts by constructing a temporary object of type std::basic_ostream::sentry. No cap. This temp object can do several things, and it wraps up with setting a status flag — go read the sentry documentation for the full tea on that one 🫖

If the sentry status is good, the function tries to generate whatever data is appropriate for the type of the argument. Simple as that.

Okay important warning though 😭 if an exception gets thrown during insertion, ios_base::badbit will be turned on in the stream's error state without causing an ios_base::failure to be thrown. Then the original exception gets rethrown. So like, no sneaky extra exception, just the og one coming back for round two 💀

__ostream_type & operator<< (long __n) — integer arithmetic inserter 🧮
__ostream_type & operator<< (unsigned long __n) — integer arithmetic inserter 🧮
__ostream_type & operator<< (bool __n) — integer arithmetic inserter 🧮
__ostream_type & operator<< (short __n) — integer arithmetic inserter 🧮
__ostream_type & operator<< (unsigned short __n) — integer arithmetic inserter 🧮
__ostream_type & operator<< (int __n) — integer arithmetic inserter 🧮
__ostream_type & operator<< (unsigned int __n) — integer arithmetic inserter 🧮
__ostream_type & operator<< (long long __n) — integer arithmetic inserter 🧮
__ostream_type & operator<< (unsigned long long __n) — integer arithmetic inserter 🧮
__ostream_type & operator<< (double __f) — floating point arithmetic inserter 🌊
__ostream_type & operator<< (float __f) — floating point arithmetic inserter 🌊
__ostream_type & operator<< (long double __f) — floating point arithmetic inserter 🌊

🦋 Unformatted Output Functions 🦋

So the unformatted output functions also have common behavior, and the way that works: each one starts by constructing a temporary object of type std::basic_ostream::sentry. This has several effects, finishing up with the setting of a status flag — again, sentry documentation, go read it 💖

If the sentry status is good, the function tries to generate whatever data is appropriate for the type of the argument.

But here's where it differs, bestie, pay attention 😭 If an exception is thrown during insertion, ios_base::badbit will be turned on in the stream's error state. And if badbit is on in the stream's exceptions mask, the exception will be rethrown without completing its actions. Very much not the same as the formatted ones up there ⭐

__ostream_type & put (char_type __c) — simple insertion ✨ just yeet one character in.
__ostream_type & write (const char_type *__s, streamsize __n) — character string insertion 🎀 you're writing __n characters from __s.

👑 Static Public Member Functions 👑

static bool sync_with_stdio (bool __sync=true) — the whole interaction-with-the-standard-C-I/O-objects situation 🌈 default is true, so it's synced unless you say otherwise.
static int xalloc () throw () — access to unique indices 💅 that's the whole vibe.

🌸 Static Public Attributes 🌸

static const openmode __noreplace — that's the one.
static const fmtflags adjustfield — a mask of left|right|internal. Useful for the 2-arg form of setf 🎀
static const openmode app — seek to end before each write. Every. Single. Write.
static const openmode ate — open and seek to end immediately after opening.
static const iostate badbit — indicates a loss of integrity in an input or output sequence (like an irrecoverable read error from a file) 💀
static const fmtflags basefield — a mask of dec|oct|hex. Useful for the 2-arg form of setf 🎀
static const seekdir beg — request a seek relative to the beginning of the stream.
static const openmode binary — perform input and output in binary mode (as opposed to text mode). And here's the thing: this is probably not what you think it is 😭 see https://gcc.gnu.org/onlinedocs/libstdc++/manual/fstreams.html#std.io.filestreams.binary for the real explanation before you go assuming stuff.
static const fmtflags boolalpha — insert/extract bool in alphabetic rather than numeric format ✨ (true/false instead of 1/0, iconic).
static const seekdir cur — request a seek relative to the current position within the sequence.
static const fmtflags dec — converts integer input or generates integer output in decimal base.
static const seekdir end — request a seek relative to the current end of the sequence.
static const iostate eofbit — indicates that an input operation reached the end of an input sequence 🏁
static const iostate failbit — indicates that an input operation failed to read the expected characters, or that an output operation failed to generate the desired characters 😬 rough out here.
static const fmtflags fixed — generate floating-point output in fixed-point notation.
static const fmtflags floatfield — a mask of scientific|fixed. Useful for the 2-arg form of setf 🎀
static const iostate goodbit — indicates all is well 🌈✨ literally the good vibes flag.
static const fmtflags hex — converts integer input or generates integer output in hexadecimal base.
static const openmode in — open for input. Default for ifstream and fstream.
static const fmtflags internal — adds fill characters at a designated internal point in certain generated output, or identical to right if no such point is designated.
static const fmtflags left — adds fill characters on the right (final positions) of certain generated output. (I.e., the thing you print is flush left.) 👈
static const fmtflags oct — converts integer input or generates integer output in octal base.
static const openmode out — open for output. Default for ofstream and fstream.
static const fmtflags right — adds fill characters on the left (initial positions) of certain generated output. (I.e., the thing you print is flush right.) 👉
static const fmtflags scientific — generates floating-point output in scientific notation 🧪
static const fmtflags showbase — generates a prefix indicating the numeric base of generated integer output.
static const fmtflags showpoint — generates a decimal-point character unconditionally in generated floating-point output. Unconditionally. That's the whole point (pun intended) 🍓
static const fmtflags showpos — generates a + sign in non-negative generated numeric output.
static const fmtflags skipws — skips leading white space before certain input operations.
static const openmode trunc — truncate an existing stream when opening. Default for ofstream. Yes it will eat your file, be normal about it 💀
static const fmtflags unitbuf — flushes output after each output operation.
static const fmtflags uppercase — replaces certain lowercase letters with their uppercase equivalents in generated output 🔠

🧚 Protected Types 🧚

enum { _S_local_word_size } — yep, that's the enum. Protected, so hands off unless you're a subclass bestie.

🎀 Protected Member Functions 🎀

basic_iostream (basic_iostream &&__rhs) — move-y constructor situation.
basic_iostream (const basic_iostream &)=delete — copy constructor? Deleted. No copying, not today, not ever 🙈
void _M_cache_locale (const locale &__loc) — caches the locale.
void _M_call_callbacks (event __ev) throw () — call the callbacks for that event.
void _M_dispose_callbacks (void) throw () — dispose of the callbacks.
template<typename _ValueT > __istream_type & _M_extract (_ValueT &__v) — the internal extract machinery.
_Words & _M_grow_words (int __index, bool __iword) — grows the words array.
void _M_init () throw () — internal init.
template<typename _ValueT > __ostream_type & _M_insert (_ValueT __v) — the internal insert machinery.
void _M_move (ios_base &) noexcept — internal move.
void _M_swap (ios_base &__rhs) noexcept — internal swap.
void init (basic_streambuf< _CharT, _Traits > *__sb) — all setup is performed here ✨ literally everything, this is the main character of the setup functions.
void move (basic_ios &&__rhs) — move from an rvalue basic_ios.
void move (basic_ios &__rhs) — move from an lvalue basic_ios.
basic_iostream & operator= (basic_iostream &&__rhs) — move assignment, slay.
basic_iostream & operator= (const basic_iostream &)=delete — copy assignment? Also deleted 💀 no copying periodt.
void set_rdbuf (basic_streambuf< _CharT, _Traits > *__sb) — sets the rdbuf.
void swap (basic_ios &__rhs) noexcept — swap with a basic_ios.
void swap (basic_iostream &__rhs) — swap with another basic_iostream.
void swap (basic_istream &__rhs) — swap with a basic_istream.
void swap (basic_ostream &__rhs) — swap with a basic_ostream.

💜 Protected Attributes 💜

_Callback_list * _M_callbacks — the callback list pointer.
const __ctype_type * _M_ctype — the ctype facet pointer.
iostate _M_exception — the exception state.
char_type _M_fill — the fill character.
bool _M_fill_init — whether the fill got initialized.
fmtflags _M_flags — the format flags.
streamsize _M_gcount — the gcount.
locale _M_ios_locale — the locale, of course.
_Words _M_local_word [_S_local_word_size] — the local word array, sized _S_local_word_size 🎀
const __num_get_type * _M_num_get — the num_get facet pointer.
const __num_put_type * _M_num_put — the num_put facet pointer.
streamsize _M_precision — the precision.
basic_streambuf< _CharT, _Traits > * _M_streambuf — the streambuf pointer, the actual engine under the hood 🔥
iostate _M_streambuf_state — the streambuf state.
basic_ostream< _CharT, _Traits > * _M_tie — the tie pointer.
streamsize _M_width — the width.
_Words * _M_word — pointer to the words.
int _M_word_size — how big the words situation is.
_Words _M_word_zero — the zeroth word, just vibing.

⭐ Detailed Description ⭐

template<typename _CharT, typename _Traits>
    class std::basic_iostream< _CharT, _Traits >

Okay so this is Template class basic_iostream 💖

Template Parameters — because you gotta know your types, bestie:

_CharT — type of character stream 🎀
_Traits — traits for character type, defaults to char_traits<_CharT>.

And the whole thing? This class multiply inherits from the input and output stream classes simply to provide a single interface. That's it, that's the reason — one interface, two parents, main character energy 👑

🎀 Member Typedef Documentation 🎀

Ok bestie, these are the little name-aliases the class hands you so you don't have to type out the whole ungodly template soup every time. Slay.

typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> > std::basic_ios< _CharT, _Traits >::__num_put_type [inherited] — heads up: these are non-standard types, so don't go assuming they're portable across the whole universe, mkay? 💅
typedef void(* std::ios_base::event_callback) (event __e, ios_base &__b, int __i) [inherited] — it's the type of an event callback function. 🦋

Parameters, in order:

__e — one of the members of the event enum.
__b — reference to the ios_base object.
__i — the integer that was provided when the callback was registered.

Event callbacks are user-defined functions that get called during several ios_base and basic_ios functions — specifically imbue(), copyfmt(), and ~ios(). So like, your callback is literally on the invite list for those three moments. 🎀

typedef _Ios_Fmtflags std::ios_base::fmtflags [inherited] — this is a bitmask type. _Ios_Fmtflags is implementation-defined, but — and this is the important part — it is valid to perform bitwise operations on these values and expect the Right Thing to happen. ✨ Defined objects of type fmtflags are:
- boolalpha
- dec
- fixed
- hex
- internal
- left
- oct
- right
- scientific
- showbase
- showpoint
- showpos
- skipws
- unitbuf
- uppercase
- adjustfield
- basefield
- floatfield
typedef _Ios_Iostate std::ios_base::iostate [inherited] — also a bitmask type. _Ios_Iostate is implementation-defined, but again: bitwise operations on these values, Right Thing, guaranteed. 💖 Defined objects of type iostate are:
- badbit
- eofbit
- failbit
- goodbit
typedef _Ios_Openmode std::ios_base::openmode [inherited] — yeah you guessed it, bitmask type number three. _Ios_Openmode is implementation-defined, and bitwise ops on these values do the Right Thing. 🔥 Defined objects of type openmode are:
- app
- ate
- binary
- in
- out
- trunc
typedef _Ios_Seekdir std::ios_base::seekdir [inherited] — this one's an enumerated type. _Ios_Seekdir is implementation-defined. 🧚 Defined values of type seekdir are:
- beg
- cur, equivalent to SEEK_CUR in the C standard library.
- end, equivalent to SEEK_END in the C standard library.

🌸 Member Enumeration Documentation 🌸

💜 `enum std::ios_base::event` `[inherited]`

The set of events that may be passed to an event callback. Let me spell out the whole drama for you:

erase_event is used during ~ios() and copyfmt().
imbue_event is used during imbue().
copyfmt_event is used during copyfmt().

That's the entire cast. Three characters, no filler. 👑

✨ Constructor & Destructor Documentation ✨

🫶 `template<typename _CharT , typename _Traits > std::basic_iostream< _CharT, _Traits >::basic_iostream (basic_streambuf< _CharT, _Traits > * __sb)` `[inline]`, `[explicit]`

Constructor does nothing. Literally nothing. 😭 Both of the parent classes are initialized with the same streambuf pointer that was passed to this constructor, and then it's like... that's it, we're done here.

🫶 `template<typename _CharT , typename _Traits > virtual std::basic_iostream< _CharT, _Traits >::~basic_iostream ()` `[inline]`, `[virtual]`

Destructor does nothing. Matching energy. Balance restored. 🦋

⭐ Member Function Documentation ⭐

🌈 `const locale & std::ios_base::_M_getloc () const` `[inline]`, `[inherited]`

Locale access. ✨

Returns: a reference to the current locale.

It's like getloc above, but it returns a reference instead of generating a copy — so no unnecessary copying, we love efficiency.

Referenced by: std::money_get< _CharT, _InIter >::do_get(), std::time_get< _CharT, _InIter >::do_get(), std::num_get< _CharT, _InIter >::do_get(), std::time_get< _CharT, _InIter >::do_get_date(), std::time_get< _CharT, _InIter >::do_get_monthname(), std::time_get< _CharT, _InIter >::do_get_time(), std::time_get< _CharT, _InIter >::do_get_weekday(), std::time_get< _CharT, _InIter >::do_get_year(), std::num_put< _CharT, _OutIter >::do_put(), std::time_put< _CharT, _OutIter >::do_put(), std::time_get< _CharT, _InIter >::get(), and std::time_put< _CharT, _OutIter >::put().

🌈 `template<typename _CharT , typename _Traits > bool std::basic_ios< _CharT, _Traits >::bad () const` `[inline]`, `[inherited]`

Fast error checking. ⚡

Returns: True if the badbit is set.

Note that other iostate flags may also be set — so like, don't read this as "only badbit, nothing else going on." 🙈

References: std::ios_base::badbit, and std::basic_ios< _CharT, _Traits >::rdstate().

Referenced by: std::basic_ostream< _CharT, _Traits >::sentry::sentry().

🌈 `template<typename _CharT , typename _Traits > void std::basic_ios< _CharT, _Traits >::clear (iostate __state = goodbit)` `[inherited]`

[Re]sets the error state. 🎀

Parameters:

__state — the new state flag(s) to set.

See std::ios_base::iostate for the possible bit values. Most users will not need to pass an argument — the default is goodbit, so calling it bare just wipes the slate clean. 💅

Referenced by: std::basic_ios< _CharT, _Traits >::exceptions(), std::basic_ifstream< _CharT, _Traits >::open(), std::basic_fstream< _CharT, _Traits >::open(), std::basic_ofstream< _CharT, _Traits >::open(), std::basic_ifstream< _CharT, _Traits >::open(), std::basic_fstream< _CharT, _Traits >::open(), std::basic_ofstream< _CharT, _Traits >::open(), std::__detail::operator>>(), std::basic_istream< _CharT, _Traits >::putback(), std::basic_istream< _CharT, _Traits >::seekg(), std::basic_istream< _CharT, _Traits >::seekg(), std::basic_ios< _CharT, _Traits >::setstate(), and std::basic_istream< _CharT, _Traits >::unget().

(Yes, open() and seekg() really do show up twice in that list. We don't make the rules, we just report them faithfully. 💀)

🌈 `template<typename _CharT , typename _Traits > basic_ios< _CharT, _Traits > & std::basic_ios< _CharT, _Traits >::copyfmt (const basic_ios< _CharT, _Traits > & __rhs)` `[inherited]`

Copies fields of __rhs into this. It's giving "becoming your friend's whole personality" but in a sanctioned, documented way. 💖

Parameters:

__rhs — the source values for the copies.

Returns: a reference to this object.

Now the important fine print: all fields of __rhs are copied into this object except that rdbuf() and rdstate() remain unchanged. All values in the pword and iword arrays are copied. 🦋

The order of operations, because it matters, bestie:

Before copying, each callback is invoked with erase_event.
After copying, each (new) callback is invoked with copyfmt_event.
The final step is to copy exceptions().

References: std::__addressof(), std::basic_ios< _CharT, _Traits >::exceptions(), std::basic_ios< _CharT, _Traits >::fill(), std::ios_base::flags(), std::ios_base::getloc(), std::ios_base::precision(), std::basic_ios< _CharT, _Traits >::tie(), std::tie(), and std::ios_base::width().

🌈 `template<typename _CharT , typename _Traits > bool std::basic_ios< _CharT, _Traits >::eof () const` `[inline]`, `[inherited]`

Fast error checking. ⚡

Returns: True if the eofbit is set.

Same disclaimer as bad(): other iostate flags may also be set. Don't let the single-purpose name fool you. 🙈

References: std::ios_base::eofbit, and std::basic_ios< _CharT, _Traits >::rdstate().

🌈 `template<typename _CharT , typename _Traits > iostate std::basic_ios< _CharT, _Traits >::exceptions () const` `[inline]`, `[inherited]`

Throwing exceptions on errors — this is the getter half of the duo. 🎀

Returns: the current exceptions mask.

This changes nothing in the stream — it's read-only vibes. See the one-argument version of exceptions(iostate) for the meaning of the return value.

Referenced by: std::basic_ios< _CharT, _Traits >::copyfmt().

🌈 `template<typename _CharT , typename _Traits > void std::basic_ios< _CharT, _Traits >::exceptions (iostate __except)` `[inline]`, `[inherited]`

Throwing exceptions on errors — now the setter. 👑

Parameters:

__except — the new exceptions mask.

By default, error flags are set silently. You can set an exceptions mask for each stream; if a bit in the mask becomes set in the error flags, then an exception of type std::ios_base::failure is thrown. 🔥

⚠️ And here's the spicy part: if the error flag is already set when the exceptions mask is added, the exception is immediately thrown. Like, no waiting, no grace period, instant.

Try running the following under GCC 3.1 or later:

#include <iostream>
#include <fstream>
#include <exception>

int main()
{
    std::set_terminate (__gnu_cxx::__verbose_terminate_handler);

    std::ifstream f ("/etc/motd");

    std::cerr << "Setting badbit\n";
    f.setstate (std::ios_base::badbit);

    std::cerr << "Setting exception mask\n";
    f.exceptions (std::ios_base::badbit);
}

References: std::basic_ios< _CharT, _Traits >::clear().

🌈 `template<typename _CharT , typename _Traits > bool std::basic_ios< _CharT, _Traits >::fail () const` `[inline]`, `[inherited]`

Fast error checking. ⚡

Returns: True if either the badbit or the failbit is set.

Checking the badbit in fail() is historical practice — that's just how it's always been done, we're not here to question history. Also, note that other iostate flags may be set too. 💅

References: std::ios_base::badbit, std::ios_base::failbit, and std::basic_ios< _CharT, _Traits >::rdstate().

Referenced by: std::basic_ios< _CharT, _Traits >::operator bool(), std::basic_ios< _CharT, _Traits >::operator!(), std::basic_istream< _CharT, _Traits >::seekg(), std::basic_istream< _CharT, _Traits >::seekg(), std::basic_ostream< _CharT, _Traits >::seekp(), std::basic_ostream< _CharT, _Traits >::seekp(), std::basic_istream< _CharT, _Traits >::tellg(), std::basic_ostream< _CharT, _Traits >::tellp(), and std::regex_traits< _Ch_type >::value().

🌈 `template<typename _CharT , typename _Traits > char_type std::basic_ios< _CharT, _Traits >::fill () const` `[inline]`, `[inherited]`

Retrieves the empty character. 🎀

Returns: the current fill character.

It defaults to a space (' ') in the current locale. So when nothing fancy is set, you're padding with spaces like a normal person. ✨

References: std::basic_ios< _CharT, _Traits >::widen().

Referenced by: std::basic_ios< _CharT, _Traits >::copyfmt(), and std::basic_ios< _CharT, _Traits >::fill().

🌈 `template<typename _CharT , typename _Traits > char_type std::basic_ios< _CharT, _Traits >::fill (char_type __ch)` `[inline]`, `[inherited]`

Sets a new empty character. 💖

Parameters:

__ch — the new character.

Returns: the previous fill character. (Yes, it hands you back the old one — trade offer style. 🫶)

The fill character is used to fill out space when P characters have been requested (e.g., via setw), Q characters are actually used, and Q<P. It defaults to a space (' ') in the current locale.

References: std::basic_ios< _CharT, _Traits >::fill().

🌈 `fmtflags std::ios_base::flags () const` `[inline]`, `[inherited]`

Access to format flags. 👑

Returns: the format control flags for both input and output — one shared little flag bucket for everything.

Referenced by: std::basic_istream< _CharT, _Traits >::sentry::sentry(), std::basic_ostream< _CharT, _Traits >::sentry::~sentry(), std::basic_ios< _CharT, _Traits >::copyfmt(), std::num_get< _CharT, _InIter >::do_get(), std::num_get< _CharT, _InIter >::do_get(), std::num_put< _CharT, _OutIter >::do_put(), std::num_put< _CharT, _OutIter >::do_put(), std::normal_distribution< double >::operator()(), std::operator<<(), std::chrono::operator<<(), std::operator>>(), std::operator>>(), std::__detail::operator>>(), std::operator>>(), std::operator>>(), std::operator>>(), std::operator>>(), and std::operator>>().

(That is a lot of operator>>()s and we are reporting every single one of them, because accuracy is the whole assignment. 🍓)

🌈 `fmtflags std::ios_base::flags (fmtflags __fmtfl)` `[inline]`, `[inherited]`

Setting new format flags all at once — the "replace everything, no notes" option. 🔥

Parameters:

__fmtfl — the new flags to set.

Returns: the previous format control flags.

This function overwrites all the format flags with __fmtfl. Not merges. Not ORs. Overwrites. So if you had other flags set and you wanted to keep them, uh, you should've thought about that first. 💀

References: std::basic_istream< _CharT, _Traits >::sentry::sentry(), std::basic_ostream< _CharT, _Traits >::sentry::~sentry(), std::basic_ios< _CharT, _Traits >::copyfmt(), std::num_get< _CharT, _InIter >::do_get(), std::num_get< _CharT, _InIter >::do_get(), std::num_put< _CharT, _OutIter >::do_put(), std::num_put< _CharT, _OutIter >::do_put(), std::normal_distribution< double >::operator()(), std::operator<<(), std::chrono::operator<<(), std::operator>>(), std::operator>>(), std::__detail::operator>>(), std::operator>>(), std::operator>>(), std::operator>>(), std::operator>>(), and std::operator>>().

`template<typename _CharT , typename _Traits > basic_ostream< _CharT, _Traits > & std::basic_ostream< _CharT, _Traits >::flush ()` — inherited 💅

Okay so this one is literally just syncing the stream buffer. That's the whole vibe.

Returns: *this

So like, if rdbuf() is a null pointer, bestie, nothing happens. Not a single thing. It just vibes.

Otherwise? It calls rdbuf()->pubsync(), and if that returns -1, it sets badbit. That's it, that's the whole function 🫶

References: std::ios_base::badbit, std::ios_base::goodbit, std::basic_ios< _CharT, _Traits >::rdbuf(), and std::basic_ios< _CharT, _Traits >::setstate().

Referenced by: std::flush().

`template<typename _CharT , typename _Traits > streamsize std::basic_istream< _CharT, _Traits >::gcount () const` — inline, inherited ✨

Character counting, icon behavior honestly.

Returns: the number of characters extracted by the previous unformatted input function dispatched for this stream. Like, the last one. Not a running total, just the last one, no cap.

References: std::basic_istream< _CharT, _Traits >::_M_gcount.

`template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits >::int_type std::basic_istream< _CharT, _Traits >::get (void)` — inherited 🦋

Simple extraction. Very demure, very mindful.

Returns: a character, or eof().

It tries to extract a character. If none are available? Sets failbit and returns traits::eof(). Rip 😭

References: std::basic_istream< _CharT, _Traits >::_M_gcount, std::ios_base::badbit, std::ios_base::eofbit, std::ios_base::failbit, std::ios_base::goodbit, std::basic_ios< _CharT, _Traits >::rdbuf(), and std::basic_ios< _CharT, _Traits >::setstate().

Referenced by: std::basic_istream< _CharT, _Traits >::get(), and std::basic_istream< _CharT, _Traits >::get().

`template<typename _CharT , typename _Traits > __istream_type & std::basic_istream< _CharT, _Traits >::get (__streambuf_type & __sb)` — inline, inherited 🎀

Extraction into another streambuf. Passing the aux, basically.

Parameters:

__sb — a streambuf in which to store data.

Returns: *this

It literally just returns get(__sb,widen('\n')). That's the whole thing, she's a one-liner 💀

References: std::basic_istream< _CharT, _Traits >::get(), and std::basic_ios< _CharT, _Traits >::widen().

`template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::get (__streambuf_type & __sb, char_type __delim)` — inherited 🌸

Extraction into another streambuf, but now with a stop character. Main character energy.

Parameters:

__sb — a streambuf in which to store data.
__delim — a 'stop' character.

Returns: *this

So characters get extracted and inserted into __sb until one of these things happens:

the input sequence reaches EOF
insertion into the output buffer fails — and in this case, the character that would have been inserted is not extracted, okurrr
the next character equals __delim — in this case the character is not extracted
an exception occurs (and in this case it is caught, we're being safe)

If no characters are stored, failbit is set in the stream's error state. F in the chat.

References: std::basic_istream< _CharT, _Traits >::_M_gcount, and std::ios_base::goodbit.

`template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::get (char_type & __c)` — inherited 🧚

Simple extraction, take two.

Parameters:

__c — the character in which to store data.

Returns: *this

Tries to extract a character and store it in __c. If none are available, sets failbit and returns traits::eof().

Note: this function is not overloaded on signed char and unsigned char. Just so you know 💅

`template<typename _CharT , typename _Traits > __istream_type & std::basic_istream< _CharT, _Traits >::get (char_type * s, streamsize n)` — inline, inherited 🍓

Simple multiple-character extraction. We're scaling up, besties.

Parameters:

__s — pointer to an array.
__n — maximum number of characters to store in s.

Returns: *this

Returns get(__s,__n,widen('\n')). Again, one line, she's efficient.

References: std::basic_istream< _CharT, _Traits >::get(), and std::basic_ios< _CharT, _Traits >::widen().

`template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::get (char_type * s, streamsize n, char_type __delim)` — inherited 👑

Simple multiple-character extraction, full version.

Parameters:

__s — pointer to an array.
__n — maximum number of characters to store in __s.
__delim — a 'stop' character.

Returns: *this

Characters are extracted and stored into __s until one of these happens:

__n-1 characters are stored
the input sequence reaches EOF
the next character equals __delim, in which case the character is not extracted

If no characters are stored, failbit is set in the stream's error state.

In any case, a null character is stored into the next location in the array. Periodt ✨

Note: again, this function is not overloaded on signed char and unsigned char.

References: std::basic_istream< _CharT, _Traits >::_M_gcount, std::ios_base::goodbit, std::basic_ios< _CharT, _Traits >::rdbuf(), and std::basic_streambuf< _CharT, _Traits >::sgetc().

`template<typename _CharT , typename _Traits > __istream_type & std::basic_istream< _CharT, _Traits >::getline (char_type * s, streamsize n)` — inline, inherited 🌈

String extraction! The classic.

Parameters:

__s — a character array in which to store the data.
__n — maximum number of characters to extract.

Returns: *this

Returns getline(__s,__n,widen('\n')). Yes bestie, the '\n' is just a widened default.

References: std::basic_istream< _CharT, _Traits >::getline(), and std::basic_ios< _CharT, _Traits >::widen().

`template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::getline (char_type * s, streamsize n, char_type __delim)` — inherited 💜

String extraction, the real one. Pay attention because the ordering here is not a vibe, it's a requirement.

Parameters:

__s — a character array in which to store the data.
__n — maximum number of characters to extract.
__delim — a 'stop' character.

Returns: *this

Extracts and stores characters into __s until one of these happens. And note — these criteria are required to be tested in the order listed here, so that an input line can exactly fill the __s array without setting failbit. Like, the order is the whole point, don't touch it 🔥

the input sequence reaches end-of-file, in which case eofbit is set in the stream error state
the next character equals __delim, in which case the character is extracted (and therefore counted in gcount()) but not stored
__n-1 characters are stored, in which case failbit is set in the stream error state

If no characters are extracted, failbit is set. (An empty line of input should therefore not cause failbit to be set — important!! 🙈)

In any case, a null character is stored in the next location in the array.

Referenced by: std::basic_istream< _CharT, _Traits >::getline().

`basic_istream< char > & std::basic_istream< char >::getline (char_type * s, streamsize n, char_type __delim)` — inherited ⭐

Explicit specialization declarations, defined in src/istream.cc. That's it, that's the whole note, she's just chillin' there 💅

`locale std::ios_base::getloc () const` — inline, inherited 🦋

Locale access, iykyk.

Returns: a copy of the current locale.

So if imbue(loc) has previously been called, then this function returns loc. Otherwise, it returns a copy of std::locale(), the global C++ locale. Simple as that.

Referenced by: std::basic_ios< _CharT, _Traits >::copyfmt(), std::money_put< _CharT, _OutIter >::do_put(), std::chrono::operator<<(), std::operator>>(), std::operator>>(), and std::ws().

`template<typename _CharT , typename _Traits > bool std::basic_ios< _CharT, _Traits >::good () const` — inline, inherited 🫶

Fast error checking. The vibe check function, truly.

Returns: True if no error flags are set.

It's a wrapper around rdstate. That's literally all she does and she does it flawlessly.

References: std::basic_ios< _CharT, _Traits >::rdstate().

Referenced by: std::basic_istream< _CharT, _Traits >::sentry::sentry(), std::basic_ostream< _CharT, _Traits >::sentry::sentry(), and std::__detail::operator>>().

`template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::ignore (void)` — inherited 🌸

Simple extraction. Someone get this girl a consistent description, she's got three overloads and two of them say the exact same thing 😭

Returns: a character, or eof().

Tries to extract a character. If none are available, sets failbit and returns traits::eof().

References: std::basic_istream< _CharT, _Traits >::_M_gcount, std::ios_base::eofbit, std::ios_base::goodbit, std::basic_ios< _CharT, _Traits >::rdbuf(), and std::basic_streambuf< _CharT, _Traits >::sbumpc().

`template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::ignore (streamsize __n)` — inherited 🎀

Simple extraction, part two, electric boogaloo.

Returns: a character, or eof().

Tries to extract a character. If none are available, sets failbit and returns traits::eof().

References: std::basic_istream< _CharT, _Traits >::_M_gcount, std::ios_base::goodbit, std::basic_ios< _CharT, _Traits >::rdbuf(), and std::basic_streambuf< _CharT, _Traits >::sgetc().

`template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::ignore (streamsize __n, int_type __delim)` — inherited 🔥

Discarding characters. The "no thoughts, head empty, throw it away" function, we love her.

Parameters:

__n — number of characters to discard.
__delim — a 'stop' character.

Returns: *this

Extracts characters and throws them away until one of these happens:

if __n != std::numeric_limits<int>::max(), __n characters are extracted
the input sequence reaches end-of-file
the next character equals __delim (in this case the character is extracted); note that this condition will never occur if __delim equals traits::eof()

NB: provide three overloads, instead of the single function (with defaults) mandated by the Standard: this leads to a better performing implementation, while still conforming to the Standard. She's doing the most and somehow still following the rules, iconic 💅

`template<typename _CharT , typename _Traits > locale std::basic_ios< _CharT, _Traits >::imbue (const locale & __loc)` — inherited 🌍

Moves to a new locale. Glow-up arc.

Parameters:

__loc — the new locale.

Returns: the previous locale. (She remembers where you came from 🥺)

Calls ios_base::imbue(loc), and if a stream buffer is associated with this stream, calls that buffer's pubimbue(loc).

Additional l10n notes are at http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html — go read them, bestie, they're good for you ✨

References: std::ios_base::imbue().

Referenced by: std::chrono::operator<<().

`template<typename _CharT , typename _Traits > void std::basic_ios< _CharT, _Traits >::init (basic_streambuf< _CharT, _Traits > * __sb)` — protected, inherited 🧚

All setup is performed here. Like, all of it. This is called from the public constructor.

It is not virtual and cannot be redefined. She's final. Periodt 👑

Okay so before we get to the next function, here's everybody who's out here referencing this constructor — it's a whole friend group, no cap 💅

Referenced by std::basic_fstream< _CharT, _Traits >::basic_fstream(),
std::basic_fstream< _CharT, _Traits >::basic_fstream(),
std::basic_fstream< _CharT, _Traits >::basic_fstream(),
std::basic_ifstream< _CharT, _Traits >::basic_ifstream(),
std::basic_ifstream< _CharT, _Traits >::basic_ifstream(),
std::basic_ifstream< _CharT, _Traits >::basic_ifstream(),
std::basic_ios< _CharT, _Traits >::basic_ios(), std::basic_istream<
_CharT, _Traits >::basic_istream(), std::basic_istringstream< _CharT,
_Traits, _Alloc >::basic_istringstream(), std::basic_istringstream<
_CharT, _Traits, _Alloc >::basic_istringstream(),
std::basic_istringstream< _CharT, _Traits, _Alloc
>::basic_istringstream(), std::basic_ofstream< _CharT, _Traits
>::basic_ofstream(), std::basic_ofstream< _CharT, _Traits
>::basic_ofstream(), std::basic_ofstream< _CharT, _Traits
>::basic_ofstream(), std::basic_ostream< _CharT, _Traits
>::basic_ostream(), std::basic_ostringstream< _CharT, _Traits, _Alloc
>::basic_ostringstream(), std::basic_ostringstream< _CharT, _Traits,
_Alloc >::basic_ostringstream(), std::basic_ostringstream< _CharT,
_Traits, _Alloc >::basic_ostringstream(), std::basic_stringstream<
_CharT, _Traits, _Alloc >::basic_stringstream(),
std::basic_stringstream< _CharT, _Traits, _Alloc
>::basic_stringstream(), and std::basic_stringstream< _CharT, _Traits,
_Alloc >::basic_stringstream().

Like, literally the entire stream family showed up. Iconic behavior honestly 🫶

`long & std::ios_base::iword (int __ix)` [inline], [inherited]

Access to integer array.

Yep, your very own integer closet ✨

Parameters

__ix — Index into the array.

Returns

A reference to an integer associated with the index.

So bestie, iword hands you an array of integers that you can use for literally any purpose you want. The array grows as required to hold whatever index you throw at it — it's giving elastic waistband energy 🌸 And every single integer in the array starts out initialized to 0.

⚠️ Two things, and I need you to hear me: the implementation reserves several indices for itself, so you should use xalloc to grab an index that's actually safe for you to touch. And because the array can grow dynamically, it is not safe to hold onto that reference — it can go poof 🫠

`char std::basic_ios< _CharT, _Traits >::narrow (char_type c, char dfault) const` [inline], [inherited]

Squeezes characters.

Not me making a character smaller 😭 it's a whole glow-down for chars.

Parameters

__c — The character to narrow.
__dfault — The character to narrow.

Returns

The narrowed character.

What it does: maps a character of char_type down to a character of char, if that's even possible 💫

It returns the result of this, exactly:

std::use_facet<ctype<char_type> >(getloc()).narrow(c,dfault)

And if you wanna get into the l10n lore, additional notes live at http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html 🧚

`std::basic_ios< _CharT, _Traits >::operator bool () const` [inline], [explicit], [inherited]

The quick-and-easy status check.

This is the vibe check for your stream, periodt ✨ It's what lets you write little baddies like if (!a_stream) ... and while (a_stream) ... — chef's kiss, so clean 🎀

References std::basic_ios< _CharT, _Traits >::fail().

`bool std::basic_ios< _CharT, _Traits >::operator! () const` [inline], [inherited]

The quick-and-easy status check.

Same energy, opposite sign 😌 You get constructs such as if (!a_stream) ... and while (a_stream) ... — yes, both of these functions exist to make exactly those two things cute.

References std::basic_ios< _CharT, _Traits >::fail().

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (__ios_type &(*)(__ios_type &) __pf)` [inline], [inherited]

Interface for manipulators.

Okay so manipulators like std::endl and std::hex use these functions in constructs like 'std::cout << std::endl' — you've literally been using them this whole time without knowing, iykyk 💅 For more info, go peek at the iomanip header 🦋

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (__ostream_type &(*)(__ostream_type &) __pf)` [inline], [inherited]

Interface for manipulators.

Round two, same slay 🎀 Manipulators such as std::endl and std::hex use these functions in constructs like 'std::cout << std::endl'. For more information, see the iomanip header ✨

`basic_ostream< _CharT, _Traits > & std::basic_ostream< _CharT, _Traits >::operator<< (__streambuf_type * __sb)` [inherited]

Extracting from another streambuf.

Sharing is caring bestie 🌈

Parameters

__sb — A pointer to a streambuf

This one behaves like one of the basic arithmetic extractors, in that it also constructs a sentry object and has the same error handling behavior 👑

🚨 If __sb is NULL, the stream will set failbit in its error state. Dead. Gone. 💀

Characters are extracted from __sb and inserted into *this until one of the following occurs:

the input stream reaches end-of-file,
insertion into the output sequence fails — in this case, the character that would have been inserted is not extracted 😭 — or
an exception occurs while getting a character from __sb, which sets failbit in the error state

And if the function inserts no characters at all? failbit gets set. Empty-handed = flagged 🙈

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (bool __n)` [inline], [inherited]

Integer arithmetic inserters.

Parameters

__n — A variable of builtin integral type.

Returns

*this if successful

These functions use the stream's current locale — specifically, the num_get facet — to do the numeric formatting 💫

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (const void * __p)` [inline], [inherited]

Pointer arithmetic inserters.

Parameters

__p — A variable of pointer type.

Returns

*this if successful

Again: these functions use the stream's current locale (specifically, the num_get facet) to perform numeric formatting 🌸

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (double __f)` [inline], [inherited]

Floating point arithmetic inserters.

Parameters

__f — A variable of builtin floating point type.

Returns

*this if successful

Current locale, num_get facet, numeric formatting — the holy trinity, no cap ✨

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (float __f)` [inline], [inherited]

Floating point arithmetic inserters.

Parameters

__f — A variable of builtin floating point type.

Returns

*this if successful

Yes, same locale / num_get facet / numeric formatting situation as its sibling 🫶

`basic_ostream< _CharT, _Traits > & std::basic_ostream< _CharT, _Traits >::operator<< (int __n)` [inherited]

Integer arithmetic inserters.

Parameters

__n — A variable of builtin integral type.

Returns

*this if successful

Locale. num_get facet. Numeric formatting. You know the drill by now bestie 💅

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (ios_base &(*)(ios_base &) __pf)` [inline], [inherited]

Interface for manipulators.

Third time's the charm 🎀 Manipulators such as std::endl and std::hex use these functions in constructs like 'std::cout << std::endl'. For more information, see the iomanip header.

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (long __n)` [inline], [inherited]

Integer arithmetic inserters.

Parameters

__n — A variable of builtin integral type.

Returns

*this if successful

Uses the stream's current locale (specifically, the num_get facet) to perform numeric formatting 🌟

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (long double __f)` [inline], [inherited]

Floating point arithmetic inserters.

Parameters

__f — A variable of builtin floating point type.

Returns

*this if successful

The long double one!! Very main character energy 👑 Uses the stream's current locale (specifically, the num_get facet) to perform numeric formatting.

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (long long __n)` [inline], [inherited]

Integer arithmetic inserters.

Parameters

__n — A variable of builtin integral type.

Returns

*this if successful

Once more, with feeling: stream's current locale, num_get facet, numeric formatting 🦋

`basic_ostream< _CharT, _Traits > & std::basic_ostream< _CharT, _Traits >::operator<< (short __n)` [inherited]

Integer arithmetic inserters.

Parameters

__n — A variable of builtin integral type.

Returns

*this if successful

These functions use the stream's current locale (specifically, the num_get facet) to perform numeric formatting 💜

References std::ios_base::badbit, std::ios_base::goodbit, and std::basic_ios< _CharT, _Traits >::setstate().

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (unsigned int __n)` [inline], [inherited]

Integer arithmetic inserters.

Parameters

__n — A variable of builtin integral type.

Returns

*this if successful

Locale + num_get facet + numeric formatting, the usual ✨

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (unsigned long __n)` [inline], [inherited]

Integer arithmetic inserters.

Parameters

__n — A variable of builtin integral type.

Returns

*this if successful

Yes, still the stream's current locale (specifically, the num_get facet) doing the numeric formatting 🎀

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (unsigned long long __n)` [inline], [inherited]

Integer arithmetic inserters.

Parameters

__n — A variable of builtin integral type.

Returns

*this if successful

The biggest unsigned baddie of them all 😤 Uses the stream's current locale (specifically, the num_get facet) to perform numeric formatting.

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (unsigned short __n)` [inline], [inherited]

Integer arithmetic inserters.

Parameters

__n — A variable of builtin integral type.

Returns

*this if successful

And the last one, our cute little unsigned short 🍓 These functions use the stream's current locale (specifically, the num_get facet) to perform numeric formatting.

The way that's literally every arithmetic inserter accounted for 💅 all present, all correct, all accounted for.

💅 `operator>>` — the manipulator ones (the `__ios_type` flavour)

template<typename _CharT , typename _Traits > __istream_type &
std::basic_istream< _CharT, _Traits >::operator>> (__ios_type &(*)(__ios_type &) __pf) [inline],  [inherited]

Okay so this is the interface for manipulators, bestie ✨ Manipulators like std::ws and std::dec literally use these functions in constructs like std::cin >> std::ws. For more information, see the iomanip header — that's where the whole manipulator party lives 🎀

🌸 `operator>>` — the other manipulator flavour (the `__istream_type` one)

template<typename _CharT , typename _Traits > __istream_type &
std::basic_istream< _CharT, _Traits >::operator>> (__istream_type &(*)(__istream_type &) __pf) [inline],  [inherited]

Same deal, different function-pointer shape 🫶 Again: interface for manipulators, manipulators such as std::ws and std::dec use these functions in constructs like std::cin >> std::ws, and for more information, see the iomanip header. Two flavours, one vibe, no cap.

🦋 `operator>>` — extracting into another streambuf

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits
> & std::basic_istream< _CharT, _Traits >::operator>> (__streambuf_type
* __sb) [inherited]

Extracting into another streambuf — it's giving relay race 🏃‍♀️

Parameters

__sb — a pointer to a streambuf.

So here's the tea: this function behaves like one of the basic arithmetic extractors, in that it also constructs a sentry object and has the same error handling behavior. Iconic consistency 💅

If __sb is NULL, the stream will set failbit in its error state. Not great, not terrible, just a fact 🫠

Characters are extracted from this stream and inserted into the __sb streambuf until one of the following occurs:

the input stream reaches end-of-file,
insertion into the output buffer fails (in this case, the character that would have been inserted is not extracted), or
an exception occurs (and in this case is caught).

If the function inserts no characters, failbit is set. That's the rules, periodt.

References: std::ios_base::eofbit, std::ios_base::failbit, std::ios_base::goodbit, std::basic_ios< _CharT, _Traits >::rdbuf(), and std::basic_ios< _CharT, _Traits >::setstate().

🔥 `operator>>` — `bool`

template<typename _CharT , typename _Traits > __istream_type &
std::basic_istream< _CharT, _Traits >::operator>> (bool & __n) [inline],
[inherited]

Integer arithmetic extractors 🧮 (yes, bool counts as an integer type here, don't come for me)

Parameters

__n — a variable of builtin integral type.

Returns: *this if successful.

These functions use the stream's current locale (specifically, the num_get facet) to parse the input data. Locale-aware parsing is lowkey the main character here 👑

🍓 `operator>>` — `double`

template<typename _CharT , typename _Traits > __istream_type &
std::basic_istream< _CharT, _Traits >::operator>> (double & __f)
[inline],  [inherited]

Floating point arithmetic extractors 🌊

Parameters

__f — a variable of builtin floating point type.

Returns: *this if successful.

These functions use the stream's current locale (specifically, the num_get facet) to parse the input data.

🌈 `operator>>` — `float`

template<typename _CharT , typename _Traits > __istream_type &
std::basic_istream< _CharT, _Traits >::operator>> (float & __f)
[inline],  [inherited]

Floating point arithmetic extractors, the smaller sibling edition 🌸

Parameters

__f — a variable of builtin floating point type.

Returns: *this if successful.

These functions use the stream's current locale (specifically, the num_get facet) to parse the input data.

⭐ `operator>>` — `int`

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits
> & std::basic_istream< _CharT, _Traits >::operator>> (int & __n)
[inherited]

Integer arithmetic extractors, the blueprint 💖

Parameters

__n — a variable of builtin integral type.

Returns: *this if successful.

These functions use the stream's current locale (specifically, the num_get facet) to parse the input data.

💜 `operator>>` — the `ios_base` manipulator flavour

template<typename _CharT , typename _Traits > __istream_type &
std::basic_istream< _CharT, _Traits >::operator>> (ios_base
&(*)(ios_base &) __pf) [inline],  [inherited]

Interface for manipulators 🎀 Manipulators such as std::ws and std::dec use these functions in constructs like std::cin >> std::ws. For more information, see the iomanip header.

🧚 `operator>>` — `long`

template<typename _CharT , typename _Traits > __istream_type &
std::basic_istream< _CharT, _Traits >::operator>> (long & __n) [inline],
[inherited]

Integer arithmetic extractors — long boi energy 🐍

Parameters

__n — a variable of builtin integral type.

Returns: *this if successful.

These functions use the stream's current locale (specifically, the num_get facet) to parse the input data.

🌟 `operator>>` — `long double`

template<typename _CharT , typename _Traits > __istream_type &
std::basic_istream< _CharT, _Traits >::operator>> (long double & __f)
[inline],  [inherited]

Floating point arithmetic extractors — the extra-precision one, she's dramatic and we love her 💅

Parameters

__f — a variable of builtin floating point type.

Returns: *this if successful.

These functions use the stream's current locale (specifically, the num_get facet) to parse the input data.

🎀 `operator>>` — `long long`

template<typename _CharT , typename _Traits > __istream_type &
std::basic_istream< _CharT, _Traits >::operator>> (long long & __n)
[inline],  [inherited]

Integer arithmetic extractors, but make it long long 🔥

Parameters

__n — a variable of builtin integral type.

Returns: *this if successful.

These functions use the stream's current locale (specifically, the num_get facet) to parse the input data.

💀 `operator>>` — `short` (the one with the extra ✨references✨)

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits
> & std::basic_istream< _CharT, _Traits >::operator>> (short & __n)
[inherited]

Integer arithmetic extractors — small type, big responsibilities 😭

Parameters

__n — a variable of builtin integral type.

Returns: *this if successful.

These functions use the stream's current locale (specifically, the num_get facet) to parse the input data.

References: std::ios_base::badbit, std::ios_base::failbit, std::ios_base::goodbit, and std::basic_ios< _CharT, _Traits >::setstate().

🫶 `operator>>` — `unsigned int`

template<typename _CharT , typename _Traits > __istream_type &
std::basic_istream< _CharT, _Traits >::operator>> (unsigned int & __n)
[inline],  [inherited]

Integer arithmetic extractors, now with no negatives allowed 🚫

Parameters

__n — a variable of builtin integral type.

Returns: *this if successful.

These functions use the stream's current locale (specifically, the num_get facet) to parse the input data.

🦋 `operator>>` — `unsigned long`

template<typename _CharT , typename _Traits > __istream_type &
std::basic_istream< _CharT, _Traits >::operator>> (unsigned long & __n)
[inline],  [inherited]

Integer arithmetic extractors, unsigned + long, she's got range 💖

Parameters

__n — a variable of builtin integral type.

Returns: *this if successful.

These functions use the stream's current locale (specifically, the num_get facet) to parse the input data.

🌸 `operator>>` — `unsigned long long`

template<typename _CharT , typename _Traits > __istream_type &
std::basic_istream< _CharT, _Traits >::operator>> (unsigned long long &
__n) [inline],  [inherited]

Integer arithmetic extractors — maximum unsigned long long energy, she ate 🔥

Parameters

__n — a variable of builtin integral type.

Returns: *this if successful.

These functions use the stream's current locale (specifically, the num_get facet) to parse the input data.

🌈 `operator>>` — `unsigned short`

template<typename _CharT , typename _Traits > __istream_type &
std::basic_istream< _CharT, _Traits >::operator>> (unsigned short & __n)
[inline],  [inherited]

Integer arithmetic extractors, tiny and unsigned, a whole vibe 🧚

Parameters

__n — a variable of builtin integral type.

Returns: *this if successful.

These functions use the stream's current locale (specifically, the num_get facet) to parse the input data.

👑 `operator>>` — `void*&`

template<typename _CharT , typename _Traits > __istream_type &
std::basic_istream< _CharT, _Traits >::operator>> (void *& __p)
[inline],  [inherited]

Basic arithmetic extractors — but it's a pointer, okay? 🤨

Parameters

__p — a variable of pointer type.

Returns: *this if successful.

These functions use the stream's current locale (specifically, the num_get facet) to parse the input data.

🎀 `peek` — looking ahead, respectfully

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits
>::int_type std::basic_istream< _CharT, _Traits >::peek (void)
[inherited]

Looking ahead in the stream 👀 — no touching, just vibes.

Returns: the next character, or eof().

If, after constructing the sentry object, good() is false, returns traits::eof(). Otherwise reads but does not extract the next input character. Respectful. Consensual. Leaves the character right where it was 🫶

References: std::basic_istream< _CharT, _Traits >::_M_gcount.

⭐ `precision()` — const flavour

streamsize std::ios_base::precision () const [inline],  [inherited]

Flags access 🔍

Returns: the precision to generate on certain output operations.

Be careful if you try to give a definition of precision here; see DR 189. (This is a real warning from the original, bestie — don't improvise 💀)

Referenced by: std::basic_ios< _CharT, _Traits >::copyfmt(), and std::chrono::operator<<().

💜 `precision(__prec)` — the setter

streamsize std::ios_base::precision (streamsize __prec) [inline],
[inherited]

Changing flags ✨

Parameters

__prec — the new precision value.

Returns: the previous value of precision(). So you get the old one back — it's a trade, not a theft 💅

🍓 `put` — simple insertion

template<typename _CharT , typename _Traits > basic_ostream< _CharT, _Traits
> & std::basic_ostream< _CharT, _Traits >::put (char_type __c)
[inherited]

Simple insertion, no thoughts, just one character going out 🌸

Parameters

__c — the character to insert.

Returns: *this

Tries to insert __c.

Note: this function is not overloaded on signed char and unsigned char. So don't @ me when your signed char doesn't match 🙈

References: std::ios_base::badbit, std::ios_base::goodbit, std::basic_ios< _CharT, _Traits >::rdbuf(), and std::basic_ios< _CharT, _Traits >::setstate().

Referenced by: std::endl(), and std::ends().

🦋 `putback` — unextracting a single character (yes, putting it BACK)

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits
> & std::basic_istream< _CharT, _Traits >::putback (char_type __c)
[inherited]

Unextracting a single character — it's giving "jk, take it back" 😭

Parameters

__c — the character to push back into the input stream.

Returns: *this

If rdbuf() is not null, calls rdbuf()->sputbackc(c).

If rdbuf() is null or if sputbackc() fails, sets badbit in the error state. Rude of it, honestly.

Note: this function first clears eofbit. Since no characters are extracted, the next call to gcount() will return 0, as required by DR 60. Very important, don't forget it 👑

References: std::basic_istream< _CharT, _Traits >::_M_gcount, std::ios_base::badbit, std::basic_ios< _CharT, _Traits >::clear(), std::ios_base::eofbit, std::ios_base::goodbit, std::basic_ios< _CharT, _Traits >::rdbuf(), std::basic_ios< _CharT, _Traits >::rdstate(), std::basic_ios< _CharT, _Traits >::setstate(), and std::basic_streambuf< _CharT, _Traits >::sputbackc().

Referenced by: std::operator<<().

🧚 `pword` — access to the void pointer array

void *& std::ios_base::pword (int __ix) [inline],  [inherited]

Access to void pointer array — the chaotic storage closet of ios_base 💀

Parameters

__ix — index into the array.

Returns: a reference to a void* associated with the index.

The pword function provides access to an array of pointers that can be used for any purpose. The array grows as required to hold the supplied index. All pointers in the array are initialized to 0.

The implementation reserves several indices. You should use xalloc to obtain an index that is safe to use. 🫶

Also note that since the array can grow dynamically, it is not safe to hold onto the reference. Seriously — don't be hoarding that reference, it'll betray you 😭

✨ `rdbuf()` — peeking at the buffer underneath 🫶

template<typename _CharT , typename _Traits > basic_streambuf< _CharT, _Traits > * std::basic_ios< _CharT, _Traits >::rdbuf () const [inline], [inherited]

Okay so this is the accessing the underlying buffer girlie. No arguments, just vibes and a pointer.

Returns — the current stream buffer. That's it. That's the whole thing.

And listen: this does not change the state of the stream. Zero side effects, a total chill pass. 💅

Referenced by — bestie, this list is long, but I'm not gonna gatekeep a single one: std::basic_istream< _CharT, _Traits >::sentry::sentry(), std::basic_ostream< _CharT, _Traits >::sentry::~sentry(), std::basic_ostream< _CharT, _Traits >::flush(), std::basic_istream< _CharT, _Traits >::get(), std::basic_istream< _CharT, _Traits >::get(), std::basic_istream< char >::get(), std::basic_istream< _CharT, _Traits >::get(), std::getline(), std::getline(), std::basic_istream< _CharT, _Traits >::ignore(), std::basic_istream< _CharT, _Traits >::ignore(), std::operator<<(), std::basic_istream< _CharT, _Traits >::operator>>(), std::operator>>(), std::operator>>(), std::operator>>(), std::tr2::operator>>(), std::basic_ostream< _CharT, _Traits >::put(), std::basic_istream< _CharT, _Traits >::putback(), std::basic_istream< _CharT, _Traits >::read(), std::basic_istream< char >::readsome(), std::basic_istream< _CharT, _Traits >::readsome(), std::basic_istream< _CharT, _Traits >::seekg(), std::basic_istream< _CharT, _Traits >::seekg(), std::basic_ostream< _CharT, _Traits >::seekp(), std::basic_ostream< _CharT, _Traits >::seekp(), std::basic_istream< _CharT, _Traits >::sync(), std::basic_istream< _CharT, _Traits >::tellg(), std::basic_ostream< _CharT, _Traits >::tellp(), and std::ws(). Yeah 💀 they're all in there. Every single one ate.

🔄 `rdbuf(__sb)` — swapping out the buffer

template<typename _CharT , typename _Traits > basic_streambuf< _CharT, _Traits > * std::basic_ios< _CharT, _Traits >::rdbuf (basic_streambuf< _CharT, _Traits > * __sb) [inherited]

Changing the underlying buffer. Main character behavior honestly.

Parameters

__sb — the new stream buffer. The fresh one. The upgrade. ✨

Returns — the previous stream buffer. She's giving "here's what it looked like before the glow-up."

It associates a new buffer with the current stream, and clears the error state.

🚨 okay bestie, this next bit is lore. Due to historical accidents which the LWG refuses to correct, the I/O library suffers from a design error: this function is hidden in derived classes by overrides of the zero-argument rdbuf(), which is non-virtual for hysterical raisins. 😭 As a result, you must use explicit qualifications to access this function via any derived class. For example:

std::fstream     foo;         // or some other derived type
std::streambuf*  p = .....;

foo.ios::rdbuf(p);            // ios == basic_ios<char>

Like... the ios:: part isn't optional, it's the whole personality. Not me defending a design error, but here we are. 🙈

🩺 `rdstate()` — the vibe check of your stream

template<typename _CharT , typename _Traits > iostate std::basic_ios< _CharT, _Traits >::rdstate () const [inline], [inherited]

Returns the error state of the stream buffer.

Returns — A bit pattern (well, isn't everything?) 💅 iconic parenthetical, no notes

See std::ios_base::iostate for the possible bit values. Most users will call one of the interpreting wrappers, e.g., good(). Like yeah, you could rawdog the bits, but the wrappers exist for a reason, bestie.

Referenced by — std::basic_ios< _CharT, _Traits >::bad(), std::basic_ios< _CharT, _Traits >::eof(), std::basic_ios< _CharT, _Traits >::fail(), std::basic_ios< _CharT, _Traits >::good(), std::basic_istream< _CharT, _Traits >::putback(), std::basic_istream< _CharT, _Traits >::seekg(), std::basic_istream< _CharT, _Traits >::seekg(), std::basic_ios< _CharT, _Traits >::setstate(), and std::basic_istream< _CharT, _Traits >::unget(). 🦋

📥 `read(s, n)` — extraction, no delimiters, no mercy

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::read (char_type * __s, streamsize __n) [inherited]

Extraction without delimiters. She does not care about your whitespace. She does not care about your \n. She takes exactly what she wants. 👑

Parameters

__s — a character array. The landing zone. 🛬
__n — maximum number of characters to store.

Returns — *this

So: if the stream state is good(), it extracts characters and stores them into __s until one of the following happens:

__n characters are stored
the input sequence reaches end-of-file, in which case the error state is set to failbit|eofbit

📌 Note — this function is not overloaded on signed char and unsigned char. Fr fr, check your types before you come crying to me. 😭

References — std::basic_istream< _CharT, _Traits >::_M_gcount, std::ios_base::badbit, std::ios_base::eofbit, std::ios_base::failbit, std::ios_base::goodbit, std::basic_ios< _CharT, _Traits >::rdbuf(), and std::basic_ios< _CharT, _Traits >::setstate().

🥄 `readsome(s, n)` — little scoop, not a whole meal

template<typename _CharT , typename _Traits > streamsize std::basic_istream< _CharT, _Traits >::readsome (char_type * __s, streamsize __n) [inherited]

Extraction until the buffer is exhausted, but no more. It's giving "eat what's on your plate, don't go grocery shopping." 🍓

Parameters

__s — a character array.
__n — maximum number of characters to store.

Returns — the number of characters extracted.

Here's the tea: it extracts characters and stores them into __s depending on the number of characters remaining in the streambuf's buffer, rdbuf()->in_avail(), called A here:

if A == -1, sets eofbit and extracts no characters
if A == 0, extracts no characters
if A > 0, extracts min(A,n)

The goal is to empty the current buffer, and to not request any more from the external input sequence controlled by the streambuf. Respect the boundary, periodt. 💅

References — std::basic_istream< _CharT, _Traits >::_M_gcount, std::ios_base::badbit, std::ios_base::eofbit, std::ios_base::goodbit, std::min(), std::basic_ios< _CharT, _Traits >::rdbuf(), and std::basic_ios< _CharT, _Traits >::setstate().

📞 `register_callback(fn, index)` — add me to the group chat

void std::ios_base::register_callback (event_callback __fn, int __index) [inherited]

Add the callback __fn with parameter __index.

Parameters

__fn — the function to add.
__index — the integer to pass to the function when invoked.

Registers a function as an event callback with an integer parameter to be passed to the function when invoked. Multiple copies of the function are allowed. And if there are multiple callbacks, they are invoked in the order they were registered — first come, first served, no queue-jumping. 🎀

🔍 `seekg(off, dir)` — repositioning the read era

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::seekg (off_type __off, ios_base::seekdir __dir) [inherited]

Changing the current read position. Teleport but for read pointers. 🌀

Parameters

__off — a file offset object.
__dir — the direction in which to seek.

Returns — *this

If fail() is not true, calls rdbuf()->pubseekoff(__off,__dir). If that function fails, sets failbit.

📌 Note — this function first clears eofbit. It does not count the number of characters extracted, if any, and therefore does not affect the next call to gcount(). Remember that, or your gcount() will gaslight you. 😭

References — std::ios_base::badbit, std::basic_ios< _CharT, _Traits >::clear(), std::ios_base::eofbit, std::basic_ios< _CharT, _Traits >::fail(), std::ios_base::failbit, std::ios_base::goodbit, std::ios_base::in, std::basic_ios< _CharT, _Traits >::rdbuf(), std::basic_ios< _CharT, _Traits >::rdstate(), and std::basic_ios< _CharT, _Traits >::setstate().

🔍 `seekg(__pos)` — same teleport, absolute coords

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::seekg (pos_type __pos) [inherited]

Changing the current read position.

Parameters

__pos — a file position object.

Returns — *this

If fail() is not true, calls rdbuf()->pubseekpos(__pos). If that function fails, sets failbit.

📌 Note — again, it first clears eofbit. It does not count the number of characters extracted, if any, and therefore does not affect the next call to gcount(). Same disclaimer, different signature, iykyk. 🫶

✍️ `seekp(off, dir)` — repositioning the write era

template<typename _CharT , typename _Traits > basic_ostream< _CharT, _Traits > & std::basic_ostream< _CharT, _Traits >::seekp (off_type __off, ios_base::seekdir __dir) [inherited]

Changing the current write position.

Parameters

__off — a file offset object.
__dir — the direction in which to seek.

Returns — *this

If fail() is not true, calls rdbuf()->pubseekoff(off,dir). If that function fails, sets failbit.

References — std::basic_ios< _CharT, _Traits >::fail(), std::ios_base::failbit, std::ios_base::out, std::basic_ios< _CharT, _Traits >::rdbuf(), and std::basic_ios< _CharT, _Traits >::setstate().

✍️ `seekp(__pos)` — absolute write coords

template<typename _CharT , typename _Traits > basic_ostream< _CharT, _Traits > & std::basic_ostream< _CharT, _Traits >::seekp (pos_type __pos) [inherited]

Changing the current write position.

Parameters

__pos — a file position object.

Returns — *this

If fail() is not true, calls rdbuf()->pubseekpos(pos). If that function fails, sets failbit.

🎛️ `setf(__fmtfl)` — adding flags, keeping the old ones

fmtflags std::ios_base::setf (fmtflags __fmtfl) [inline], [inherited]

Setting new format flags.

Parameters

__fmtfl — additional flags to set.

Returns — the previous format control flags.

This function sets additional flags in format control. Flags that were previously set remain set. It's additive, not destructive — she's not clearing anything behind your back. 💜

Referenced by — std::__detail::operator>>().

🎛️ `setf(fmtfl, mask)` — the surgical version

fmtflags std::ios_base::setf (fmtflags __fmtfl, fmtflags __mask) [inline], [inherited]

Setting new format flags.

Parameters

__fmtfl — additional flags to set.
__mask — the flags mask for fmtfl.

Returns — the previous format control flags.

Okay so this one first clears mask in the format flags, then sets fmtfl & mask. An example mask is ios_base::adjustfield. So you're not just adding, you're swapping out a whole little neighborhood of flags. Precision. 🎯

🚩 `setstate(__state)` — flagging the error state

template<typename _CharT , typename _Traits > void std::basic_ios< _CharT, _Traits >::setstate (iostate __state) [inline], [inherited]

Sets additional flags in the error state.

Parameters

__state — the additional state flag(s) to set.

See std::ios_base::iostate for the possible bit values.

References — std::basic_ios< _CharT, _Traits >::clear(), and std::basic_ios< _CharT, _Traits >::rdstate().

That's the little state-setting slay 💅 — and there's still more coming, so don't you dare close the tab. 🔥

okay so the Referenced by squad for that last one is literally a whole group chat, and we’re listing every single member:

std::basic_istream< _CharT, _Traits >::sentry::sentry()
std::basic_ostream< _CharT, _Traits >::sentry::sentry()
std::basic_ostream< _CharT, _Traits >::sentry::~sentry()
std::basic_ifstream< _CharT, _Traits >::close()
std::basic_ofstream< _CharT, _Traits >::close()
std::basic_fstream< _CharT, _Traits >::close()
std::basic_ostream< _CharT, _Traits >::flush()
std::basic_istream< _CharT, _Traits >::get()
std::basic_istream< _CharT, _Traits >::get()
std::getline()
std::getline()
std::basic_ifstream< _CharT, _Traits >::open()
std::basic_fstream< _CharT, _Traits >::open()
std::basic_ofstream< _CharT, _Traits >::open()
std::basic_ifstream< _CharT, _Traits >::open()
std::basic_fstream< _CharT, _Traits >::open()
std::basic_ofstream< _CharT, _Traits >::open()
std::operator<<()
std::basic_ostream< _CharT, _Traits >::operator<<()
std::operator<<()
std::basic_istream< _CharT, _Traits >::operator>>()
std::operator>>()
std::operator>>()
std::operator>>()
std::basic_istream< _CharT, _Traits >::operator>>()
std::tr2::operator>>()
std::basic_ostream< _CharT, _Traits >::put()
std::basic_istream< _CharT, _Traits >::putback()
std::basic_istream< _CharT, _Traits >::read()
std::basic_istream< _CharT, _Traits >::readsome()
std::basic_istream< _CharT, _Traits >::seekg()
std::basic_istream< _CharT, _Traits >::seekg()
std::basic_ostream< _CharT, _Traits >::seekp()
std::basic_ostream< _CharT, _Traits >::seekp()
std::basic_istream< _CharT, _Traits >::sync()
std::ws()

`sync` — synchronizing the stream buffer 💅

template<typename _CharT , typename _Traits > int std::basic_istream<
_CharT, _Traits >::sync (void) [inherited]

Returns — 0 on success, -1 on failure.

If rdbuf() is a null pointer, returns -1.

Otherwise, calls rdbuf()->pubsync(), and if that returns -1, sets badbit and returns -1.

Otherwise, returns 0.

Note — This function does not count the number of characters extracted, if any, and therefore does not affect the next call to gcount().

References — std::ios_base::badbit, std::ios_base::goodbit, std::basic_streambuf< _CharT, _Traits >::pubsync(), std::basic_ios< _CharT, _Traits >::rdbuf(), and std::basic_ios< _CharT, _Traits >::setstate().

`sync_with_stdio` — interaction with the standard C I/O objects 🌈

static bool std::ios_base::sync_with_stdio (bool __sync = true) [static],
[inherited]

Parameters — __sync Whether to synchronize or not.

Returns — True if the standard streams were previously synchronized.

The synchronization referred to is only that between the standard C facilities (e.g., stdout) and the standard C++ objects (e.g., cout). User-declared streams are unaffected. See https://gcc.gnu.org/onlinedocs/libstdc++/manual/fstreams.html#std.io.filestreams.binary

`tellg` — getting the current read position 🎀

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits
>::pos_type std::basic_istream< _CharT, _Traits >::tellg (void)
[inherited]

Returns — A file position object.

If fail() is not false, returns pos_type(-1) to indicate failure. Otherwise returns rdbuf()->pubseekoff(0,cur,in).

Note — This function does not count the number of characters extracted, if any, and therefore does not affect the next call to gcount(). At variance with putback, unget and seekg, eofbit is not cleared first.

References — std::ios_base::badbit, std::ios_base::cur, std::basic_ios< _CharT, _Traits >::fail(), std::ios_base::in, and std::basic_ios< _CharT, _Traits >::rdbuf().

`tellp` — getting the current write position 🦋

template<typename _CharT , typename _Traits > basic_ostream< _CharT, _Traits
>::pos_type std::basic_ostream< _CharT, _Traits >::tellp () [inherited]

Returns — A file position object.

If fail() is not false, returns pos_type(-1) to indicate failure. Otherwise returns rdbuf()->pubseekoff(0,cur,out).

References — std::ios_base::cur, std::basic_ios< _CharT, _Traits >::fail(), std::ios_base::out, and std::basic_ios< _CharT, _Traits >::rdbuf().

`tie` (const) — who’s tied to me? 👑

template<typename _CharT , typename _Traits > basic_ostream< _CharT, _Traits
> * std::basic_ios< _CharT, _Traits >::tie () const [inline],
[inherited]

Returns — A pointer to the tied stream, or NULL if the stream is not tied.

A stream may be tied (or synchronized) to a second output stream. When this stream performs any I/O, the tied stream is first flushed. For example, std::cin is tied to std::cout.

Referenced by — std::basic_istream< _CharT, _Traits >::sentry::sentry(), std::basic_ostream< _CharT, _Traits >::sentry::sentry(), and std::basic_ios< _CharT, _Traits >::copyfmt().

`tie` (setter) — tie me to your output stream 🫶

template<typename _CharT , typename _Traits > basic_ostream< _CharT, _Traits
> * std::basic_ios< _CharT, _Traits >::tie (basic_ostream< _CharT,
_Traits > * __tiestr) [inline],  [inherited]

Parameters — __tiestr The output stream.

Returns — The previously tied output stream, or NULL if the stream was not tied.

This sets up a new tie; see tie() for more.

`unget` — unextracting the previous character 😭

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits
> & std::basic_istream< _CharT, _Traits >::unget (void) [inherited]

Returns — *this

If rdbuf() is not null, calls rdbuf()->sungetc(c).

If rdbuf() is null or if sungetc() fails, sets badbit in the error state.

Note — This function first clears eofbit. Since no characters are extracted, the next call to gcount() will return 0, as required by DR 60.

References — std::basic_istream< _CharT, _Traits >::_M_gcount, std::basic_ios< _CharT, _Traits >::clear(), std::ios_base::eofbit, std::ios_base::goodbit, and std::basic_ios< _CharT, _Traits >::rdstate().

Referenced by — std::__detail::operator>>().

`unsetf` — clearing format flags 💀

void std::ios_base::unsetf (fmtflags __mask) [inline],  [inherited]

Parameters — __mask The flags to unset.

This function clears __mask in the format flags.

`widen` — widens characters ✨

template<typename _CharT , typename _Traits > char_type std::basic_ios<
_CharT, _Traits >::widen (char __c) const [inline],  [inherited]

Parameters — __c The character to widen.

Returns — The widened character.

Maps a character of char to a character of char_type.

Returns the result of

std::use_facet<ctype<char_type> >(getloc()).widen(c)

Additional l10n notes are at http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html

Referenced by — std::endl(), std::basic_ios< _CharT, _Traits >::fill(), std::basic_istream< _CharT, _Traits >::get(), std::basic_istream< _CharT, _Traits >::get(), std::getline(), std::getline(), std::basic_istream< _CharT, _Traits >::getline(), std::operator<<(), std::operator<<(), and std::tr2::operator>>().

`width` (const) — flags access 🌸

streamsize std::ios_base::width () const [inline],  [inherited]

Returns — The minimum field width to generate on output operations.

Minimum field width refers to the number of characters.

Referenced by — std::basic_ios< _CharT, _Traits >::copyfmt(), std::num_put< _CharT, _OutIter >::do_put(), std::operator>>(), and std::operator>>().

`width` (setter) — changing flags 🎀

streamsize std::ios_base::width (streamsize __wide) [inline],  [inherited]

Parameters — __wide The new width value.

Returns — The previous value of width().

`write` — character string insertion 🔥

template<typename _CharT , typename _Traits > basic_ostream< _CharT, _Traits
> & std::basic_ostream< _CharT, _Traits >::write (const char_type * __s,
streamsize __n) [inherited]

Parameters — __s The array to insert. __n Maximum number of characters to insert.

Returns — *this

Characters are copied from __s and inserted into the stream until one of the following happens:

__n characters are inserted
inserting into the output sequence fails (in this case, badbit will be set in the stream’s error state)

Note — This function is not overloaded on signed char and unsigned char.

`xalloc` — access to unique indices 🧚

static int std::ios_base::xalloc () [static],  [inherited]

Returns — An integer different from all previous calls.

This function returns a unique integer every time it is called. It can be used for any purpose, but is primarily intended to be a unique index for the iword and pword functions. The expectation is that an application calls xalloc in order to obtain an index in the iword and pword arrays that can be used without fear of conflict.

The implementation maintains a static variable that is incremented and returned on each invocation. xalloc is guaranteed to return an index that is safe to use in the iword and pword arrays.

🫶 Member Data Documentation 🫶

`_M_gcount` — the number of characters extracted in the previous unformatted function 💖

template<typename _CharT , typename _Traits > streamsize std::basic_istream<
_CharT, _Traits >::_M_gcount [protected],  [inherited]

The number of characters extracted in the previous unformatted function; see gcount().

Referenced by — std::basic_istream< _CharT, _Traits >::~basic_istream(), std::basic_istream< _CharT, _Traits >::gcount(), std::basic_istream< _CharT, _Traits >::get(), std::basic_istream< _CharT, _Traits >::get(), std::basic_istream< _CharT, _Traits >::get(), std::basic_istream< _CharT, _Traits >::get(), std::basic_istream< char >::get(), std::basic_istream< char >::ignore(), std::basic_istream< _CharT, _Traits >::ignore(), std::basic_istream< _CharT, _Traits >::ignore(), std::basic_istream< char >::operator>>(), std::basic_istream< _CharT, _Traits >::peek(), std::basic_istream< _CharT, _Traits >::putback(), std::basic_istream< char >::putback(), std::basic_istream< _CharT, _Traits >::read(), std::basic_istream< _CharT, _Traits >::readsome(), std::basic_istream< char >::readsome(), std::basic_istream< char >::sync(), and std::basic_istream< _CharT, _Traits >::unget().

`adjustfield` — a mask of `left|right|internal` 🎀

const fmtflags std::ios_base::adjustfield [static],  [inherited]

A mask of left|right|internal. Useful for the 2-arg form of setf.

Referenced by — std::num_put< _CharT, _OutIter >::do_put(), std::internal(), std::left(), and std::right().

`app` — seek to end before each write 🌈

const openmode std::ios_base::app [static],  [inherited]

Seek to end before each write.

Referenced by — std::basic_filebuf< _CharT, _Traits >::_M_set_buffer(), std::basic_filebuf< _CharT, _Traits >::overflow(), and std::basic_filebuf< _CharT, _Traits >::xsputn().

`ate` — open and seek to end immediately after opening 🦋

const openmode std::ios_base::ate [static],  [inherited]

Open and seek to end immediately after opening.

Referenced by — std::basic_filebuf< _CharT, _Traits >::open().

`badbit` — loss of integrity, bestie 💀

const iostate std::ios_base::badbit [static],  [inherited]

Indicates a loss of integrity in an input or output sequence (such as an irrecoverable read error from a file).

(…continuing that reference list from the last one, because it is LONG and I refuse to cut a single entry 💀)

Referenced by std::basic_istream< _CharT, _Traits >::sentry::sentry(), std::basic_ostream< _CharT, _Traits >::sentry::~sentry(), std::basic_ios< _CharT, _Traits >::bad(), std::basic_ios< _CharT, _Traits >::fail(), std::basic_ostream< _CharT, _Traits >::flush(), std::basic_istream< _CharT, _Traits >::get(), std::basic_istream< char >::get(), std::basic_istream< _CharT, _Traits >::get(), std::basic_ostream< _CharT, _Traits >::operator<<(), std::operator>>(), std::basic_istream< _CharT, _Traits >::operator>>(), std::basic_ostream< _CharT, _Traits >::put(), std::basic_istream< _CharT, _Traits >::putback(), std::basic_istream< _CharT, _Traits >::read(), std::basic_istream< _CharT, _Traits >::readsome(), std::basic_istream< char >::seekg(), std::basic_istream< _CharT, _Traits >::seekg(), std::basic_istream< _CharT, _Traits >::seekg(), std::basic_istream< _CharT, _Traits >::sync(), std::basic_istream< char >::tellg(), std::basic_istream< _CharT, _Traits >::tellg(), and std::ws().

const fmtflags std::ios_base::basefield [static], [inherited] — bestie this one is literally just a mask of dec|oct|hex. Super useful for the 2-arg form of setf. That's the whole vibe. ✨
- Referenced by std::dec(), std::num_get< _CharT, _InIter >::do_get(), std::num_put< _CharT, _OutIter >::do_put(), std::hex(), and std::oct().
const seekdir std::ios_base::beg [static], [inherited] — "take me to the beginning of the stream" energy 🎀. It's a request to seek relative to the start of the sequence.
- Referenced by std::basic_filebuf< _CharT, _Traits >::seekpos().
const openmode std::ios_base::binary [static], [inherited] — does input and output in binary mode instead of text mode. And okay, listen: this is probably not what you think it is 😭. For real, go read https://gcc.gnu.org/onlinedocs/libstdc++/manual/fstreams.html#std.io.filestreams.binary before you start assuming things, iykyk.
- Referenced by std::basic_filebuf< _CharT, _Traits >::showmanyc().
const fmtflags std::ios_base::boolalpha [static], [inherited] — inserts/extracts a bool in alphabetic format instead of numeric. So you get the actual words, not just 1 and 0. Obsessed tbh 💜
- Referenced by std::boolalpha(), std::num_get< _CharT, _InIter >::do_get(), std::num_put< _CharT, _OutIter >::do_put(), and std::noboolalpha().
const seekdir std::ios_base::cur [static], [inherited] — seek relative to wherever you currently are in the sequence. Stay where you're at, basically 🦋
- Referenced by std::basic_filebuf< _CharT, _Traits >::imbue(), std::basic_filebuf< _CharT, _Traits >::overflow(), std::basic_filebuf< _CharT, _Traits >::pbackfail(), std::basic_filebuf< _CharT, _Traits >::seekoff(), std::basic_stringbuf< _CharT, _Traits, _Alloc >::seekoff(), std::basic_istream< _CharT, _Traits >::tellg(), and std::basic_ostream< _CharT, _Traits >::tellp().
const fmtflags std::ios_base::dec [static], [inherited] — converts integer input, or generates integer output, in decimal base. The default default, the main character of bases fr.
- Referenced by std::dec().
const seekdir std::ios_base::end [static], [inherited] — seek relative to the current end of the sequence. End-of-the-line core 🌸
- Referenced by std::basic_filebuf< _CharT, _Traits >::open(), and std::basic_stringbuf< _CharT, _Traits, _Alloc >::seekoff().
const iostate std::ios_base::eofbit [static], [inherited] — flags that an input operation hit the end of an input sequence. The "no more content bestie, we're done here" bit 😭. The reference list on this one is genuinely unhinged, buckle up:
- Referenced by std::basic_istream< _CharT, _Traits >::sentry::sentry(), std::time_get< _CharT, _InIter >::do_get(), std::num_get< _CharT, _InIter >::do_get(), std::num_get< _CharT, _InIter >::do_get(), std::num_get< _CharT, _InIter >::do_get(), std::num_get< _CharT, _InIter >::do_get(), std::time_get< _CharT, _InIter >::do_get_date(), std::time_get< _CharT, _InIter >::do_get_monthname(), std::time_get< _CharT, _InIter >::do_get_time(), std::time_get< _CharT, _InIter >::do_get_weekday(), std::time_get< _CharT, _InIter >::do_get_year(), std::basic_ios< _CharT, _Traits >::eof(), std::basic_istream< _CharT, _Traits >::get(), std::basic_istream< _CharT, _Traits >::get(), std::basic_istream< char >::get(), std::time_get< _CharT, _InIter >::get(), std::basic_istream< _CharT, _Traits >::ignore(), std::basic_istream< _CharT, _Traits >::operator>>(), std::operator>>(), std::basic_istream< _CharT, _Traits >::putback(), std::basic_istream< _CharT, _Traits >::read(), std::basic_istream< _CharT, _Traits >::readsome(), std::basic_istream< _CharT, _Traits >::seekg(), std::basic_istream< _CharT, _Traits >::seekg(), std::basic_istream< char >::sync(), std::basic_istream< _CharT, _Traits >::unget(), and std::ws().
const iostate std::ios_base::failbit [static], [inherited] — flags that an input operation failed to read the characters it expected, or that an output operation failed to generate the characters you wanted. Either way it's giving "something went wrong" 💀 and you're gonna feel it.
- Referenced by std::basic_istream< _CharT, _Traits >::sentry::sentry(), std::basic_ostream< _CharT, _Traits >::sentry::sentry(), std::basic_ifstream< _CharT, _Traits >::close(), std::basic_ofstream< _CharT, _Traits >::close(), std::basic_fstream< _CharT, _Traits >::close(), std::num_get< _CharT, _InIter >::do_get(), std::time_get< _CharT, _InIter >::do_get_monthname(), std::time_get< _CharT, _InIter >::do_get_weekday(), std::time_get< _CharT, _InIter >::do_get_year(), std::basic_ios< _CharT, _Traits >::fail(), std::basic_istream< _CharT, _Traits >::get(), std::basic_istream< _CharT, _Traits >::get(), std::basic_istream< char >::get(), std::time_get< _CharT, _InIter >::get(), std::basic_ifstream< _CharT, _Traits >::open(), std::basic_fstream< _CharT, _Traits >::open(), std::basic_ofstream< _CharT, _Traits >::open(), std::basic_ifstream< _CharT, _Traits >::open(), std::basic_fstream< _CharT, _Traits >::open(), std::basic_ofstream< _CharT, _Traits >::open(), std::operator<<(), std::basic_istream< _CharT, _Traits >::operator>>(), std::operator>>(), std::basic_istream< _CharT, _Traits >::operator>>(), std::basic_istream< _CharT, _Traits >::read(), std::basic_istream< _CharT, _Traits >::seekg(), std::basic_istream< _CharT, _Traits >::seekg(), std::basic_ostream< _CharT, _Traits >::seekp(), and std::basic_ostream< _CharT, _Traits >::seekp().
const fmtflags std::ios_base::fixed [static], [inherited] — generates floating-point output in fixed-point notation 🎀. Classic, dependable, does not do the exponent thing.
- Referenced by std::fixed(), and std::hexfloat().
const fmtflags std::ios_base::floatfield [static], [inherited] — a mask of scientific|fixed. Again, bestie, it's for the 2-arg form of setf. That's the whole point of these masks ✨
- Referenced by std::defaultfloat(), std::fixed(), std::hexfloat(), and std::scientific().
const iostate std::ios_base::goodbit [static], [inherited] — indicates all is well 🫶. The "we're so back" bit. No errors, no drama, just vibes. Its reference list is also enormous, so:
- Referenced by std::basic_istream< _CharT, _Traits >::sentry::sentry(), std::time_get< _CharT, _InIter >::do_get(), std::num_get< _CharT, _InIter >::do_get(), std::time_get< _CharT, _InIter >::do_get_monthname(), std::time_get< _CharT, _InIter >::do_get_weekday(), std::time_get< _CharT, _InIter >::do_get_year(), std::basic_ostream< _CharT, _Traits >::flush(), std::basic_istream< _CharT, _Traits >::get(), std::basic_istream< _CharT, _Traits >::get(), std::basic_istream< _CharT, _Traits >::get(), std::basic_istream< char >::get(), std::basic_istream< _CharT, _Traits >::get(), std::time_get< _CharT, _InIter >::get(), std::basic_istream< _CharT, _Traits >::ignore(), std::basic_istream< _CharT, _Traits >::ignore(), std::basic_ostream< _CharT, _Traits >::operator<<(), std::basic_istream< _CharT, _Traits >::operator>>(), std::operator>>(), std::basic_istream< _CharT, _Traits >::operator>>(), std::basic_ostream< _CharT, _Traits >::put(), std::basic_istream< _CharT, _Traits >::putback(), std::basic_istream< _CharT, _Traits >::read(), std::basic_istream< _CharT, _Traits >::readsome(), std::basic_istream< char >::readsome(), std::basic_istream< _CharT, _Traits >::seekg(), std::basic_istream< _CharT, _Traits >::seekg(), std::basic_istream< _CharT, _Traits >::sync(), std::basic_istream< _CharT, _Traits >::unget(), and std::ws().
const fmtflags std::ios_base::hex [static], [inherited] — converts integer input, or generates integer output, in hexadecimal base. Base 16 slay 🔥
- Referenced by std::num_get< _CharT, _InIter >::do_get(), std::num_put< _CharT, _OutIter >::do_put(), and std::hex().
const openmode std::ios_base::in [static], [inherited] — open for input 📥. This is the default for ifstream and fstream, no cap.
- Referenced by std::basic_filebuf< _CharT, _Traits >::_M_set_buffer(), std::basic_ifstream< _CharT, _Traits >::open(), std::basic_ifstream< _CharT, _Traits >::open(), std::basic_stringbuf< _CharT, _Traits, _Alloc >::overflow(), std::basic_filebuf< _CharT, _Traits >::pbackfail(), std::basic_istream< _CharT, _Traits >::seekg(), std::basic_istream< _CharT, _Traits >::seekg(), std::basic_stringbuf< _CharT, _Traits, _Alloc >::seekoff(), std::basic_stringbuf< _CharT, _Traits, _Alloc >::seekpos(), std::basic_filebuf< _CharT, _Traits >::showmanyc(), std::basic_stringbuf< _CharT, _Traits, _Alloc >::showmanyc(), std::basic_istream< _CharT, _Traits >::tellg(), std::basic_filebuf< _CharT, _Traits >::underflow(), std::basic_stringbuf< _CharT, _Traits, _Alloc >::underflow(), and std::basic_filebuf< _CharT, _Traits >::xsgetn().
const fmtflags std::ios_base::internal [static], [inherited] — adds fill characters at a designated internal point in certain generated output — or, if no such point got designated, it behaves identically to right. Same thing, different font 💅
- Referenced by std::internal().
const fmtflags std::ios_base::left [static], [inherited] — adds fill characters on the right (the final positions) of certain generated output. Translation: the thing you print is flush left. Left-aligned girlies rise 🌸
- Referenced by std::num_put< _CharT, _OutIter >::do_put(), and std::left().
const fmtflags std::ios_base::oct [static], [inherited] — converts integer input, or generates integer output, in octal base. Base 8, the quirky one, we love her.
- Referenced by std::oct().
const openmode std::ios_base::out [static], [inherited] — open for output 📤. Default for ofstream and fstream. Periodt.
- Referenced by std::basic_filebuf< _CharT, _Traits >::_M_set_buffer(), std::basic_ofstream< _CharT, _Traits >::open(), std::basic_ofstream< _CharT, _Traits >::open(), std::basic_filebuf< _CharT, _Traits >::overflow(), std::basic_stringbuf< _CharT, _Traits, _Alloc >::overflow(), std::basic_stringbuf< _CharT, _Traits, _Alloc >::pbackfail(), std::basic_stringbuf< _CharT, _Traits, _Alloc >::seekoff(), std::basic_ostream< _CharT, _Traits >::seekp(), std::basic_ostream< _CharT, _Traits >::seekp(), std::basic_stringbuf< _CharT, _Traits, _Alloc >::seekpos(), std::basic_ostream< _CharT, _Traits >::tellp(), and std::basic_filebuf< _CharT, _Traits >::xsputn().
const fmtflags std::ios_base::right [static], [inherited] — adds fill characters on the left (the initial positions) of certain generated output. So the thing you print is flush right. Iconic mirror moment 🪞
- Referenced by std::right().
const fmtflags std::ios_base::scientific [static], [inherited] — generates floating-point output in scientific notation 🧚. Exponents, but make it fashion.
- Referenced by std::hexfloat(), and std::scientific().
const fmtflags std::ios_base::showbase [static], [inherited] — generates a prefix that indicates the numeric base of generated integer output. Like a little name tag for your number's base 🎀

First up, the tail end of the previous entry: it's referenced by std::num_put< _CharT, _OutIter >::do_put(), std::noshowbase(), and std::showbase(). 🫶

`const fmtflags std::ios_base::showpoint` `[static]`, `[inherited]`

This one generates a decimal-point character unconditionally in generated floating-point output. No vibes-based decimal points here — it's always showing up. 💖

Referenced by std::noshowpoint(), and std::showpoint().

`const fmtflags std::ios_base::showpos` `[static]`, `[inherited]`

Generates a + sign in non-negative generated numeric output. Positive numbers get their little plus moment, periodt. ✨

Referenced by std::noshowpos(), and std::showpos().

`const fmtflags std::ios_base::skipws` `[static]`, `[inherited]`

Skips leading white space before certain input operations. It's giving polite little input cleanup before the real reading starts. 🎀

Referenced by std::basic_istream< _CharT, _Traits >::sentry::sentry(), std::noskipws(), std::__detail::operator>>(), and std::skipws().

`const openmode std::ios_base::trunc` `[static]`, `[inherited]`

Truncate an existing stream when opening. It's the default for ofstream. So yeah, opening can absolutely wipe the existing stream — that's the whole point, bestie. 💅

`const fmtflags std::ios_base::unitbuf` `[static]`, `[inherited]`

Flushes output after each output operation. Every single operation gets its own little flush moment. 🦋

Referenced by std::basic_ostream< _CharT, _Traits >::sentry::~sentry(), std::nounitbuf(), and std::unitbuf().

`const fmtflags std::ios_base::uppercase` `[static]`, `[inherited]`

Replaces certain lowercase letters with their uppercase equivalents in generated output. Lowercase letters are not the main character here. 👑

Referenced by std::num_put< _CharT, _OutIter >::do_put(), std::nouppercase(), and std::uppercase().

👑 Author 👑

Generated automatically by Doxygen for libstdc++ from the source code.

Sign-off time: this page is stamped with the libstdc++ source/version vibe, and the date is right there in the footer, bestie — peep it down there. 🎀💜🌸

📦 where this page comes from

ubuntu noble: libstdc++-14-doc 14-20240412-0ubuntu1
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-06: a language model's rewrite of the original, under its terms

STD::IOSTREAM(3cxx)

💖 std::basic_iostream< _CharT, _Traits > from 3cxx 💖

✨ NAME ✨

🦋 SYNOPSIS 🦋

🎀 Public Types 🎀

🌸 Public Member Functions 🌸

⭐ Extractors ⭐

🦋 Unformatted Input Functions 🦋

🎀 Inserters 🎀

🦋 Unformatted Output Functions 🦋

👑 Static Public Member Functions 👑

🌸 Static Public Attributes 🌸

🧚 Protected Types 🧚

🎀 Protected Member Functions 🎀

💜 Protected Attributes 💜

⭐ Detailed Description ⭐

🎀 Member Typedef Documentation 🎀

🌸 Member Enumeration Documentation 🌸

💜 enum std::ios_base::event [inherited]

✨ Constructor & Destructor Documentation ✨

🫶 template<typename _CharT , typename _Traits > std::basic_iostream< _CharT, _Traits >::basic_iostream (basic_streambuf< _CharT, _Traits > * __sb) [inline], [explicit]

🫶 template<typename _CharT , typename _Traits > virtual std::basic_iostream< _CharT, _Traits >::~basic_iostream () [inline], [virtual]

⭐ Member Function Documentation ⭐

🌈 const locale & std::ios_base::_M_getloc () const [inline], [inherited]

🌈 template<typename _CharT , typename _Traits > bool std::basic_ios< _CharT, _Traits >::bad () const [inline], [inherited]

🌈 template<typename _CharT , typename _Traits > void std::basic_ios< _CharT, _Traits >::clear (iostate __state = goodbit) [inherited]

🌈 template<typename _CharT , typename _Traits > basic_ios< _CharT, _Traits > & std::basic_ios< _CharT, _Traits >::copyfmt (const basic_ios< _CharT, _Traits > & __rhs) [inherited]

🌈 template<typename _CharT , typename _Traits > bool std::basic_ios< _CharT, _Traits >::eof () const [inline], [inherited]

🌈 template<typename _CharT , typename _Traits > iostate std::basic_ios< _CharT, _Traits >::exceptions () const [inline], [inherited]

🌈 template<typename _CharT , typename _Traits > void std::basic_ios< _CharT, _Traits >::exceptions (iostate __except) [inline], [inherited]

🌈 template<typename _CharT , typename _Traits > bool std::basic_ios< _CharT, _Traits >::fail () const [inline], [inherited]

🌈 template<typename _CharT , typename _Traits > char_type std::basic_ios< _CharT, _Traits >::fill () const [inline], [inherited]

🌈 template<typename _CharT , typename _Traits > char_type std::basic_ios< _CharT, _Traits >::fill (char_type __ch) [inline], [inherited]

🌈 fmtflags std::ios_base::flags () const [inline], [inherited]

🌈 fmtflags std::ios_base::flags (fmtflags __fmtfl) [inline], [inherited]

template<typename _CharT , typename _Traits > basic_ostream< _CharT, _Traits > & std::basic_ostream< _CharT, _Traits >::flush () — inherited 💅

template<typename _CharT , typename _Traits > streamsize std::basic_istream< _CharT, _Traits >::gcount () const — inline, inherited ✨

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits >::int_type std::basic_istream< _CharT, _Traits >::get (void) — inherited 🦋

template<typename _CharT , typename _Traits > __istream_type & std::basic_istream< _CharT, _Traits >::get (__streambuf_type & __sb) — inline, inherited 🎀

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::get (__streambuf_type & __sb, char_type __delim) — inherited 🌸

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::get (char_type & __c) — inherited 🧚

template<typename _CharT , typename _Traits > __istream_type & std::basic_istream< _CharT, _Traits >::get (char_type * __s, streamsize __n) — inline, inherited 🍓

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::get (char_type * __s, streamsize __n, char_type __delim) — inherited 👑

template<typename _CharT , typename _Traits > __istream_type & std::basic_istream< _CharT, _Traits >::getline (char_type * __s, streamsize __n) — inline, inherited 🌈

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::getline (char_type * __s, streamsize __n, char_type __delim) — inherited 💜

basic_istream< char > & std::basic_istream< char >::getline (char_type * __s, streamsize __n, char_type __delim) — inherited ⭐

locale std::ios_base::getloc () const — inline, inherited 🦋

template<typename _CharT , typename _Traits > bool std::basic_ios< _CharT, _Traits >::good () const — inline, inherited 🫶

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::ignore (void) — inherited 🌸

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::ignore (streamsize __n) — inherited 🎀

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::ignore (streamsize __n, int_type __delim) — inherited 🔥

template<typename _CharT , typename _Traits > locale std::basic_ios< _CharT, _Traits >::imbue (const locale & __loc) — inherited 🌍

template<typename _CharT , typename _Traits > void std::basic_ios< _CharT, _Traits >::init (basic_streambuf< _CharT, _Traits > * __sb) — protected, inherited 🧚

long & std::ios_base::iword (int __ix)</p> [inline], [inherited]

char std::basic_ios< _CharT, _Traits >::narrow (char_type __c, char __dfault) const</p> [inline], [inherited]

std::basic_ios< _CharT, _Traits >::operator bool () const</p> [inline], [explicit], [inherited]

bool std::basic_ios< _CharT, _Traits >::operator! () const</p> [inline], [inherited]

__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (__ios_type &(*)(__ios_type &) __pf)</p> [inline], [inherited]

__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (__ostream_type &(*)(__ostream_type &) __pf)</p> [inline], [inherited]

basic_ostream< _CharT, _Traits > & std::basic_ostream< _CharT, _Traits >::operator<< (__streambuf_type * __sb)</p> [inherited]

__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (bool __n)</p> [inline], [inherited]

__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (const void * __p)</p> [inline], [inherited]

__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (double __f)</p> [inline], [inherited]

__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (float __f)</p> [inline], [inherited]

basic_ostream< _CharT, _Traits > & std::basic_ostream< _CharT, _Traits >::operator<< (int __n)</p> [inherited]

__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (ios_base &(*)(ios_base &) __pf)</p> [inline], [inherited]

__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (long __n)</p> [inline], [inherited]

__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (long double __f)</p> [inline], [inherited]

__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (long long __n)</p> [inline], [inherited]

basic_ostream< _CharT, _Traits > & std::basic_ostream< _CharT, _Traits >::operator<< (short __n)</p> [inherited]

__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (unsigned int __n)</p> [inline], [inherited]

__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (unsigned long __n)</p> [inline], [inherited]

__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (unsigned long long __n)</p> [inline], [inherited]

__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (unsigned short __n)</p> [inline], [inherited]

💅 operator>> — the manipulator ones (the __ios_type flavour)

🌸 operator>> — the other manipulator flavour (the __istream_type one)

🦋 operator>> — extracting into another streambuf

🔥 operator>> — bool

🍓 operator>> — double

🌈 operator>> — float

💖 `std::basic_iostream< _CharT, _Traits >` from `3cxx` 💖

💜 `enum std::ios_base::event` `[inherited]`

🫶 `template<typename _CharT , typename _Traits > std::basic_iostream< _CharT, _Traits >::basic_iostream (basic_streambuf< _CharT, _Traits > * __sb)` `[inline]`, `[explicit]`

🫶 `template<typename _CharT , typename _Traits > virtual std::basic_iostream< _CharT, _Traits >::~basic_iostream ()` `[inline]`, `[virtual]`

🌈 `const locale & std::ios_base::_M_getloc () const` `[inline]`, `[inherited]`

🌈 `template<typename _CharT , typename _Traits > bool std::basic_ios< _CharT, _Traits >::bad () const` `[inline]`, `[inherited]`

🌈 `template<typename _CharT , typename _Traits > void std::basic_ios< _CharT, _Traits >::clear (iostate __state = goodbit)` `[inherited]`

🌈 `template<typename _CharT , typename _Traits > basic_ios< _CharT, _Traits > & std::basic_ios< _CharT, _Traits >::copyfmt (const basic_ios< _CharT, _Traits > & __rhs)` `[inherited]`

🌈 `template<typename _CharT , typename _Traits > bool std::basic_ios< _CharT, _Traits >::eof () const` `[inline]`, `[inherited]`

🌈 `template<typename _CharT , typename _Traits > iostate std::basic_ios< _CharT, _Traits >::exceptions () const` `[inline]`, `[inherited]`

🌈 `template<typename _CharT , typename _Traits > void std::basic_ios< _CharT, _Traits >::exceptions (iostate __except)` `[inline]`, `[inherited]`

🌈 `template<typename _CharT , typename _Traits > bool std::basic_ios< _CharT, _Traits >::fail () const` `[inline]`, `[inherited]`

🌈 `template<typename _CharT , typename _Traits > char_type std::basic_ios< _CharT, _Traits >::fill () const` `[inline]`, `[inherited]`

🌈 `template<typename _CharT , typename _Traits > char_type std::basic_ios< _CharT, _Traits >::fill (char_type __ch)` `[inline]`, `[inherited]`

🌈 `fmtflags std::ios_base::flags () const` `[inline]`, `[inherited]`

🌈 `fmtflags std::ios_base::flags (fmtflags __fmtfl)` `[inline]`, `[inherited]`

`template<typename _CharT , typename _Traits > basic_ostream< _CharT, _Traits > & std::basic_ostream< _CharT, _Traits >::flush ()` — inherited 💅

`template<typename _CharT , typename _Traits > streamsize std::basic_istream< _CharT, _Traits >::gcount () const` — inline, inherited ✨

`template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits >::int_type std::basic_istream< _CharT, _Traits >::get (void)` — inherited 🦋

`template<typename _CharT , typename _Traits > __istream_type & std::basic_istream< _CharT, _Traits >::get (__streambuf_type & __sb)` — inline, inherited 🎀

`template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::get (__streambuf_type & __sb, char_type __delim)` — inherited 🌸

`template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::get (char_type & __c)` — inherited 🧚

`template<typename _CharT , typename _Traits > __istream_type & std::basic_istream< _CharT, _Traits >::get (char_type * s, streamsize n)` — inline, inherited 🍓

`template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::get (char_type * s, streamsize n, char_type __delim)` — inherited 👑

`template<typename _CharT , typename _Traits > __istream_type & std::basic_istream< _CharT, _Traits >::getline (char_type * s, streamsize n)` — inline, inherited 🌈

`template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::getline (char_type * s, streamsize n, char_type __delim)` — inherited 💜

`basic_istream< char > & std::basic_istream< char >::getline (char_type * s, streamsize n, char_type __delim)` — inherited ⭐

`locale std::ios_base::getloc () const` — inline, inherited 🦋

`template<typename _CharT , typename _Traits > bool std::basic_ios< _CharT, _Traits >::good () const` — inline, inherited 🫶

`template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::ignore (void)` — inherited 🌸

`template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::ignore (streamsize __n)` — inherited 🎀

`template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::ignore (streamsize __n, int_type __delim)` — inherited 🔥

`template<typename _CharT , typename _Traits > locale std::basic_ios< _CharT, _Traits >::imbue (const locale & __loc)` — inherited 🌍

`template<typename _CharT , typename _Traits > void std::basic_ios< _CharT, _Traits >::init (basic_streambuf< _CharT, _Traits > * __sb)` — protected, inherited 🧚

`long & std::ios_base::iword (int __ix)`</p> [inline], [inherited]

`char std::basic_ios< _CharT, _Traits >::narrow (char_type c, char dfault) const`</p> [inline], [inherited]

`std::basic_ios< _CharT, _Traits >::operator bool () const`</p> [inline], [explicit], [inherited]

`bool std::basic_ios< _CharT, _Traits >::operator! () const`</p> [inline], [inherited]

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (__ios_type &(*)(__ios_type &) __pf)`</p> [inline], [inherited]

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (__ostream_type &(*)(__ostream_type &) __pf)`</p> [inline], [inherited]

`basic_ostream< _CharT, _Traits > & std::basic_ostream< _CharT, _Traits >::operator<< (__streambuf_type * __sb)`</p> [inherited]

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (bool __n)`</p> [inline], [inherited]

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (const void * __p)`</p> [inline], [inherited]

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (double __f)`</p> [inline], [inherited]

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (float __f)`</p> [inline], [inherited]

`basic_ostream< _CharT, _Traits > & std::basic_ostream< _CharT, _Traits >::operator<< (int __n)`</p> [inherited]

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (ios_base &(*)(ios_base &) __pf)`</p> [inline], [inherited]

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (long __n)`</p> [inline], [inherited]

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (long double __f)`</p> [inline], [inherited]

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (long long __n)`</p> [inline], [inherited]

`basic_ostream< _CharT, _Traits > & std::basic_ostream< _CharT, _Traits >::operator<< (short __n)`</p> [inherited]

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (unsigned int __n)`</p> [inline], [inherited]

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (unsigned long __n)`</p> [inline], [inherited]

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (unsigned long long __n)`</p> [inline], [inherited]

`__ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (unsigned short __n)`</p> [inline], [inherited]

💅 `operator>>` — the manipulator ones (the `__ios_type` flavour)

🌸 `operator>>` — the other manipulator flavour (the `__istream_type` one)

🦋 `operator>>` — extracting into another streambuf

🔥 `operator>>` — `bool`

🍓 `operator>>` — `double`

🌈 `operator>>` — `float`

⭐ `operator>>` — `int`

💜 `operator>>` — the `ios_base` manipulator flavour

🧚 `operator>>` — `long`

🌟 `operator>>` — `long double`

🎀 `operator>>` — `long long`

💀 `operator>>` — `short` (the one with the extra ✨references✨)

🫶 `operator>>` — `unsigned int`

🦋 `operator>>` — `unsigned long`

🌸 `operator>>` — `unsigned long long`

🌈 `operator>>` — `unsigned short`

👑 `operator>>` — `void*&`

🎀 `peek` — looking ahead, respectfully

⭐ `precision()` — const flavour

💜 `precision(__prec)` — the setter

🍓 `put` — simple insertion

🦋 `putback` — unextracting a single character (yes, putting it BACK)

🧚 `pword` — access to the void pointer array

✨ `rdbuf()` — peeking at the buffer underneath 🫶

🔄 `rdbuf(__sb)` — swapping out the buffer