Re: How to build a string on the fly, using std::ostringstream? [Reposting]

On Apr 28, 11:06 pm, vova...@[EMAIL PROTECTED]
 wrote:
> This can be done by changing a member
>    std::auto_ptr <std::ostringstream> s;
> with
>    std::stringstream s;
> and defining the copy constructor with
>    s << sb.s.rdbuf();
> in its body. Not sure if this approach is any better.

It does remove the need for dynamic allocation of the stream, but it
requires two instances of the stream and copying of the content
between them. Creating instances and copying will involve dynamic
allocation. Hence I doubt it is any more efficient than dynamic
allocation of the stream.

The underlying problem is that ostringstream is not swappable. While I
saw a glimmer of hope in using rdbuf to swap the stringbuffers,
unfortunately a derived stream may use its own buffer (not the one
returned by ios::rdbuf), and unfortunately ostringstream does just
that. It even hides the mutating version of rdbuf, so you cannot
replace the buffer.

A custom stream overcomes this problem:

   // Swappable string buffer

   class stringbuf
     : public std::stringbuf
   {
   public:
    explicit stringbuf ()
       : std::stringbuf (std::ios_base::out)
     {}

     void swap (stringbuf& other) throw ()
     {
       char* gbegin = other.eback ();
       char* gnext = other.gptr ();
       char* gend = other.egptr ();
       other.setg (eback (), gptr (), egptr ());
       setg (gbegin, gnext, gend);

       char* pbegin = other.pbase ();
       char* pnext = other.pptr ();
       char* pend = other.epptr ();
       other.setp (pbase (), pptr (), epptr ());
       setp (pbegin, pnext, pend);
     }
   };

   // String stream base

   typedef std::basic_ostream <char, std::char_traits <char> >
     ostringstream_base;

   // Swappable string stream

   class ostringstream
     : public ostringstream_base
   {
   public:
     ostringstream ()
       : ostringstream_base (&buf)
     {}

     void swap (ostringstream& other) throw ()
     {buf.swap (other.buf);}

     stringbuf* rdbuf()
     {return &buf;}

     std::string str () const
     {return buf.str();}

     void str (const std::string& s)
     {buf.str (s);}

   private:
     stringbuf buf;
   };

Regards,
Vidar Hasfjord

-- 
      [ See http://www.gotw.ca/resources/clcm.htm
for info about ]
      [ comp.lang.c++.moderated.    First time posters: Do this! ]