STD::BASIC_FSTREAM(3cxx)

📦

version 14-20240412 · 26 versions

💅 std::basic_fstream< _CharT, _Traits > — the `3cxx` manual page 💅

okay so bestie, welcome to the group chat for std::basic_fstream< _CharT, _Traits >, the cxx manual page. This is your file-stream bestie: controlling input and output for files, periodt. 💖

🌸 NAME 🌸

std::basic_fstream< _CharT, _Traits > — literally controlling input and output for files. That's the whole assignment. 🎀

✨ SYNOPSIS ✨

#include <fstream>

It inherits std::basic_iostream< _CharT, _Traits >. Yes ma'am, that's the family tree. 🦋

🦋 Public Types 🦋

okay so these are the public typedefs and enum vibes, all listed with their exact signatures because we do not skip the boring parts in this house. 💅

typedef ctype< _CharT > __ctype_type
typedef ctype< _CharT > __ctype_type — yes bestie, it appears twice in the manual, and we're keeping both. No erasure. 💖
typedef basic_filebuf< char_type, traits_type > __filebuf_type
typedef basic_ios< char_type, traits_type > __ios_type
typedef basic_iostream< char_type, traits_type > __iostream_type
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
typedef basic_streambuf< _CharT, _Traits > __streambuf_type — another repeat, another crumb kept. 🫶
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_type::int_type int_type
typedef _Ios_Iostate iostate — this is a bitmask type.
typedef traits_type::off_type off_type
typedef _Ios_Openmode openmode — this is a bitmask type.
typedef traits_type::pos_type pos_type
typedef _Ios_Seekdir seekdir — this is an enumerated type.
typedef _Traits traits_type

and then there's this lil repeat hanging out at the bottom:

typedef num_put< _CharT, ostreambuf_iterator< _CharT, _Traits > > __num_put_type

🔥 Public Member Functions 🔥

deep breath bestie, because this is the big list. Every single one is here, no skips, no "oops I forgot one." 💅

basic_fstream () — default constructor.
basic_fstream (basic_fstream &&__rhs)
template<typename _Path , typename _Require = _If_fs_path<_Path>> basic_fstream (const _Path &__s, ios_base::openmode __mode=ios_base::in|ios_base::out) — create an input/output file stream.
basic_fstream (const basic_fstream &)=delete
basic_fstream (const char *__s, ios_base::openmode __mode=ios_base::in|ios_base::out) — create an input/output file stream.
basic_fstream (const std::string &__s, ios_base::openmode __mode=ios_base::in|ios_base::out) — create an input/output file stream.
~basic_fstream () — the destructor does nothing. she's literally just vibing. 💀
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.
void close () — close the file.
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.
bool is_open () — wrapper to test for an open file.
bool is_open () const
long & iword (int __ix) — access to integer array.
char narrow (char_type __c, char __dfault) const — squeezes characters.
template<typename _Path > _If_fs_path< _Path, void > open (const _Path &__s, ios_base::openmode __mode=ios_base::in|ios_base::out) — opens an external file.
void open (const char *__s, ios_base::openmode __mode=ios_base::in|ios_base::out) — opens an external file.
void open (const std::string &__s, ios_base::openmode __mode=ios_base::in|ios_base::out) — opens an external file.
__ostream_type & operator<< (__streambuf_type *__sb) — extracting from another streambuf.
__ostream_type & operator<< (const void *__p) — pointer arithmetic inserters.
__ostream_type & operator<< (nullptr_t)
basic_fstream & operator= (basic_fstream &&__rhs)
basic_fstream & operator= (const basic_fstream &)=delete
__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.
__filebuf_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.
void swap (basic_fstream &__rhs)
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.

and there's also these manipulator-interface girlies:

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

okay so all the operator>> functions — aka formatted input functions — have some common behavior. 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. simple as that, bestie. ✨

no cap: 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. keep that in your notes. 😭

__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, bestie. each one 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(). she's counting, okay? 💅

and again, for real: 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. 🌸

int_type get () — the simplest little grab there is: one character, straight out of the stream ✨
__istream_type & get (char_type &__c) — also simple extraction, except this one drops the character into __c for you 🎀
__istream_type & get (char_type *__s, streamsize __n, char_type __delim) — simple multiple-character extraction, with a delimiter in the mix 💅
__istream_type & get (char_type *__s, streamsize __n) — same multiple-character extraction energy, no delimiter argument 🦋
__istream_type & get (__streambuf_type &__sb, char_type __delim) — extraction into another streambuf, delimiter included 👀
__istream_type & get (__streambuf_type &__sb) — extraction into another streambuf, plain and simple 💜
__istream_type & getline (char_type *__s, streamsize __n, char_type __delim) — string extraction, bestie 🌸
__istream_type & getline (char_type *__s, streamsize __n) — string extraction, the two-arg version 🫶
__istream_type & ignore (streamsize __n, int_type __delim) — literally just discarding characters 💀
__istream_type & ignore (streamsize __n) — simple extraction (yep, that's what the page calls it) 🙈
__istream_type & ignore () — simple extraction again, no args at all ✨
int_type peek () — looking ahead in the stream, no committing, just vibes 👑
__istream_type & read (char_type *__s, streamsize __n) — extraction without delimiters, raw and unfiltered 🔥
streamsize readsome (char_type *__s, streamsize __n) — extraction until the buffer is exhausted, but no more — lowkey the most honest function here 😭
__istream_type & putback (char_type __c) — unextracting a single character, putting it right back where it came from 🧚
__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) — also changing the current read position, just with the offset + seekdir flavour 🎀
operator bool () const — the quick-and-easy status check, our fave 🫶
bool operator! () const — the quick-and-easy status check, but negated 💅
__ostream_type & operator<< (__ostream_type &(*__pf)(__ostream_type &)) — interface for manipulators ✨
__ostream_type & operator<< (__ios_type &(*__pf)(__ios_type &)) — interface for manipulators, __ios_type edition 🦋
__ostream_type & operator<< (ios_base &(*__pf)(ios_base &)) — interface for manipulators, ios_base edition 🌸

🔥 Inserters 🔥

okay so all the operator<< functions (aka the formatted output functions, iykyk) share some common behavior, and you need to know this part 👑

Each one starts by constructing a temporary object of type std::basic_ostream::sentry. This can have several effects, and it concludes with the setting of a status flag — see the sentry documentation for more, bestie.

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. The original exception will then be rethrown. Not me warning you twice 😭

that rethrow behaviour is not a drill — the badbit gets set and your original exception comes right back at you 🙈

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

same deal as the inserters, but unformatted this time — and the details lowkey differ, so pay attention 💀

All the unformatted output functions have some common behavior. Each starts by constructing a temporary object of type std::basic_ostream::sentry. 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 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. 🚨

like bestie, if badbit is sitting in the exceptions mask, your operation does not get to finish. It rethrows mid-action. That's the whole rule 🙈

__ostream_type & put (char_type __c) — simple insertion 🎀
__ostream_type & write (const char_type *__s, streamsize __n) — character string insertion 📝

💖 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 — the page just lists it with zero explanation, so I'm not gonna invent one, bestie 💀
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 🦋
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 (such as 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). 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 rather than 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 🌸
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 💧
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 } — that's the whole entry, no notes attached 💅

💜 Protected Member Functions 💜

void _M_cache_locale (const locale &__loc)
void _M_call_callbacks (event __ev) throw ()
void _M_dispose_callbacks (void) throw ()
template<typename _ValueT > __istream_type & _M_extract (_ValueT &__v)
_Words & _M_grow_words (int __index, bool __iword)
void _M_init () throw ()
template<typename _ValueT > __ostream_type & _M_insert (_ValueT __v)
void _M_move (ios_base &) noexcept
void _M_swap (ios_base &__rhs) noexcept
void init (basic_streambuf< _CharT, _Traits > *__sb) — all setup is performed here 🛠️
void move (basic_ios &&__rhs)
void move (basic_ios &__rhs)
void set_rdbuf (basic_streambuf< _CharT, _Traits > *__sb)
void swap (basic_ios &__rhs) noexcept
void swap (basic_iostream &__rhs)
void swap (basic_istream &__rhs)
void swap (basic_ostream &__rhs)

🍓 Protected Attributes 🍓

_Callback_list * _M_callbacks
const __ctype_type * _M_ctype
iostate _M_exception
char_type _M_fill
bool _M_fill_init
fmtflags _M_flags
streamsize _M_gcount
locale _M_ios_locale
_Words _M_local_word [_S_local_word_size]
const __num_get_type * _M_num_get
const __num_put_type * _M_num_put
streamsize _M_precision
basic_streambuf< _CharT, _Traits > * _M_streambuf
iostate _M_streambuf_state
basic_ostream< _CharT, _Traits > * _M_tie
streamsize _M_width
_Words * _M_word
int _M_word_size
_Words _M_word_zero

🌟 Detailed Description 🌟

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

Controlling input and output for files. periodt 💅

🎀 Template Parameters 🎀

_CharT — type of character stream 🔤
_Traits — traits for character type, defaults to char_traits<_CharT> 🧬

This class supports reading from and writing to named files, using the inherited functions from std::basic_iostream. To control the associated sequence, an instance of std::basic_filebuf is used — and this page refers to that instance as sb 🫶

🧬 Member Typedef Documentation

✨ `__num_put_type` — inherited, and very much a "non-standard" girlie

template<typename _CharT , typename _Traits > typedef num_put<_CharT,
    ostreambuf_iterator<_CharT, _Traits> > std::basic_ios< _CharT, _Traits
    >::__num_put_type [inherited]

These are non-standard types. That's it, that's the whole note — they're not part of the standard, so don't go assuming anything extra about them 💅

🎀 `event_callback` — inherited

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

It's the type of an event callback function. Iconic little function pointer, lowkey.

Parameters

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

So here's the vibe check: event callbacks are user-defined functions that get called during several ios_base and basic_ios functions — specifically imbue(), copyfmt(), and ~ios().

🦋 `fmtflags` — inherited, bitmask royalty

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, fr fr.

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]

Also a bitmask type. _Ios_Iostate is implementation-defined, but yeah — bitwise ops on these values, Right Thing, you know the drill ✨

Defined objects of type iostate are:

badbit
eofbit
failbit
goodbit

🎀 `openmode` — inherited

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

Bitmask type again, bestie. _Ios_Openmode is implementation-defined, and 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 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

It's the set of events that may be passed to an event callback. Let's break it down:

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

Periodt. Three events, three places they show up 💀

🛠️ Constructor & Destructor Documentation

`basic_fstream()` — the default one

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

Default constructor, bestie. It initializes sb using its own default constructor, and then passes &sb to the base class initializer. Does it open any files? Nope — you haven't given it a filename to open, so there's literally nothing to open 🙈

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

`basic_fstream(const char* __s, ...)` — the C-string one

template<typename _CharT , typename _Traits > std::basic_fstream< _CharT,
    _Traits >::basic_fstream (const char * __s, ios_base::openmode __mode =
    ios_base::in | ios_base::out) [inline],  [explicit]

Create an input/output file stream. Two-for-one, we love to see it 🫶

Parameters

__s — null terminated string specifying the filename.
__mode — open file in specified mode (see std::ios_base).

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

`basic_fstream(const std::string& __s, ...)` — the `std::string` one

template<typename _CharT , typename _Traits > std::basic_fstream< _CharT,
    _Traits >::basic_fstream (const std::string & __s, ios_base::openmode
    __mode = ios_base::in | ios_base::out) [inline],  [explicit]

Create an input/output file stream. Same energy, but now with a std::string filename, which is honestly so much nicer than raw C strings, no cap.

Parameters

__s — null terminated string specifying the filename.
__mode — open file in specified mode (see std::ios_base).

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

`basic_fstream(const _Path& __s, ...)` — the filesystem::path one

template<typename _CharT , typename _Traits > template<typename _Path ,
    typename _Require  = _If_fs_path<_Path>> std::basic_fstream< _CharT,
    _Traits >::basic_fstream (const _Path & __s, ios_base::openmode __mode =
    ios_base::in | ios_base::out) [inline]

Create an input/output file stream. Yes, there's a template-on-template situation happening here, and yes, it's fine ✨

Parameters

__s — filesystem::path specifying the filename.
__mode — open file in specified mode (see std::ios_base).

`~basic_fstream()` — the destructor

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

Plot twist: the destructor does nothing 💀 The file is closed by the filebuf object, not the formatting stream. So don't be out here crediting the wrong object, iykyk.

💜 Member Function Documentation

`_M_getloc()` — inherited, the locale access one

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

Locale access, in all its underscored glory.

Returns: a reference to the current locale.

Like getloc above, but returns a reference instead of generating a copy. Efficient icon behavior 🎀

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()
std::time_put< _CharT, _OutIter >::put()

`bad()` — inherited, fast error checking

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

Fast error checking. Snappy little bool, we stan.

Returns: true if the badbit is set.

Small caveat though — note that other iostate flags may also be set. So don't read this as "everything is fine," okay? 🙈

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

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

`clear()` — inherited, the [re]setter

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

[Re]sets the error state. The brackets are doing so much work there and honestly? Slay.

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. (Like, most of y'all can just call it and move on 💅)

Referenced by: okay bestie, buckle up, and yes — several of these are literally listed twice in the docs, that's just how it is 💀

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()
std::basic_istream< _CharT, _Traits >::unget()

`close()` — shut it down 🚪

template<typename _CharT , typename _Traits > void std::basic_fstream<
    _CharT, _Traits >::close () [inline]

Close the file. It calls std::basic_filebuf::close(). And if that function fails? failbit gets set in the stream's error state. So like, always check, bestie.

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

`copyfmt()` — inherited, the copy-everything one

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 object. The way this one has rules, though 👑

Parameters

__rhs — the source values for the copies.

Returns: a reference to this object.

So here's what actually happens: 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 too. Before copying, each callback is invoked with erase_event. After copying, each (new) callback is invoked with copyfmt_event. And the final step? 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().

`eof()` — inherited, fast error checking

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

Fast error checking, part two.

Returns: true if the eofbit is set.

And again — note that other iostate flags may also be set. One flag being set does not mean the others aren't lurking 👀

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

`exceptions()` — inherited, the read-only one

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

Throwing exceptions on errors — well, reading about them right now.

Returns: the current exceptions mask.

This changes nothing in the stream. It's purely a read, bestie. See the one-argument version of exceptions(iostate) for the meaning of the return value.

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

`exceptions(iostate)` — inherited, the one that actually throws 😭

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

Throwing exceptions on errors. This is the spicy one.

Parameters

__except — the new exceptions mask.

By default, error flags are set silently. Very demure, very mindful. But 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 part that gets people: 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().

`fail()` — inherited, fast error checking (the third one)

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

Fast error checking, back again.

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

Checking the badbit in fail() is historical practice — that's just the lore, don't question it. And 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()
std::regex_traits< _Ch_type >::value()

`fill()` — inherited, the empty-character girlie

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

Retrieves the empty character. Cute little getter, does exactly what it says 🎀

Returns: the current fill character.

It defaults to a space (' ') in the current locale, periodt. That's just the vibe.

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. Bestie, you're literally choosing what fills the gaps. <sparkle>✨</sparkle>

Parameters

__ch — the new character. That's the one, mwah.

Returns

The previous fill character. The one it was before — like, the ex-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. Reading the whole format-control fit check 👑

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>>(). No cap, that's the whole list, not me editing it down fr fr.

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

Setting new format flags all at once. Glow-up for the whole flag set, one call ✅

Parameters

__fmtfl — the new flags to set.

Returns

The previous format control flags.

This function overwrites all the format flags with __fmtfl. Like, every single one. It's not a merge, it's a takeover.

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

Synchronizing the stream buffer. Making sure everything's actually made it out the door 🏃‍♀️

Returns

*this

If rdbuf() is a null pointer, changes nothing. Nothing happened, and that's fine.

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

🍓 `template<typename _CharT , typename _Traits > streamsize std::basic_istream< _CharT, _Traits >::gcount () const [inline], [inherited]`

Character counting. Keeping score of how many chars actually got extracted 🔢

Returns

The number of characters extracted by the previous unformatted input function dispatched for this stream.

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. One char, no thoughts, just vibes ✨

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::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. Handing your chars off to a different buffer, cute 🎀

Parameters

__sb — a streambuf in which to store data.

Returns

*this

Returns get(__sb,widen('\n')).

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 with a stop character this time, iykyk 🛑

Parameters

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

Returns

*this

Characters are extracted and inserted into __sb until one of the following happens:

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

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

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, but storing into a reference this time 💖

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. So don't come at it with those, it will not hear you.

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

Simple multiple-character extraction. Array time bestie 📚

Parameters

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

Returns

*this

Returns get(__s,__n,widen('\n')).

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, now with a delim. The full package deal 💅

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 the following 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.

Note: this function is not overloaded on signed char and unsigned char. Same energy as before — it simply does not do that.

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. Reading a whole line like the main character you are 🌟

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

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 with a stop character. This is the one with the actual rules, so listen up 📋

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 the following happens. Note that these criteria are required to be tested in the order listed here, to allow an input line to exactly fill the __s array without setting failbit. Order matters, bestie, don't rearrange them.

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.) Empty line? Valid. Iconic even.

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. Special-cased for char, bestie — that's the whole note.

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

Locale access. Peeking at which locale is currently loaded 🌍

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. The quick vibe check of the stream world ✅

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 > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::ignore (void) [inherited]`

Simple extraction. Yeah the doc says "extraction" here, we're just rolling with it, don't @ me 🙈

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, with a count. Yes, same description as above — the docs said what they said 💅

Returns

A character, or eof().

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

template<typename _CharT , typename _Traits > basic_istream< _CharT, _Traits > & std::basic_istream< _CharT, _Traits >::ignore (streamsize __n, int_type __delim) [inherited] — bestie this one is literally the "trash it" button, aka Discarding characters.

Parameters

__n — Number of characters to discard.
__delim — A 'stop' character.

Returns *this

So it extracts characters and just throws them away (no cap, we don't want them) until ONE of these things happens:

if __n != std::numeric_limits<int>::max(), __n characters are extracted
the input sequence reaches end-of-file
the next character equals __delim (and in this case, the character is extracted) — but heads up, 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. Slay, honestly. ✨

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 > locale std::basic_ios< _CharT, _Traits >::imbue (const locale & __loc) [inherited] — Moves to a new locale. it's giving ✨glow-up✨ but for language settings.

Parameters

__loc — The new locale.

Returns The previous locale. (yes, it remembers the old one, iconic behaviour)

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. literally the backstage crew of the stream 🎀 This is called from the public constructor. It is not virtual and cannot be redefined. no take-backs, no overrides, periodt.

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(). (that's a lot of names, we love a supportive cast 💖)

template<typename _CharT , typename _Traits > bool std::basic_fstream< _CharT, _Traits >::is_open () [inline] — Wrapper to test for an open file. tiny little vibe check: is the file open or not 🦋

Returns rdbuf()->is_open()

References std::basic_filebuf< _CharT, _Traits >::is_open().

long & std::ios_base::iword (int __ix) [inline], [inherited] — Access to integer array. your personal little integer storage cubby 🔥

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. bestie please do not cling, the array is a main character who changes 💅

template<typename _CharT , typename _Traits > char std::basic_ios< _CharT, _Traits >::narrow (char_type __c, char __dfault) const [inline], [inherited] — Squeezes characters. not me making your wide chars fit into a regular char 😭

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

template<typename _CharT , typename _Traits > template<typename _Path > _If_fs_path< _Path, void > std::basic_fstream< _CharT, _Traits >::open (const _Path & __s, ios_base::openmode __mode = ios_base::in | ios_base::out) [inline] — Opens an external file. the filesystem::path flavour, fancy ✨

Parameters

__s — The name of the file, as a filesystem::path.
__mode — The open mode flags.

Calls std::basic_filebuf::open(__s,__mode). If that function fails, failbit is set in the stream's error state.

References std::basic_fstream< _CharT, _Traits >::open().

template<typename _CharT , typename _Traits > void std::basic_fstream< _CharT, _Traits >::open (const char * __s, ios_base::openmode __mode = ios_base::in | ios_base::out) [inline] — Opens an external file. the classic C-string version, old money 🎀

Parameters

__s — The name of the file.
__mode — The open mode flags.

Calls std::basic_filebuf::open(__s,__mode). If that function fails, failbit is set in the stream's error state.

References std::basic_ios< _CharT, _Traits >::clear(), std::ios_base::failbit, std::basic_filebuf< _CharT, _Traits >::open(), and std::basic_ios< _CharT, _Traits >::setstate().

Referenced by std::basic_fstream< _CharT, _Traits >::basic_fstream(), std::basic_fstream< _CharT, _Traits >::basic_fstream(), and std::basic_fstream< _CharT, _Traits >::open().

template<typename _CharT , typename _Traits > void std::basic_fstream< _CharT, _Traits >::open (const std::string & __s, ios_base::openmode __mode = ios_base::in | ios_base::out) [inline] — Opens an external file. and this one takes a std::string because we're not always out here with raw pointers bestie 💜

Parameters

__s — The name of the file.
__mode — The open mode flags.

Calls std::basic_filebuf::open(__s,__mode). If that function fails, failbit is set in the stream's error state.

References std::basic_ios< _CharT, _Traits >::clear(), std::ios_base::failbit, std::basic_filebuf< _CharT, _Traits >::open(), and std::basic_ios< _CharT, _Traits >::setstate().

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) ... — the [explicit] is doing so much work here, no accidental conversions, we stan a careful icon 👑

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. This allows you to write constructs such as if (!a_stream) ... and while (a_stream) ... — same energy, just with the little bang operator 🫶

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

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. function-pointer-to-function-pointer, we love a glow-up pipeline ✨
template<typename _CharT , typename _Traits > __ostream_type & std::basic_ostream< _CharT, _Traits >::operator<< (__ostream_type &(*)(__ostream_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. this overload takes the __ostream_type flavour, same vibe, different signature 🌸
template<typename _CharT , typename _Traits > basic_ostream< _CharT, _Traits > & std::basic_ostream< _CharT, _Traits >::operator<< (__streambuf_type * __sb) [inherited] — Extracting from another streambuf. wait no, it's << so we're inserting — the title says extracting because that's what's happening to __sb's contents, keep up bestie 😭

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. (so like, don't do that 🙈)

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. brutal but fair 💀

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.