ansaurus

Question

What determines when a destructor is called for a temporary object in C++?

Answer 1

+7 A:

coutn() create a temporary object, which will be destroyed at the next sequence point (the end of the line in this case).

Peter Alexander 2010-06-17 08:49:03

@Peter but why is this object temporary? And even though I write something like this: auto tmp = coutn << "Line one" << 1; it's still working.

There is nothing we can do 2010-06-17 08:50:43

@A-ha: When the compiler detects that an object will (and can) **not** be longer used, it calls the destructor. Usually this happens at the end of blocks or, as Peter stated, sequence points. In the case you describe, if `tmp` is no used afterwards, the compiler might just optimize things and decide it is a temporary object.

ereOn 2010-06-17 08:56:03

@A-ha: Simple answer: because the standard says so §12.2/1 *Temporaries are created in various contexts... returning an r-value* When you return an object from a function (as compared to a reference) a temporary object is created to hold the return value inside the function so that the caller can read it. Now, the compiler can optimize the creation of that temporary if it is used to initialize an object of the same type in the caller function in which case it will not be destroyed, but if it is created it must be destroyed at the next sequence point.

David Rodríguez - dribeas 2010-06-17 09:01:22

@A-ha: When you do the `auto tmp = ...` thing, you are creating a *copy* of the temporary object. The temporary is copied into `tmp` and then the temporary is destroyed. In that case, you'll get another destructor call when `tmp` goes out of scope.

Peter Alexander 2010-06-17 09:03:19

@Peter Alexander, A-ha: If you do `auto tmp = ...` chances are that the compiler will elide the creation of the temporary (by placing the `tmp` variable in the location of memory where the temporary would be created, and then not destroying anything at the next sequence point. That is, the compiler can manage in many cases to avoid the temporary and the copy construction by having both the temporary and the destination variable share the same memory. The net effect is that the function will initialize the `tmp` variable, the copy will not be performed, and only one object will be present.

David Rodríguez - dribeas 2010-06-17 09:06:26

@David: That's true, but he said that it still happened, so I'm guessing the compiler didn't manage to elide the copy.

Peter Alexander 2010-06-17 09:46:54

@Peter: Destruction of temporaries has absolutely nothing to do with sequence points. A temporary is destroyed when evaluation of the full-expression that contains the rvalue, whose evaluation triggered the creation of the temporary, is completed.

FredOverflow 2010-06-17 11:10:12

Answer 2

+3 A:

The standard says:

Temporary objects are destroyed as the last step in evaluating the full-expression that (lexically) contains the point where they were created.

A full-expression is an expression that is not a subexpression of another expression

FredOverflow 2010-06-17 11:14:28

ansaurus

tags:

views:

answers:

What determines when a destructor is called for a temporary object in C++?

related questions