«

How do you save the formatting options for a stream? In the program
below, notice that when I define my operator<<() for the custom type, it
permanently changes the output format of the stream:

#include <iostream>
#include <iomanip>

struct Data {
double d;
};

std:stream&
operator<<(std:stream& o, const Data& d)
{
//std:stream old;
//old.copyfmt(o);
o << "during: " << std::fixed << std::setprecision(3) << d.d;
//o.copyfmt(old);
return o;
}

int main()
{
Data d;
d.d = 3.14159;

double dd;
dd = 3.14159;
std::cout << "before: " << dd << '\n';
std::cout << d << '\n';
std::cout << " after: " << dd << '\n';

return 0;
}

output:
before: 3.14159
during: 3.142
after: 3.142


When I uncomment the lines in operator<<(), I get a "no appropriate
default constructor available" error, and when I tried

std:stream old(o);

I get a "no copy constructor available or copy constructor is declared
'explicit'" error.


So, how do I save the old formatting options for the stream, and restore
them before returning?

--
Marcus Kwok

Marcus Kwok wrote:

> How do you save the formatting options for a stream? In the program
> below, notice that when I define my operator<<() for the custom type, it
> permanently changes the output format of the stream:
>
> #include <iostream>
> #include <iomanip>
>
> struct Data {
> double d;
> };
>
> std:stream&
> operator<<(std:stream& o, const Data& d)
> {
> //std:stream old;
> //old.copyfmt(o);
> o << "during: " << std::fixed << std::setprecision(3) << d.d;
> //o.copyfmt(old);
> return o;
> }
>
> int main()
> {
> Data d;
> d.d = 3.14159;
>
> double dd;
> dd = 3.14159;
> std::cout << "before: " << dd << '\n';
> std::cout << d << '\n';
> std::cout << " after: " << dd << '\n';
>
> return 0;
> }
>
> output:
> before: 3.14159
> during: 3.142
> after: 3.142
>
>
> When I uncomment the lines in operator<<(), I get a "no appropriate
> default constructor available" error, and when I tried
>
> std:stream old(o);
>
> I get a "no copy constructor available or copy constructor is declared
> 'explicit'" error.
>
>
> So, how do I save the old formatting options for the stream, and restore
> them before returning?
>

Just don't change them:

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

struct Data {
double d;
};

std:stream&
operator<<(std:stream& o, const Data& d)
{
std::stringstream str;
str << "during: " << std::fixed << std::setprecision(3) << d.d;
o << str.str();
return o;
}

int main()
{
Data d;
d.d = 3.14159;

double dd;
dd = 3.14159;
std::cout << "before: " << dd << '\n';
std::cout << d << '\n';
std::cout << " after: " << dd << '\n';

return 0;
}


Best

Kai-Uwe Bux

Marcus Kwok wrote:
> std:stream&
> operator<<(std:stream& o, const Data& d)
> {
> //std:stream old;

Use 'std:stream old(0);' instead: the constructor of 'std:stream'
requires a stream buffer but this can be null.
--
<private.php?do=newpm&u=> <http://www.dietmar-kuehl.de/>
<http://www.eai-systems.com> - Efficient Artificial Intelligence

Kai-Uwe Bux wrote:
> Just don't change them:

> std:stream&
> operator<<(std:stream& o, const Data& d)
> {
> std::stringstream str;
> str << "during: " << std::fixed << std::setprecision(3) << d.d;
> o << str.str();
> return o;
> }

This doesn't work: for example, when called using code like this
it behaves in unexpected ways:

std::cout << std::showpos << d;
--
<private.php?do=newpm&u=> <http://www.dietmar-kuehl.de/>
<http://www.eai-systems.com> - Efficient Artificial Intelligence

On 2006-02-17, Dietmar Kuehl <> wrote:
> Marcus Kwok wrote:
>> std:stream&
>> operator<<(std:stream& o, const Data& d)
>> {
>> //std:stream old;
>
> Use 'std:stream old(0);' instead: the constructor of 'std:stream'
> requires a stream buffer but this can be null.

I was going to suggest:

std:stream::ios_type old;

The docs say it can't be used until init is called, but it's not clear
if that means you can't simply copy format information in and then out
again.

If you wind up needing to call init before copyfmt, then yucky.

--
Neil Cerutti
A billion here, a billion there, sooner or later it adds up to
real money. --Everett Dirksen

Neil Cerutti wrote:

> I was going to suggest:
>
> std:stream::ios_type old;

I have no idea what the above is...? Are you referring to
'std::ios_base'? This cannot hold the complete format and I
don't think it is equipped with a 'copyfmt()' member function.
The other candidate would be 'std::ios'. However:

> If you wind up needing to call init before copyfmt, then yucky.

The design of the initialization of 'std::ios_base' and 'std::ios'
sucks^H^H^H^H^His suboptimal and you indeed need to call 'init()'
before you can do anything to 'std::ios'. In particular, a call
to 'init()' is strictly required even to destruct the object (the
standard is explicit about this in lib.basic.ios.cons paragraph 2,
second sentence).
--
<private.php?do=newpm&u=> <http://www.dietmar-kuehl.de/>
<http://www.eai-systems.com> - Efficient Artificial Intelligence

Dietmar Kuehl <> wrote:
> Marcus Kwok wrote:
>> std:stream&
>> operator<<(std:stream& o, const Data& d)
>> {
>> //std:stream old;
>
> Use 'std:stream old(0);' instead: the constructor of 'std:stream'
> requires a stream buffer but this can be null.

Nice, this seems to work great. Thanks.

--
Marcus Kwok

Marcus Kwok wrote:
> Dietmar Kuehl <> wrote:
>> Use 'std:stream old(0);' instead: the constructor of 'std:stream'
>> requires a stream buffer but this can be null.
>
> Nice, this seems to work great. Thanks.

Note, however, this creation of a stream object is relatively
involved. At the very least it initialized quite a few member
variables and it might even do memory allocations. Thus, if you
need to save the format frequently you might want to consider
using just one stream object, e.g. by using a function static
object:

{
static std:stream old(0);
...
}

This object will only be constructed once. Of course, it will
also cause problems in multi-threaded code.
--
<private.php?do=newpm&u=> <http://www.dietmar-kuehl.de/>
<http://www.eai-systems.com> - Efficient Artificial Intelligence

On 2006-02-17, Dietmar Kuehl <> wrote:
> Neil Cerutti wrote:
>
>> I was going to suggest:
>>
>> std:stream::ios_type old;
>
> I have no idea what the above is...? Are you referring to
> 'std::ios_base'? This cannot hold the complete format and I
> don't think it is equipped with a 'copyfmt()' member function.
> The other candidate would be 'std::ios'. However:

Yes, thanks for the correction. I had meant to use a basic_ios type.

>> If you wind up needing to call init before copyfmt, then yucky.
>
> The design of the initialization of 'std::ios_base' and 'std::ios'
> sucks^H^H^H^H^His suboptimal and you indeed need to call 'init()'
> before you can do anything to 'std::ios'. In particular, a call
> to 'init()' is strictly required even to destruct the object (the
> standard is explicit about this in lib.basic.ios.cons paragraph 2,
> second sentence).

So there's a default constructor because...

No wonder Stroustrup doesn't cover this stuff.

--
Neil Cerutti

Dietmar Kuehl <> wrote:
> Marcus Kwok wrote:
>> Dietmar Kuehl <> wrote:
>>> Use 'std:stream old(0);' instead: the constructor of 'std:stream'
>>> requires a stream buffer but this can be null.
>>
>> Nice, this seems to work great. Thanks.
>
> Note, however, this creation of a stream object is relatively
> involved. At the very least it initialized quite a few member
> variables and it might even do memory allocations. Thus, if you
> need to save the format frequently you might want to consider
> using just one stream object, e.g. by using a function static
> object:
>
> {
> static std:stream old(0);
> ...
> }
>
> This object will only be constructed once. Of course, it will
> also cause problems in multi-threaded code.

Oh, I see. So, for example, if I had a

std::vector<Data> v;

and did a

std::copy(v.begin(), v.end(), std:stream_iterator<Data>(std::cout, "\n"));

then it would have to create/destroy a new std:stream for every
element in the vector, correct? That does seem like quite a bit of
overhead.

The static member/multithreading issue is also significant, but since
that is OT here (until they add concurrency to the standard) I can defer
that argument to another place and time.

It would be nice if the standard had a lightweight "format" class to
store this in.

This question was mainly academic for me, and due to the two issues
above, it looks like it may not be possible to have a completely
satisfactory solution that can be used in production code. I guess I
should just stick to explicitly formatting where needed.

--
Marcus Kwok