Copy constructor elision?
c++, copy-constructor, copy-elision
Solution
Yes this is copy elision through Named Return Value Optimization.
The C++ standard allows an implementation to omit a copy operation resulting from a return statement, even if the copy constructor has side effects.
Reference:
C++03 Standard: 12.8 Copying class objects:
# 15
When certain criteria are met, an implementation is allowed to omit the copy construction of a class object, even if the copy constructor and/or destructor for the object have side effects. In such cases, the implementation treats the source and target of the omitted copy operation as simply two different ways of referring to the same object, and the destruction of that object occurs at the later of the times when the two objects would have been destroyed without the optimization.111) This elision of copy operations is permitted in the following circumstances (which may be combined to eliminate multiple copies):
— in a return statement in a function with a class return type, when the expression is the name of a non-volatile automatic object with the same cv-unqualified type as the function return type, the copy operation can be omitted by constructing the automatic object directly into the function’s return value
— when a temporary class object that has not been bound to a reference (12.2) would be copied to a class object with the same cv-unqualified type, the copy operation can be omitted by constructing the temporary object directly into the target of the omitted copy
Problem
Possible Duplicate: Why has the destructor been called only once? Given the code below, I fail to understand the output in gcc. I expect two objects to be created and destroyed but instead see only one call to the constructor and the destructor. What's happening here? ``` #include <string> #include <iostream> struct Huge{ Huge() { std::cout << "Constructor" << std::endl; } Huge(Huge const &r) { std::cout << "Copy Constructor" << std::endl; } ~Huge() { std::cout << "Destructor" << std::endl; } }; Huge g() { std::cout << "Entering g" << std::endl; Huge temp; std::cout << "Exiting g" << std::endl; return temp; } int main(){ Huge h2(g()); std::cout << "Before leaving main" << std::endl; } ``` The output of this code in g++ (4.4) is Entering g Constructor Exiting g Before leaving main Destructor