NAME¶

std::basic_ios::copyfmt - std::basic_ios::copyfmt

Synopsis¶

basic_ios& copyfmt( const basic_ios& other );

If other refers to the same object as *this, has no effects. Otherwise, copies the
state of the stream other into *this. This is done in the following sequence:

1) Calls every callback registered by register_callback() passing erase_event as
parameter.
2) Copies all member objects from other to *this except for rdstate(), the exception
mask, and rdbuf(). In particular, makes copies of the locale, the formatting flags,
the contents of the arrays std::ios_base::iword and std::ios_base::pword (but not
the iword and pword pointers themselves), the callbacks, and the tied stream.
3) Calls every callback registered by register_callback() passing copyfmt_event as
parameter.
4) Copies the exception mask from other to *this as if by calling
exceptions(other.exceptions()).

Parameters¶

other - another stream to use as source

Return value¶

*this

Notes¶

The second pass through the callbacks may be used to deep-copy the user-defined
objects pointed to by the pointers in std::ios_base::pword.

copyfmt() may be used to save and restore the state of a stream. Boost provides a
more fine-grained I/O state savers library for the same purpose.

Example¶

Makes the std::ofstream object "out" behave exactly like std::cout, including
formatting, tie() to std::cin, etc.

// Run this code

#include <bitset>
#include <climits>
#include <fstream>
#include <iostream>

int main()
{
std::ofstream out;

out.copyfmt(std::cout); // copy everything except rdstate and rdbuf
out.clear(std::cout.rdstate()); // copy rdstate
out.basic_ios<char>::rdbuf(std::cout.rdbuf()); // share the buffer

out << "Hello, world\n";

auto bin = [](std::ios_base::fmtflags f)
{
return std::bitset<sizeof(std::ios_base::fmtflags) * CHAR_BIT>
{ static_cast<unsigned long long>(f) };
};
std::ofstream out2;
std::cout << "1) out2.flags(): " << bin(out2.flags()) << '\n';
std::cout << "2) cout.flags(): " << bin(std::cout.flags()) << '\n';
std::cout.setf(std::ios::hex | std::ios::fixed | std::ios::boolalpha);
std::cout << "3) cout.flags(): " << bin(std::cout.flags()) << '\n';
out2.copyfmt(std::cout); // copy everything except rdstate and rdbuf
std::cout << "4) out2.flags(): " << bin(out2.flags()) << '\n';
}

Possible output:¶

Hello, world
1) out2.flags(): 00000000000000000001000000000010
2) cout.flags(): 00000000000000000001000000000010
3) cout.flags(): 00000000000000000001000000001111
4) out2.flags(): 00000000000000000001000000001111

Defect reports

The following behavior-changing defect reports were applied retroactively to
previously published C++ standards.

DR Applied to Behavior as published Correct behavior
LWG 256 C++98 step 3 called the registered callbacks with the corrected to
event type copy_event, which is not defined copyfmt_event
if other refers to the same object as *this, the
LWG 292 C++98 member objects do nothing
were still copied and the registered callbacks in this case
were still called