Re: Lifetime of a temporary that is bound to a reference
"Markus Schoder" <a3vr6dsg-usenet@yahoo.de> schrieb im Newsbeitrag
news:fe3dol$19lr$1@energise.enta.net...
On Tue, 02 Oct 2007 12:54:19 -0600, Matthias Hofmann wrote:
"Markus Schoder" <a3vr6dsg-usenet@yahoo.de> schrieb im Newsbeitrag
news:pan.2007.05.24.18.58.38@yahoo.de...
Even if this were a case of the reference member being initialized by a
temporary (I doubt that it works that way) that would not change things
much. The reference member is initialized through a ctor-initializer
and 12.2/5 specifies this as a special case where the temporary
"persists until the constructor exits".
I agree. According to my interpretation of the standard, the following
code has undefined behaviour:
#include <iostream>
class Foo
{
const int& m_value;
public:
Foo( const int& value ) : m_value( value ) {} void f() { std::cout
<< m_value << std::endl; }
};
int main()
{
Foo( 42 ).f();
}
I think this code has well defined behaviour. A temporary is created that
is then bound to the reference parameter of the Foo constructor. By my
interpretation the lifetime of a temporary is determined in the context
where it is created and therefore should be the full-expression here.
The fact that the reference that is bound to the temporary is then used
in a ctor-initializer should not have an impact on the temporary's
lifetime.
I just read 12.2 paragraphs 3, 4 and 5 again to find out that they somehow
puzzle me:
12.2/3: "[...] Temporary objects are destroyed as the last step in
evaluating the full-expression (1.9) that (lexically) contains the point
where they were created. [...]"
12.2/4: "There are two contexts in which temporaries are destroyed at a
different point than the end of the fullexpression. [...]"
12.2/5: "The second context is when a reference is bound to a temporary.
[...] A temporary bound to a reference parameter in a function call (5.2.2)
persists until the completion of the full expression containing the call. A
temporary bound to the returned value in a function return statement
(6.6.3)
persists until the function exits. [...]"
Now why does 12.2/5 say that a reference parameter in a function call
persists until the completion of the full expression containing the
call, if
that's just what 12.2/3 says? What is the difference in lifetime for a
temporary created in a full expression, and for a temporary bound to a
reference parameter in a function call contained in a full expression? I
cannot see any difference there!
I further wonder whether a temporary bound to the returned value in a
function call is useful at all? If a temporary is bound to the returned
value in a function call, then you cannot use it within the function,
because the latter is about to exit. Outside the function, however, it
cannot be used either, because, as 12.2/5 says, it will already have been
destroyed.
Anyway, I meanwhile think that the expression 'Foo( 42 ).f();' from the
example above is indeed well defined. As 12.2/5 does not mention reference
parameters in a constructor call, I also think that the sentence in 12.2/3
that I quoted above is the one that applies here.
Note: My earlier post was made somewhere in May 2007. For whatever reason
it took more than 4 months to appear in this newsgroup. This post is made
on Oct 4 2007 I hope it gets there a bit quicker.
The reason was that I hadn't dealt with C++ for a couple of months and your
post finally made me return to this newsgroup, thus helping me find back my
way into programming! ;-)
--
Matthias Hofmann
Anvil-Soft, CEO
http://www.anvil-soft.com - The Creators of Toilet Tycoon
http://www.anvil-soft.de - Die Macher des Klomanagers
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]