copy-elision

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;

I have an uncopiable class. Copying this would be problematic. I want to guarantee that it won't be ever copied, so I made its copy constructor deleted : class A { public: A(); A(const A&) = delete; }; A fun() { return A(); }; int main() { A a = fun(); }; Unfortunately, g++ won't compile this on the reason: t.cc: In function ‘A fun()’: t.cc:8:12: error: use of deleted function ‘A::A(const A&)’ return A(); ^ t.cc:4:5: note: declared here A(const A&) = delete; ^ t.cc: In function ‘int main()’: t.cc:12:13: error: use of deleted function ‘A::A(const A&)’ A a = fun(); ^ t.cc:4:5: note: declared

It's stated in [C++11: 12.8/31] : This elision of copy/move operations, called copy elision, is permitted [...] : — in a return statement in a function with a class return type, when the expression is the name of a non-volatile automatic object ( other than a function or catch-clause parameter ) with the same cv-unqualified type as the function return type, the copy/move operation can be omitted by constructing the automatic object directly into the function’s return value This implies #include <iostream> using namespace std; struct X { X() { } X(const X& other) { cout << "X(const X& other)" <

I was reading Copy and Swap . I tried reading some links on Copy Elision but could not figure out properly what it meant. Can somebody please explain what this optimization is, and especially what is mean by the following text This is not just a matter of convenience but in fact an optimization. If the parameter (s) binds to a lvalue (another non-const object), a copy of the object is made automatically while creating the parameter (s). However, when s binds to a rvalue (temporary object, literal), the copy is typically elided, which saves a call to a copy constructor and a destructor. In the