C ++: what is the difference between ostream and ostringstream?

advertisements

What is the difference between ostream and ostringstream? When would you use one versus the other?


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 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[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.