Like <strstream>, <sstream) defines three classes that cooperate to help you read and write character sequences stored in memory:

• stringbuf, derived from streambuf to mediate access to an in-memory character sequence and grow it on demand (yes, the name should be stringstreambuf for greater uniformity)
• istringstream, derived from istream to construct a stringbuf object with input and/or output streams and to assist in extracting from the stream
• ostringstream, derived from ostream to construct a stringbuf object with input and/or output streams and to assist in inserting into the stream

• You can initialize the character sequence controlled by a stringbuf from the character sequence controlled by a string, when the stringbuf is constructed or repeatedly thereafter.
• You can initialize the character sequence controlled by a newly constructed string object from the character sequence controlled by a stringbuf.
• You can specify independently, when a stringbuf is constructed, whether the input stream is readable or the output stream is writable.

The classes istringstream and ostringstream behave much like istrstream and ostrstream. They construct a stringbuf object for you. They also provide member functions that access the special features of a stringbuf object. In this case, that mostly involves copying to and from string objects, as described above.

A few subtle differences exist between class stringbuf and class strstreambuf. If an object of the latter class defines an output sequence, it always defines an input sequence as well. But that is not always true for an object of class stringbuf. Otherwise, the two kinds of stream buffers are more alike than different.

To reproduce the existing functionality, the library instantiates these general templates for T defined as type char. The net result is much the same, but the machinery — and the notation — is now far more elaborate. I prefer to show the behavior of iostreams for the more familiar char-based streams.

The library also instantiates these templates for T defined as type wchar_t. If you want to manipulate wide-character strings, that can be invaluable, but such usage is still relatively rare. Even more rare is the use of iostreams based on arbitrary characters of type T. (As far as I know, such usage is nonexistent.) It will be interesting to see how useful such generality will prove in future practice.

I also reported last month that the header <strstream) has been exempted from the templatizing treatment. The committee is staking the future on <sstream>, which does much the same thing as <strstream) but works with templatized strings of arbitrary character types. The older header <strstream> is retained mostly in the interest of preserving existing code.

Finally, I note that the member function name str has already been changed in class string since March 1994. It is now data. That cleanup has yet to extend to the classes defined in <sstream>, but it might.

• read only
• write only
• read/write

If all you want to do is read an inmemory character sequence that is initialized from a string object, construct an object of class istringstream. If you know at construction time what string object s you wish to use, you can write:

istringstream strin(s);

strin.str(s2);

You can also construct an istringstream object with an empty character sequence, using the default constructor. Presumably, you would later supply a non-empty character sequence, as in:

istringstream strin;
strin.str(s);

ostringstream strout;

Your goal in creating a write-only character sequence is to capture the final result in a string object, as a rule. Write s = strout.str() to construct a string object, initialize it to control a copy of the character sequence, and assign it to the string object s. The two character sequences can, of course, evolve separately thereafter.

If you want a null-terminated string, there is no real need to insert a null character last. It will not be supplied for you when you call s = strout.str(), as above. On the other hand, you must then call s.c_str() to get a pointer to the beginning of the character sequence. That call will supply a terminating null character.

If you want to create an in-memory character sequence that you can read as well as write, you need two objects to control the input and output streams. The classes istringstream and ostringstream are highly symmetric. Thus, you have three equally valid ways to do the job. If you don't want to supply an initial character sequence, you can write:

istringstream istr(ios::in | ios::out);
ostream ostr(istr. rdbuf());

ostringstream ostr(ios::in | ios::out);
istream istr(ostr. rdbuf());

stringbuf sb(ios::in | ios::out);
istream istr(&sb);
ostream ostr(&sb);

You can also supply an initial character sequence from a string object s in each of these three cases:

istringstream istr(s, ios::in | ios::out);
ostream ostr(istr. rdbuf( ) );

ostringstream ostr(s, ios::in | ios::out);
istream istr(ostr. rdbuf() );

stringbuf sb(s, ios::in | ios::out);
istream istr(&sb);
ostream ostr(&sb);