“Roll-Back” or Undo Any Manipulators Applied To A Stream Without Knowing What The Manipulators Were [duplicate]

Answer 1

I know that is an old question, but for future generations:

You can also write a simple state saver yourself (it will certainly help you avoid leaving the state changed). Just use the solution suggested by @loki and run it from the constructor/destructor of an object (in short: RAII) along these lines:

class stateSaver
{
  public:
    stateSaver(ostream& os): stream_(os), state_(nullptr) { state_.copyfmt(os); }
    ~stateSaver() { stream_.copyfmt(state_); }
  private:
    std::ios state_;
    ostream& stream_;
};

Then, you will use it like this:

void myFunc() {
    stateSaver state(cout);
    cout << hex << 42 << endl; // will be in hex
}

int main() {
    cout << 42 << endl; // will be in dec
    myFunc();
    cout << 42 << endl; // will also be in dec
}

Answer 2

Boost IO State saver might be of help.

http://www.boost.org/doc/libs/1_40_0/libs/io/doc/ios_state.html

Answer 3

The standard manipulators all manipulate a stream's format flags, precision and width settings. The width setting is reset by most formatted output operations anyway. These can all be retrieved like this:

std::ios_base::fmtflags saveflags = std::cout.flags();
std::streamsize prec = std::cout.precision();
std::streamsize width = std::cout.width();

and restored:

std::cout.flags( saveflags );
std::cout.precision( prec );
std::cout.width( width );

Turning this into an RAII class is an exercise for the reader...

Answer 4

Yes.

You can save the state and restore it:

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{

    std::ios  state(NULL);
    state.copyfmt(std::cout);

    cout << "Hello" << hex << 42 << "\n";
    // now i want to "roll-back" cout to whatever state it was in
    // before the code above, *without* having to know what modifiers I added to it

  // ... MAGIC HAPPENS! ...

    std::cout.copyfmt(state);
    cout << "This should not be in hex: " << 42 << "\n";
}

If you want to get back to the default state you don't even need to save the state you can extract it from a temporary object.

std::cout.copyfmt(std::ios(NULL));

Answer 5

Saving and restoring state is not exception-safe. I would propose to shuffle everything into a stringstream, and finally you put that on the real stream (which has never changed its flags at all).

#include <iostream>
#include <iomanip>
#include <sstream>

int main()
{
    std::ostringstream out;
    out << "Hello" << std::hex << 42 << "\n";
    std::cout << out.str();

    // no magic necessary!

    std::cout << "This should not be in hex: " << 42 << "\n";
}

Of course this is a little less performant. The perfect solutions depends on your specific needs.