Re: reference lifetimes...
On Nov 11, 1:26 pm, Victor Bazarov <v.Abaza...@comAcast.net> wrote:
James wrote:
Here is my code:
#include <iostream>
struct foo
{
foo()
{
std::cout << this
<< "->foo::foo()"
<< std::endl;
}
~foo()
{
std::cout << this
<< "->foo::~foo()"
<< std::endl;
}
};
struct foo_holder
{
foo const& m_ref;
};
int main()
{
{
foo_holder fh = { foo() };
std::cout << "okay" << std::endl;
}
std::cout << std::endl;
{
foo const& ref = foo();
std::cout << "okay" << std::endl;
}
return 0;
}
Why does the const reference not properly maintain its
lifetime over the call to 'cout' when the reference is
contained within a POD 'foo_holder'? I get the following
output:
0x22ff50->foo::foo()
0x22ff50->foo::~foo()
okay
0x22ff50->foo::foo()
okay
0x22ff50->foo::~foo()
Something seems terribly wrong here... Is there anyway to
overcome this?
The form
T t = { blah };
is copy-initialisation.
But not of T. In his case, he copy initializes the member m_ref
of foo_holder with a temporary.
The compiler is free to create another temporary (of your
class 'foo_holder') before initializing 'fh' with it, which
makes the temporary's 'm_ref' member bound to the temporary
'foo'.
I don't see anything in the standard which says that. He's
using aggregate initialization, which means that he's providing
a list of expressions to initialize each of the elements of the
aggregate. In his case, foo() is the expression which
initializes the foo_holder::m_ref, and not the foo_holder
itself. And the distinction between copy initialization and
direct initialization doesn't apply to either references or
aggregate initialization. (If you'll look at the points in
=A78.5/14, you'll see that the standard sends you to another
section for both aggregate initialization and reference
initialization, before considering whether it is copy
initialization or not.) The compiler can still make a copy (at
least at present), but then it is the copy which is bound to the
reference, and whose lifetime is extended. (And of course, if
the compiler did make a copy, we'd see two calls to the
destructor each time.)
The 'foo_holder' temporary is destroyed after initialising of
the 'fh' variable, causing the destruction of your foo'
temporary.
There is no foo_holder temporary.
The references when initialised with the above form are
treated differently. A possible copy of the object is created
and the reference is then bound to it. That temporary (either
another one or the original one) survives as long as the
reference.
Also, I don't think this has anything to do with PODs.
No. It's a question of aggregate initialization.
--
James Kanze