# std::basic_ios<CharT,Traits>::copyfmt

> C++ Atlas: `cppatlas.com/w/cpp/io/basic_ios/copyfmt` | Source: https://en.cppreference.com/w/cpp/io/basic_ios/copyfmt | Domain: Input/output

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:

## Official Specification Summary (cppreference)

```cpp
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.

```cpp
#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:

```text
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 event type `copy_event`, which is not defined | corrected to `copyfmt_event` |
| LWG 292 | C++98 | if `other` refers to the same object as `*this`, the member objects were still copied and the registered callbacks were still called | do nothing in this case |

---
Attribution: content from https://en.cppreference.com/w/cpp/io/basic_ios/copyfmt (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.