C++: What is the difference between ostream and ostringstream?
What is the difference between ostream and ostringstream? When would you use one versus the other?
Answer
Put succinctly: ostringstream provides a streambuf, ostream
requires the user to provide one.
To understand the implications, it's necessary to understand a little
how streams work, and I'm not sure that there's a good explanation of this on the Web. The basic abstraction
of ostream is formatting textual output. You give it an int or a
double (or a user defined type—more on that later), and it
convert it into a stream of characters, of type char. What it does
with that stream depends on the streambuf which is attached to it;
this is an example of the strategy pattern, where streambuf is an
abstract base class of the strategy[1]. The standard provides two
implementations of streambuf, filebuf and stringbuf; in practice,
in all but the most trivial applications, you'll probably have some that
you implement yourself.
When outputting, you always use ostream; it's the class over which the
<< operators are defined. You're formatting your data into a stream
of characters, and you don't really care where the stream ends up.
When creating an instance: if you create an ostream, you must provide
it with a streambuf yourself. More often, you'll create an
ofstream or an ostringstream. These are both "convenience" classes,
which derive from ostream, and provide a streambuf for it (filebuf
and stringbuf, as it happens). Practically speaking, all they do is
provide the necessary streambuf (which affects the constructor and the
destructor, and not very much else); in the case of ofstream, there
are also a few extra functions which forward to additional functions in
the filebuf interface.
It's usual (but by no means required) when you define your own
streambuf to provide convenience overloads of ostream (and
istream, if relevant), along the same lines as ofstream or
ostringstream.
By the same token, when creating an instance, it's usual to use one of
the "convenience" derived classes, rather than to use ostream directly
and provide your own streambuf.
And if all of this seems complicated: the iostream classes use just
about all of the facilities of C++ (virtual functions, templates and
function overloading all play an important role). If you're just
learning C++, don't worry too much about it: just use ofstream or
ostringstream when you construct an instance, but pass around
references to ostream. And as you learn about techniques like virtual
functions, templates and operator overloading, return to the iostreams
to understand the role they play in making code more flexible.
[1] For various reasons, std::streambuf is not actually abstract. But
the implementations of the virtual functions in it are useless;
extraction always returns EOF, and insertion always fails.