Is this defined?

[Razzer]

Recently, I saw someone use this marco:

#define MAKE_STRING(msg) \
(((ostringstream&)(ostringstream()<<msg)).str())

(Assume that the std namespace had been brought into the global scope.)

My question is that if this is defined. I think isn't. It seems to me
that the temporary is being passed around to non-const references
during its lifetime. Am I just plain wrong?

[Swampmonster]

Razzer wrote:

Recently, I saw someone use this marco:

#define MAKE_STRING(msg) \
(((ostringstream&)(ostringstream()<<msg)).str())

(Assume that the std namespace had been brought into the global scope.)

My question is that if this is defined. I think isn't. It seems to me
that the temporary is being passed around to non-const references
during its lifetime. Am I just plain wrong?

I really don't see a problem with that code.
Basically it's the same as if you write something like

int x = atoi( (std::string("1") + std::string("2")).c_str() );

which should be perfectly fine.

Temporaries created as a result of expression evaluation are
guaranteed to live exactly until the end of the expression
statement, which would be that ";" thingy.

Meanwhile it's perfectly fine to use them as an l-value like in:

int x = atoi( (std::string() = "10").c_str() );

or even

int foo = atoi( ((std::string() = "10") = "142").c_str() + 1 );

or like in the MAKE_STRING macro you posted.

I think what you mean is the nasty

std::string& foo = std::string("foo");

thingy which is of course bullshit (although it compiles).

But since the "str()" function (which is the "result" of that
MAKE_STRING macro you posted) finally returns a "basic_string"
and not a referenct to something that's all not a problem here.

And finally, the cast to "ostringstream&" is only there because
operator "<<" returns a ref to "basic_ostream" (base-type), but
the "str()" function is defined in "ostringstream" so you have
to cast it back to a ref to the "real" type to be able to call it.

[Maxim Yegorushkin]

On Fri, 17 Jun 2005 03:31:59 +0400, Razzer <co********@gmail.com> wrote:

Recently, I saw someone use this marco:

#define MAKE_STRING(msg) \
(((ostringstream&)(ostringstream()<<msg)).str())

(Assume that the std namespace had been brought into the global scope.)

My question is that if this is defined. I think isn't. It seems to me
that the temporary is being passed around to non-const references
during its lifetime. Am I just plain wrong?

Well formedness of this macro depends on the type of msg and the
overloaded operator<< for std::ostream& and msg. If it is a standard
std::ostream& std::operator<<(std::ostream&, ...) then the code is
ill-formed since an r-value (the temporary created as ostringstream()) can
not be bound to a reference to a non-constant. If it is an overloaded
operator<<, which takes an std::ostream/ostringstream as a reference to
constant and returns something that can be casted to std::ostringstream&,
then the code might be well-formed.

--
Maxim Yegorushkin

[Swampmonster]

Meanwhile it's perfectly fine to use them as an l-value like in:

int x = atoi( (std::string() = "10").c_str() );

or even

int foo = atoi( ((std::string() = "10") = "142").c_str() + 1 );

Argh. Sorry, just forget that. It's not using the temporary as an
l-value, since it's just calling a member function which is not
forbidden on non-l-values.
Of course the temporary _is_ a non-l-value ... this stuff always
confuses me a little - I should have kept my great ideas to myself.

Sorry again.

Nevertheless I think the MAKE_STRING macro will work, but if it's
really 100% O.K. with the standard I can't tell.