fmtflags_manip.cpp

Go to the documentation of this file.

 
#include <ios>        // for hex
#include <iomanip>    // for __rw_smanip
#include <iostream>   // for cout
 
#include <examples.h>
 
 
// implementation class of the fmtflags manipulator that saves
// a stream object's fmtflags state before optionally setting
// their new value and restores the saved state when destroyed
// uses ios::basefield as an invalid flags value (it's a valid
// mask but not a valid flags value)
class fmtflags_manip
{
    std::ios_base           *strm_;
    std::ios_base::fmtflags  saved_;
 
public:
    fmtflags_manip (): strm_ (), saved_ (std::ios_base::basefield) { }
 
    void operator() (std::ios_base           &strm,
                     std::ios_base::fmtflags  flags) const {
 
        const_cast<fmtflags_manip*>(this)->strm_  = &strm;
        const_cast<fmtflags_manip*>(this)->saved_ = strm.flags ();
 
        if (flags != std::ios_base::basefield)
            strm.flags (flags);
    }
 
    ~fmtflags_manip () {
        if (strm_)
            strm_->flags (saved_);
    }
};
 
 
// saveflags manipulator to temporarily set formatting flags and
// restore their initial value at the end of an insertion statement
inline std::__rw_smanip<fmtflags_manip, std::ios_base::fmtflags>
saveflags (std::ios_base::fmtflags flags = std::ios_base::basefield)
{
    typedef std::__rw_smanip<fmtflags_manip, std::ios_base::fmtflags> Manip;
 
    return Manip (flags);
}
 
 
// dummy class whose insertion operator always throws
struct BadClass { };
 
 
inline std::ostream&
operator<< (std::ostream &strm, BadClass&)
{
    // inserter that always throws an exception
    return throw "exception", strm;
 
}
 
 
int main ()
{
    try {
        BadClass throw_exception;
 
        // use the saveflags manipulator to set the formatting flags
        // for the rest of this insertion statement only and have it
        // restore the  previous flags at the end of the statement
        // or on exception
        std::cout << saveflags (std::cout.hex)
                  << std::showbase
                  << "hex 1234: " << 0x1234 << '\n'
                  << "hex 2345: " << 0x2345 << '\n'
                  << throw_exception    // inserting will throw
                  << "never output!";   // this string is never output
    }
    catch (...) {
        // show that default formatting flags (decimal output and no
        // showbase) have been restored during stack unwinding above
        std::cout << "dec 3456:   " << 3456 << '\n'
                  << std::oct
                  << "oct 4567:   " << 04567 << '\n';
    }
 
    // use ordinary manipulators to set hex output with base prefix
    std::cout << std::hex << std::showbase
              << "hex 5678: " << 0x5678 << '\n'
              << "hex 6789: " << 0x6789 << '\n';
 
    // the same flags set above are still in effect
    std::cout << "hex 789a: " << 0x789a << '\n';
 
    return 0;
}