How to deal with iomanips in custom output operators? - c++

Question

I just came across the problem of combining custom output operators with io-manipulators. Maybe my expectations are completely off, but if
std::cout << foo() << "\n";
prints
00
then I would expect
std::cout << std::left << std::setw(20) << foo() << "!\n"
to print
00 !
but given this implementation
#include <iostream>
#include <iomanip>
struct foo { int a,b; };
std::ostream& operator<<(std::ostream& out, const foo& f) {
out << f.a << f.b;
return out;
}
int main() {
std::cout << foo() << "\n";
std::cout << std::left << std::setw(20) << foo() << "!";
}
what is printed on the screen is
00
0 0!
I see basically two options: A) My expectations are just wrong. B) I use this implementation instead:
std::ostream& operator<<(std::ostream& out, const foo& f) {
std::stringstream ss;
ss << f.a << f.b;
out << ss.str();
return out;
}
However, this seems like quite some overhead considering that most of the time no io manipulators are used.
What is the idiomatic way of treating io-manipulators "correctly" in custom output operators?

Answer 1

I'm afraid there is no easy answer. Your solution is idiomatic if you only need to handle std::setw and std::left, but, for other manipulations, you have to decide the behavior of your formatter.
Imagine, for example, if your struct had floats instead of ints:
struct foo { float a,b; };
Then, your user tries to do this:
const long double pi = std::acos(-1.L);
std::cout << std::setprecision(10) << foo{0.0f, pi} << "!\n"
This is when you have to decide: Do you want to honor the precision property of the output stream, or do you want to ignore it? Your current implementation would ignore it, since it does the actual conversion in another stream.
To honor the precision property, you would have to copy it:
std::ostream& operator<<(std::ostream& out, const foo& f) {
std::stringstream ss;
ss.precision(out.precision());
ss << f.a << f.b;
out << ss.str();
return out;
}
For your case of integers, you also have to consider if you will honor std::setbase or not.
The same reasoning will have to be applied for the other manipulators, such as std::setfill, for example.

Answer 2

Not necessarily idiomatic, but one possible appraoch is this:
struct foo {
int a,b;
std::string toString() {
std::stringstream ss;
ss << a << b;
return ss.str();
}
};
std::ostream& operator<<(std::ostream& out, const foo& f) {
out << a << b;
return out;
};
Now the caller may choose whether output should be as a whole or not:
std::cout << std::left << std::setw(20) << foo().toString() << "!"; // output as expected
std::cout << foo(); // output as expected
// and no unnecessary overhead
One might also argue that output is already slow, so a bit of additional overhead does not hurt and simply implement the output operator in terms of the stringify method:
std::ostream& operator<<(std::ostream& out, const foo& f) {
out << f.toString();
return out;
}
This also fixed the minor ugliness of the first approach which basically implements the same thing twice with almost identical code.