When Exactly Do C Temporary Function Arguments Get Destroyed?

When Do Temporary Function Arguments Die?

In C , when a temporary object is created as an argument to a function, the compiler automatically manages its lifetime. This raises the question: at what point is the temporary object's destructor guaranteed to be called?

According to the C standard, temporary objects are destroyed at the end of the full expression they are part of. Here, a full expression is one that is not a sub-expression of another expression. It typically ends at the semicolon (;) or the closing parenthesis () of control flow statements (e.g., if, while, switch).

In the example provided:

class MyClass
{
  MyClass(int a);
};

myFunction(MyClass(42));

The temporary MyClass object created as a function argument will be destroyed after the function call statement ends, i.e., when the semicolon is encountered. Therefore, you can assume that the destructor will be called before any subsequent statements are executed.

It's worth noting that the lifetime of temporaries can be extended using const references. By binding a temporary to a const reference, its lifetime is extended to match that of the reference:

MyClass getMyClass();

{
  const MyClass& r = getMyClass(); // full expression ends here
  ...
} // object returned by getMyClass() is destroyed here

This technique can save unnecessary copy constructions while preserving the value returned by a function, especially when return value optimization is not applicable. However, with the advent of move semantics in C 11, its utility has diminished somewhat.

The above is the detailed content of When Exactly Do C Temporary Function Arguments Get Destroyed?. For more information, please follow other related articles on the PHP Chinese website!