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

On 23 Apr, 20:14, "Niels Dekker - no return address"
<nore...@[EMAIL PROTECTED]
> wrote:
> Does the Standard Library sup****t creating an std::string by means of
> streaming, without having to declare a *named* ostringstream object?  I
tried
> the following:
>
>    #include <sstream>
>    #include <string>
>    int i = 42;
>
>    std::string s = (std::ostringstream() << "i = " << i).str();
>
> Of course it didn't compile, because a tem****ary (std::ostringstream())
cannot
> be passed as non-const reference to a function (operator<<).

This is odd.  The operator<< that is called here...

>    std::string s = (std::ostringstream() << "i = " << i).str();
                                            ^^

is member function std::ostream::operator<<(char const*).  There is no
case of a tem****ary being bound to a non-const reference here.  It is
perfectly legal and should compile just fine.  What compiler are you
using
that complains here (without the .str() business)?

The problem you describe would occur if the argument to operator<<
were not
catered-for by the overloaded set of member functions in
std::basic_ostream
(e.g. if it were a std::string or std::complex<T>.)  There is a well-
known
idiom for cir***venting this problem (without inventing your wrapper
class)
by using the knowledge that the member-function versions of operator<<
all
return lvalue references; one such member is the one that executes
free
functions whose signatures resemble "std::ostream&
func(std::ostream&)"
as if they were manipulators in the operator<< chain (e.g. std::endl,
std::flush.)  The idiomatic approach is to select std::flush for this
job as it has no discernible side-effects; thus:

     int i = 42;
     std::string prefix = "i = ";
     std::ostringstream() << std::flush << prefix << i;

> Okay, second try, wrapping the ostringstream as follows:
>
>   template <typename T> class Wrapper {
>    T m_data;
>   public:
>    T & get() {
>     return m_data;
>    }
>   };
>
>   std::string s = (Wrapper<std::ostringstream>().get() << "i = " <<
i).str();

As explained above, all this is unnecessary.  You should still be
addressing
the single problem in your code as originally presented.

> Unfortunately it still didn't compile, because operator<< returns an
> std::basic_ostream, instead of an std::ostringstream, and therefore it
doesn't
> have an str() member function.  Now I wonder, is it safe to cast the
stream,
> returned by operator<< to an ostringstream reference?

Yes, indeed.  And since you *know* that the actual object (to whom the
ostream reference refers) is definitely an ostringstream, you can use
static_cast rather than dynamic_cast:

     int i = 42;
     std::string s = static_cast<std::ostringstream&>(
         std::ostringstream() << "i = " << i).str();

> At least, it *seems* to work...   But is it the proper way to do it?

Yes.

And if you need to cope with e.g. string objects as the first
item in the operator<< chain, you can also employ the temp-to-lvalue
conversion outlined above, e.g.

     int i = 42;
     std::string prefix = "i = ";
     std::string s = static_cast<std::ostringstream&>(
         std::ostringstream() << std::flush << prefix << i).str();

Regards,
Tony.


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