std::cout formatting in Cpp 98 standard

Question

Each of the following regards a distinctive ostream -format. How do I return it to default?

#include <iostream>
int main()
{
    std::cout << std::fixed;
    std::cout << std::setprecision(5) << f << '\n';
    std::cout << "scientific:\n" << std::scientific;
    /*Cpp 11 standard only*/
    std::cout << " hexfloat: " << std::hexfloat << 0.01 << '\n';
    "The number 0.01 in default: " << std::defaultfloat << 0.01; }
}

As in :

std::set_default?;

Also how do I perform

hexfloat and defaultfloat

in Cpp 98 standard?

also what is the technical difference between setwidth and setprecision?

Answer 1

The default of the mutually-exclusive options std::fixed , std::scientific , std::hexfloat and std::defaultfloat is, you got it std::defaultfloat .

The default for std::setprecision is 6 .

The exact effect of std::setw must be looked up for each stream-inserter separately.

A replacement of std::defaultfloat for pre-C++11 is easy enough:

std::ios_base& defaultfloat(std::ios_base& str) {
    str.unsetf(std::ios_base::floatfield);
    return str;
}

Writing std::hexfloat is equally easy, but the stream-operators wouldn't know what to do with those flags.
Which is non-trivial to fix.

Answer 2

The easy approach to restore the original format is to keep a stream without any modifications around and just use copyfmt() , eg:

int main() {
    std::ostream restore(0);

    restore.copyfmt(std::cout);
    std::cout.precision(8);
    std::cout.copyfmt(restore);
}

This approach will restore all the different formats, including the values stored with pword() and iword() . If you want to package this functionality as a set_default manipulator (you can't put it into namespace std as only implementers are allowed to put names in there), you'd use something like this:

template <typename cT, typename Traits>
std::basic_ostream<cT, Traits>& set_default(std::basic_ostream<cT, Traits>& out) {
    static std::basic_ostream<cT, Traits> dfault(0);
    out.copyfmt(dfault);
    return out;
}

It would be used like any of the other manipulators, eg:

std::cout << set_default;

You can just have one stream from which to restore the original values. Alternatively, you can keep the format of std::cout intact and rather create a separate stream using the same buffer but different formats, eg

std::ostream out(std::cout.rdbuf());
out.precision(8);
out << value;

This stream will write to the same stream as std::cout but use different formatting flags. You can even mix them as the streams don't store any characters directly: this is the job of the shared stream buffer:

std::cout << "value=";
out << value;
std::cout << '\n';

To answer your question about the behavior of, eg, defaultfloat : these are just manipulator functions. If you want to use them without C++11 you can just define a corresponding function, eg:

template <typename cT, typename Traits>
std::basic_ostream<cT, Traits>& defaultfloat(std::basic_ostream<cT, Traits>& out) {
    out.unsetf(std::ios_base::floatfield);
    return out;
}

Answer 3

How do I return if to default

auto oldflags = std::cout.flags(); 
auto oldwidth = std::cout.width(); 
auto oldprecision = std::cout.precision();
auto oldloc = std::cout.getloc();
auto oldfill = std::cout.fill();
//**************************************************
std::cout << std::fixed;
std::cout << std::setprecision(5) << f << '\n';
std::cout << "scientific:\n" << std::scientific;
/*Cpp 11 standard only*/
std::cout << " hexfloat: " << std::hexfloat << 0.01 << '\n';
"The number 0.01 in default: " << std::defaultfloat << 0.01; 
//**********************************************************
std::cout.flags(oldflags); 
std::cout.width(oldwidth); 
std::cout.precision(oldprecision);
std::cout.imbue(oldloc);
std::cout.fill(oldfill);

It's kind of a pain in the butt.

Also how do I perform hexfloat and defaultfloat in Cpp 98 standard?

Write similar functions yourself. It's even more of a pain in the butt.

what is the technical difference between setwidth and setprecision?

They do completely different things:

• width - The field width determines the minimum number of characters to be written in some output representations. If the standard width of the representation is shorter than the field width, the representation is padded with fill characters at a point determined by the format flag adjustfield (one of left, right or internal).
• precision - The floating-point precision determines the maximum number of digits to be written on insertion operations to express floating-point values. How this is interpreted depends on whether the floatfield format flag is set to a specific notation (either fixed or scientific) or it is unset (using the default notation, which is not necessarily equivalent to either fixed nor scientific). For the default locale:
  • Using the default floating-point notation, the precision field specifies the maximum number of meaningful digits to display in total counting both those before and those after the decimal point. Notice that it is not a minimum, and therefore it does not pad the displayed number with trailing zeros if the number can be displayed with less digits than the precision.
  • In both the fixed and scientific notations, the precision field specifies exactly how many digits to display after the decimal point, even if this includes trailing decimal zeros. The digits before the decimal point are not relevant for the precision in this case.