STD::OSTRINGSTREAM(3cxx)

📦

version 14-20240412 · 25 versions

🌸 NAME 🌸

This is the page for std::basic_ostringstream< _CharT, _Traits, _Alloc > in the (3cxx) manual, bestie. Its whole job? Controlling output for std::string. That's the vibe, that's the mission. 🎀

✨ SYNOPSIS ✨

#include <sstream>

Inherits std::basic_ostream< _CharT, _Traits >.

🎀 Public Types 🎀

The type-alias wardrobe is right here — every single one, no skips:

typedef ctype< _CharT > __ctype_type — Listed with no extra note in the source.
typedef basic_ios< _CharT, _Traits > __ios_type — Listed with no extra note in the source.
typedef num_put< _CharT, ostreambuf_iterator< _CharT, _Traits > > __num_put_type — Listed with no extra note in the source.
typedef basic_ostream< char_type, traits_type > __ostream_type — Listed with no extra note in the source.
typedef basic_streambuf< _CharT, _Traits > __streambuf_type — Listed with no extra note in the source.
typedef basic_string< _CharT, _Traits, _Alloc > __string_type — Listed with no extra note in the source.
typedef basic_stringbuf< _CharT, _Traits, _Alloc > __stringbuf_type — Listed with no extra note in the source.
typedef _Alloc allocator_type — Listed with no extra note in the source.
typedef _CharT char_type — Listed with no extra note in the source.
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_type::int_type int_type — Listed with no extra note in the source.
typedef _Ios_Iostate iostate — This is a bitmask type.
typedef traits_type::off_type off_type — Listed with no extra note in the source.
typedef _Ios_Openmode openmode — This is a bitmask type.
typedef traits_type::pos_type pos_type — Listed with no extra note in the source.
typedef _Ios_Seekdir seekdir — This is an enumerated type.
typedef _Traits traits_type — Listed with no extra note in the source.
typedef num_get< _CharT, istreambuf_iterator< _CharT, _Traits > > __num_get_type — Listed with no extra note in the source.

💅 Public Member Functions 💅

Okay, here's the full member-function lineup, in order, no disappearing acts:

basic_ostringstream () — Default constructor starts with an empty string buffer.
basic_ostringstream (basic_ostringstream &&__rhs) — Listed with no extra note in the source.
basic_ostringstream (const __string_type &__str, ios_base::openmode __mode=ios_base::out) — Starts with an existing string buffer.
basic_ostringstream (const basic_ostringstream &)=delete — Listed as =delete; no extra note in the source.
basic_ostringstream (ios_base::openmode __mode) — Starts with an empty string buffer.
~basic_ostringstream () — The destructor does nothing. Literally nothing. Iconic.
const locale & _M_getloc () const — Locale access.
template<typename _ValueT > basic_ostream< _CharT, _Traits > & _M_insert (_ValueT __v) — Listed with no extra note in the source.
void _M_setstate (iostate __state) — Listed with no extra note in the source.
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.
locale getloc () const — Locale access.
bool good () const — Fast error checking.
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) — Listed with no extra note in the source.
basic_ostringstream & operator= (basic_ostringstream &&__rhs) — Listed with no extra note in the source.
basic_ostringstream & operator= (const basic_ostringstream &)=delete — Listed as =delete; no extra note in the source.
streamsize precision () const — Flags access.
streamsize precision (streamsize __prec) — Changing flags.
void *& pword (int __ix) — Access to void pointer array.
__stringbuf_type * 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.
__string_type str () const — Copying out the string buffer.
void str (const __string_type &__s) — Setting a new buffer.
void swap (basic_ostringstream &__rhs) — Listed with no extra note in the source.
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.
basic_string_view< char_type, traits_type > view () const noexcept — Listed with no extra note in the source.
char_type widen (char __c) const — Widens characters.
streamsize width () const — Flags access.
streamsize width (streamsize __wide) — Changing flags.
__ostream_type & operator<< (__ostream_type &(*__pf)(__ostream_type &)) — Interface for manipulators.
__ostream_type & operator<< (__ios_type &(*__pf)(__ios_type &)) — Interface for manipulators.
__ostream_type & operator<< (ios_base &(*__pf)(ios_base &)) — Interface for manipulators.

🔥 Inserters 🔥

Okay so every single operator<< function — aka every formatted output function — has the same opening act. Each one starts by constructing a temporary object of type std::basic_ostream::sentry. That little icon can have several effects, and it finishes up by setting a status flag. See the sentry documentation for more tea. 🫶

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

If an exception is 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 is rethrown. Periodt. 💅

__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 🦋

All the unformatted output functions share some behavior, bestie. Each one starts by constructing a temporary object of type std::basic_ostream::sentry. This has several effects, and it concludes with the setting of a status flag — see the sentry documentation for more. 🌸

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

If an exception is thrown during insertion, ios_base::badbit will be turned on in the stream's error state. If badbit is on in the stream's exceptions mask, the exception will be rethrown without completing its actions. That's the warning, don't skip it. 💀

__ostream_type & put (char_type __c) — Simple insertion.
__ostream_type & write (const char_type *__s, streamsize __n) — Character string insertion.
operator bool () const — The quick-and-easy status check.
bool operator! () const — The quick-and-easy status check.

⭐ Static Public Member Functions ⭐

static bool sync_with_stdio (bool __sync=true) — Interaction with the standard C I/O objects.
static int xalloc () throw () — Access to unique indices.

✨ Static Public Attributes ✨

static const openmode __noreplace — bestie, the docs literally just list this one with no description attached. No cap.
static const fmtflags adjustfield — it's the mask left|right|internal, and it's useful for the 2-arg form of setf.
static const openmode app — seek to the end before every single write.
static const openmode ate — open it, then immediately seek to the end right after opening.
static const iostate badbit — this one means a loss of integrity in an input or output sequence happened — like an irrecoverable read error from a file. It's giving "something is deeply wrong."
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 bestie, this is probably not what you think it is; see https://gcc.gnu.org/onlinedocs/libstdc++/manual/fstreams.html#std.io.filestreams.binary.
static const fmtflags boolalpha — insert/extract bool in alphabetic format instead of numeric format.
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.
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. The vibes are immaculate.
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 it's 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.
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.
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 } — a tiny protected enum with exactly one member, bestie, and that's the whole list.

🔒 Protected Member Functions 🔒

void _M_cache_locale (const locale &__loc) — the internal locale-caching hook.
void _M_call_callbacks (event __ev) throw () — the internal callback-calling hook.
void _M_dispose_callbacks (void) throw () — the internal callback-disposal hook.
_Words & _M_grow_words (int __index, bool __iword) — the internal word-growing hook.
void _M_init () throw () — the internal init hook.
template<typename _ValueT > __ostream_type & _M_insert (_ValueT __v) — the internal insert hook.
void _M_move (ios_base &) noexcept — the internal move hook for ios_base.
void _M_swap (ios_base &__rhs) noexcept — the internal swap hook for ios_base.
void init (basic_streambuf< _CharT, _Traits > *__sb) — all setup is performed here.
void move (basic_ios &&__rhs) — move from a basic_ios rvalue reference.
void move (basic_ios &__rhs) — move from a basic_ios lvalue reference.
void set_rdbuf (basic_streambuf< _CharT, _Traits > *__sb) — the protected set_rdbuf hook.
void swap (basic_ios &__rhs) noexcept — swap with another basic_ios.
void swap (basic_ostream &__rhs) — swap with a basic_ostream.

🧺 Protected Attributes 🧺

_Callback_list * _M_callbacks — callback list pointer.
const __ctype_type * _M_ctype — the cached ctype facet pointer.
iostate _M_exception — the exception-state mask.
char_type _M_fill — the fill character.
bool _M_fill_init — fill-character initialization flag.
fmtflags _M_flags — the formatting flags.
locale _M_ios_locale — the locale object.
_Words _M_local_word [_S_local_word_size] — the local word array.
const __num_get_type * _M_num_get — the cached numeric-get facet pointer.
const __num_put_type * _M_num_put — the cached numeric-put facet pointer.
streamsize _M_precision — the precision value.
basic_streambuf< _CharT, _Traits > * _M_streambuf — the streambuf pointer.
iostate _M_streambuf_state — the streambuf state.
basic_ostream< _CharT, _Traits > * _M_tie — the tied output stream pointer.
streamsize _M_width — the width value.
_Words * _M_word — the word pointer.
int _M_word_size — the word count.
_Words _M_word_zero — the zero word.

📖 Detailed Description 📖

template<typename _CharT, typename _Traits, typename _Alloc>
class std::basic_ostringstream< _CharT, _Traits, _Alloc >

Okay so this class is literally described as "Controlling output for std::string." Iconic behavior.

Template Parameters

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

This class supports writing to objects of type std::basic_string, using the inherited functions from std::basic_ostream. To control the associated sequence, an instance of std::basic_stringbuf is used, which this page refers to as sb.

🏷️ Member Typedef Documentation 🏷️

🫶 `__num_get_type` (inherited) 🫶

template<typename _CharT , typename _Traits > typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > std::basic_ios< _CharT, _Traits >::__num_get_type [inherited]

These are non-standard types. The docs said it, not me.

🎟️ `event_callback` (inherited) 🎟️

typedef void(* std::ios_base::event_callback) (event __e, ios_base &__b, int __i) [inherited]

The type of an event callback function.

Parameters

__e — one of the members of the event enum.
__b — reference to the ios_base object.
__i — the integer 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().

🧚 `fmtflags` (inherited) 🧚

typedef _Ios_Fmtflags std::ios_base::fmtflags [inherited]

This is a bitmask type. _Ios_Fmtflags is implementation-defined, but 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

🦋 `iostate` (inherited) 🦋

typedef _Ios_Iostate std::ios_base::iostate [inherited]

This is a bitmask type. _Ios_Iostate is implementation-defined, but it is valid to perform bitwise operations on these values and expect the Right Thing to happen.

Defined objects of type iostate are:

badbit
eofbit
failbit
goodbit

🌈 `openmode` (inherited) 🌈

typedef _Ios_Openmode std::ios_base::openmode [inherited]

This is a bitmask type. _Ios_Openmode is implementation-defined, but it is valid to perform bitwise operations on these values and expect the Right Thing to happen.

Defined objects of type openmode are:

app
ate
binary
in
out
trunc

⭐ `seekdir` (inherited) ⭐

typedef _Ios_Seekdir std::ios_base::seekdir [inherited]

This is 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) 👑

enum std::ios_base::event [inherited]

The set of events that may be passed to an event callback.

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

🏗️ Constructor & Destructor Documentation 🏗️

🌱 `basic_ostringstream()` [inline] 🌱

template<typename _CharT , typename _Traits , typename _Alloc > std::basic_ostringstream< _CharT, _Traits, _Alloc >::basic_ostringstream () [inline]

Default constructor starts with an empty string buffer. Initializes sb using mode|out, and passes &sb to the base class initializer. Does not allocate any buffer.

That's a lie. We initialize the base class with NULL, because the string class does its own memory management.

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

🌸 `basic_ostringstream(ios_base::openmode __mode)` [inline], [explicit] 🌸

template<typename _CharT , typename _Traits , typename _Alloc > std::basic_ostringstream< _CharT, _Traits, _Alloc >::basic_ostringstream (ios_base::openmode __mode) [inline], [explicit]

Starts with an empty string buffer.

Parameters

__mode — whether the buffer can read, or write, or both.

ios_base::out is automatically included in mode.

Initializes sb using mode|out, and passes &sb to the base class initializer. Does not allocate any buffer.

That's a lie. We initialize the base class with NULL, because the string class does its own memory management.

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

🦋 `basic_ostringstream(const __string_type & __str, ios_base::openmode __mode = ios_base::out)` [inline], [explicit] 🦋

template<typename _CharT , typename _Traits , typename _Alloc > std::basic_ostringstream< _CharT, _Traits, _Alloc >::basic_ostringstream (const __string_type & __str, ios_base::openmode __mode = ios_base::out) [inline], [explicit]

Starts with an existing string buffer.

Parameters

__str — a string to copy as a starting buffer.
__mode — whether the buffer can read, or write, or both.

ios_base::out is automatically included in mode.

Initializes sb using str and mode|out, and passes &sb to the base class initializer.

That's a lie. We initialize the base class with NULL, because the string class does its own memory management.

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

🎀 `~basic_ostringstream()` [inline] 🎀

template<typename _CharT , typename _Traits , typename _Alloc > std::basic_ostringstream< _CharT, _Traits, _Alloc >::~basic_ostringstream () [inline]

The destructor does nothing. The buffer is deallocated by the stringbuf object, not the formatting stream.

🧰 Member Function Documentation 🧰

🔍 `std::ios_base::_M_getloc()` const [inline], [inherited] 🔍

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

Locale access.

Returns

A reference to the current locale.

Like getloc above, but returns a reference instead of generating a copy.

Referenced by (tail end of that previous entry): 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]

Bestie, this is your fast error check era. It returns true if the badbit is set.

Heads up: other iostate flags may also be set, so don’t read this as “only badbit and nothing else, periodt.”

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]

This one [re]sets the error state. Very “reset the vibe” of it all.

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.

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().

`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 “clone the formatting, not the actual stream state.”

Parameters: __rhs — the source values for the copies.
Returns: reference to this object.

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. 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, but make it end-of-file coded.

Returns: true if the eofbit is set.

Note: other iostate flags may also be set.

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 version.

Returns: the current exceptions mask.

This changes nothing in the stream. 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 with setter energy.

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.

If the error flag is already set when the exceptions mask is added, the exception is immediately thrown. 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, but this one is a little messy on purpose.

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

Checking the badbit in fail() is historical practice. Note that other iostate flags may also be set.

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. The filler character. The padding bestie.

Returns: the current fill character.

It defaults to a space (' ') in the current locale.

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. Slay, new padding character acquired.

Parameters: __ch — the new character.
Returns: the previous fill character.

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.
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>>().

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

Setting new format flags all at once. It’s the “replace the whole fit” of format flags.

Parameters: __fmtfl — the new flags to set.
Returns: the previous format control flags.

This function overwrites all the format flags with __fmtfl.

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

Synchronizing the stream buffer. Push the vibe out, bestie.

Returns: *this

If rdbuf() is a null pointer, changes nothing.

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

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().

`locale std::ios_base::getloc () const` [inline], [inherited]

Locale access. Very “what’s the current localization situation” of it all.

Returns: a copy of the current locale.

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

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, but make it unbothered.

Returns: true if no error flags are set.

A wrapper around rdstate.

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 > locale std::basic_ios< _CharT, _Traits >::imbue (const locale & __loc)` [inherited]

Moves to a new locale. Locale glow-up, if you will.

Parameters: __loc — the new locale.
Returns: the previous locale.

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

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. This is called from the public constructor. It is not virtual and cannot be redefined.

okay so before we move on, here’s the ✨referenced by✨ list for that constructor — literally every single one, no cap:

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()
std::basic_stringstream< _CharT, _Traits, _Alloc >::basic_stringstream()

long & std::ios_base::iword (int __ix) [inline], [inherited] — access to the integer array, bestie 🧮

Parameters: __ix — index into the array.

Returns: a reference to an integer associated with the index.

the iword function provides access to an array of integers that can be used for any purpose. the array grows as required to hold the supplied index. all integers 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. 😭

template<typename _CharT , typename _Traits > char std::basic_ios< _CharT, _Traits >::narrow (char_type __c, char __dfault) const [inline], [inherited] — squeezes characters 🍋

Parameters:

__c — the character to narrow.
__dfault — the character to narrow.

Returns: the narrowed character.

maps a character of char_type to a character of char, if possible.

returns the result of

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

additional l10n notes are at http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html — iykyk 🌍

template<typename _CharT , typename _Traits > std::basic_ios< _CharT, _Traits >::operator bool () const [inline], [explicit], [inherited] — the quick-and-easy status check ✅

this allows you to write constructs such as if (!a_stream) ... and while (a_stream) ...

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

template<typename _CharT , typename _Traits > bool std::basic_ios< _CharT, _Traits >::operator! () const [inline], [inherited] — the quick-and-easy status check, but with a ! 💅

this allows you to write constructs such as if (!a_stream) ... and while (a_stream) ...

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

the `operator<<` era — literally so many inserters, hold my matcha 🍵

template<typename _CharT , typename _Traits > __ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (__ios_type &(*)(__ios_type &) __pf) [inline], [inherited] — interface for manipulators 🎛️

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.

template<typename _CharT , typename _Traits > __ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (__ostream_type &(*)(__ostream_type &) __pf) [inline], [inherited] — interface for manipulators (the other flavor) 🎚️

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.

template<typename _CharT , typename _Traits > basic_ostream< _CharT, _Traits > & std::basic_ostream< _CharT, _Traits >::operator<< (__streambuf_type * __sb) [inherited] — extracting from another streambuf, no cap 🫶

Parameters: __sb — a pointer to a streambuf.

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.

if __sb is NULL, the stream will set failbit in its error state.

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.

if the function inserts no characters, failbit is set.

template<typename _CharT , typename _Traits > __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.