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

Tony (aka "Guinness Tony") wrote:
> The C-style string insertion operators are, indeed,
> defined as free function templates in [lib.ostream]27.6.2.1:
>
> namespace std {
>   ...
>   template<class charT, class traits>
>   basic_ostream<charT,traits>&
> operator<<(basic_ostream<charT,traits>&,
>                                       const charT*);
>   template<class charT, class traits>
>   basic_ostream<charT,traits>&
> operator<<(basic_ostream<charT,traits>&,
>                                       const char*);
>   // partial specializationss
>   template<class traits>
>   basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
   ...
>
> [how odd - I've never noticed that "specializationss" typo before!]

Actually those overloaded operator<< functions aren't even template
specializations! In 2001 it was already noticed by Andy Sawyer: LWG issue
311
"Incorrect wording in basic_ostream class synopsis"
http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#311


> Sorry to have added unnecessary confusion to the discussion.

No problem.  I was mistaken as well, when I wrote:
>>
>> 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<<).

Only after seeing the reply by Vidar Hasfjord, I double-checked, and found
that my toolset actually accepted inserting a literal string onto a
tem****ary
stream, because it had offered that specific operator<< as a member
function!!! (I wasn't using STL****t.)


> Nevertheless, your example still compiles under the toolsets I have
> to hand...
>
>     int i = 42;
>     std::string s = static_cast<std::ostringstream&>(
>         std::ostringstream() << "i = " << i).str();
>
> ...but, on execution, I find that the operator<< chosen by the
> compiler is std::ostream::operator<<(const void*), which /is/ a
> member function (I checked this time!)  The text written into
> the stringstream's string buffer is not a copy of the string
> literal, but a representation of /the address of/ that string
> literal.

Interesting!!!  That could be a source of very nasty bugs, especially when
switching from one library implementation to another!


> In conclusion, the "flush trick" I presented in my previous post is
> also required when the first item in the insert-chain is a C-style
> string (including string literals), i.e.
>
>     int i = 42;
>     std::string s = static_cast<std::ostringstream&>(
>         std::ostringstream() << std::flush << "i = " << i).str();

Still, why do you think the "flush trick" is superior to creating a
"tem****ary" lvalue by means of a wrapper? Do you have any references,
showing
that the "flush trick" is indeed a well-known idiom?  (I wonder how many
people actually /know/ that std::flush is inserted by a member function,
while
other objects, e.g., strings, are inserted by non-member functions.)
Otherwise I think I'll stick to the wrapper...


Kind regards, Niels


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