29 Input/output library [input.output]

29.5 Iostreams base classes [iostreams.base]

29.5.5 Class template basic_­ios [ios]

29.5.5.3 Member functions [basic.ios.members]

🔗
basic_ostream<charT, traits>* tie() const;
1
#
Returns: An output sequence that is tied to (synchronized with) the sequence controlled by the stream buffer.
🔗
basic_ostream<charT, traits>* tie(basic_ostream<charT, traits>* tiestr);
2
#
Preconditions: If tiestr is not null, tiestr is not reachable by traversing the linked list of tied stream objects starting from tiestr->tie().
3
#
Postconditions: tiestr == tie().
4
#
Returns: The previous value of tie().
🔗
basic_streambuf<charT, traits>* rdbuf() const;
5
#
Returns: A pointer to the streambuf associated with the stream.
🔗
basic_streambuf<charT, traits>* rdbuf(basic_streambuf<charT, traits>* sb);
6
#
Effects: Calls clear().
7
#
Postconditions: sb == rdbuf().
8
#
Returns: The previous value of rdbuf().
🔗
locale imbue(const locale& loc);
9
#
Effects: Calls ios_­base​::​imbue(loc) and if rdbuf() != 0 then rdbuf()->pubimbue(loc).
10
#
Returns: The prior value of ios_­base​::​imbue().
🔗
char narrow(char_type c, char dfault) const;
11
#
Returns: use_­facet<ctype<char_­type>>(getloc()).narrow(c, dfault)
🔗
char_type widen(char c) const;
12
#
Returns: use_­facet<ctype<char_­type>>(getloc()).widen(c)
🔗
char_type fill() const;
13
#
Returns: The character used to pad (fill) an output conversion to the specified field width.
🔗
char_type fill(char_type fillch);
14
#
Postconditions: traits​::​eq(fillch, fill()).
15
#
Returns: The previous value of fill().
🔗
basic_ios& copyfmt(const basic_ios& rhs);
16
#
Effects: If (this == addressof(rhs)) is true does nothing.
Otherwise assigns to the member objects of *this the corresponding member objects of rhs as follows:
  • (16.1)
    calls each registered callback pair (fn, idx) as (*fn)(erase_­event, *this, idx);
  • (16.2)
    then, assigns to the member objects of *this the corresponding member objects of rhs, except that
    • (16.2.1)
      rdstate(), rdbuf(), and exceptions() are left unchanged;
    • (16.2.2)
      the contents of arrays pointed at by pword and iword are copied, not the pointers themselves;292 and
    • (16.2.3)
      if any newly stored pointer values in *this point at objects stored outside the object rhs and those objects are destroyed when rhs is destroyed, the newly stored pointer values are altered to point at newly constructed copies of the objects;
  • (16.3)
    then, calls each callback pair that was copied from rhs as (*fn)(copyfmt_­event, *this, idx);
  • (16.4)
    then, calls exceptions(rhs.exceptions()).
17
#
[ Note
:
The second pass through the callback pairs permits a copied pword value to be zeroed, or to have its referent deep copied or reference counted, or to have other special action taken.
— end note
 ]
18
#
Postconditions: The postconditions of this function are indicated in Table 123.
Table 123: basic_­ios​::​copyfmt() effects   [tab:basic.ios.copyfmt]
Element
Value
rdbuf()
unchanged
tie()
rhs.tie()
rdstate()
unchanged
exceptions()
rhs.exceptions()
flags()
rhs.flags()
width()
rhs.width()
precision()
rhs.precision()
fill()
rhs.fill()
getloc()
rhs.getloc()
19
#
Returns: *this.
🔗
void move(basic_ios& rhs); void move(basic_ios&& rhs);
20
#
Postconditions: *this has the state that rhs had before the function call, except that rdbuf() returns nullptr.
rhs is in a valid but unspecified state, except that rhs.rdbuf() returns the same value as it returned before the function call, and rhs.tie() returns nullptr.
🔗
void swap(basic_ios& rhs) noexcept;
21
#
Effects: The states of *this and rhs are exchanged, except that rdbuf() returns the same value as it returned before the function call, and rhs.rdbuf() returns the same value as it returned before the function call.
🔗
void set_rdbuf(basic_streambuf<charT, traits>* sb);
22
#
Preconditions: sb != nullptr is true.
23
#
Effects: Associates the basic_­streambuf object pointed to by sb with this stream without calling clear().
24
#
Postconditions: rdbuf() == sb is true.
25
#
Throws: Nothing.
292)
This suggests an infinite amount of copying, but the implementation can keep track of the maximum element of the arrays that is nonzero.
⮥