Re: cleanup of temporary objects
Micah Cowan ha scritto:
Martin Bonner <martinfrompi@yahoo.co.uk> writes:
On Feb 29, 10:58 am, yev...@gmail.com wrote:
Hi, sorry, messed up my previous post...
Consider the following code:
class A {
int x;
public:
A() { printf("In A()\n"); x = 5; }
~A() { printf("In ~A()\n"); }
operator int *() { printf("In int *()\n"); return &x; }
};
A f1()
{
printf("in f1()\n");
return A();
^
}
void foo(int *p) { printf("in foo()\n"); }
int main()
{
foo(f1());
^Here
printf("After foo()\n");
return 0;
}
I have always thought this code is wrong because the temporary object
A would be destroyed after calling int *() operator and before
entering foo(), so the pointer p would point to freed memory.
what should be correct behaviour according to c++ standard
regarding when the temporary is freed? Is the code above portable?
Temporaries created during the evaluation of an expression, are
destroyed "at the end of the full expression". In your case, this
means the temporary lives until the semi-colon I highlight above.
No. It's at the end of the full expression in which the temporary is
created. That would be at the semicolon _I_ highlighted.
Yes and no. See below.
12.2#3:
Temporary objects are destroyed as the last step in evalu- ating the
full-expression (1.9) that (lexically) contains the point where they
were created.
This is made much more explicit in #5:
A temporary bound to the returned value in a function return
statement (6.6.3) persists until the function exits.
^^^^^^^^^^^^^^^^^^^^^^^^
This statement does not apply here, the temporary is *not* bound to the
return value, because "binding" occurs only when the return value is a
reference type. In fact the clause you are referring to begins with the
words "The second context is when a reference is bound to a temporary."
This is no such context.
Your proposed full-expression obviously fails to lexically contain the point
where the temporary was created, and this case fails to meet the
criteria for exceptions to this rule. A conforming implementation, it
seems to me, would need to have destructed the temporary at the
point of the function's exit.
That is correct, but you are totally missing the point, because you are
talking about the wrong temporary object! Before destroying the
temporary in f1(), another temporary is created in function main() and
the main() temporary is copy-constructed using the f1() temporary, which
is still valid at the time of the copy. All this happens as part of the
return statement (see 6.6.3/2) (*).
So Martin Bonner correctly located the place where the temporary object
*in function main()* is destroyed, which what the OP is asking about.
HTH,
Ganesh
(*) However, the copy and the final destruction of the f1() temporary
can actually be elided in certain cases (the so-called RVO/NRVO).
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]