What is the difference between ostream and ostringstream? When would you use one versus the other?
ostringstream provides a
ostream requires the user to provide one.
To understand the implications, it's necessary to understand a little how streams work (and unlike some other posters, I'm not sure that there's a good explination 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. The standard provides two implementations of
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 (
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
It's usual (but by no means required) when you define your own
streambuf to provide convenience overloads of
istream, if relevant), along the same lines as
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
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.
 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.