Return Value Optimization - C++ - Destructor calls

Question

The following code calls the destructor 4 times:

#include<iostream>
using namespace std;

class A{
   public:
   A(){cout<<"A"<<endl;}
   ~A(){cout<<"~A"<<endl;}
   A f(){cout<<"F"<<endl; A b; return b;}
};

int main(){
   A a,b;
   b=a.f();
}

OUTPUT:

A
A
F
A
~A
~A
~A
~A

Can some one please explain? I was thinking that there should be only three destructor calls.

Answer 1

There are two objects in main(), so the destructor will be called two times just because of them. One object in f(), so the destructor will be called one time just because of it. Total 3 times (which you expect, but read on...)

Now the fourth time destructor is called for the temporary object which is created when returning from f. This can happen only when there is no RVO at all. RVO is compiler's choice which means it may optimize it, or it may not. The language doesn't give any guarantee of RVO.

Anyway, just increase your optimization level; I'm sure you will see at most 3 destructor invocations only.

Answer 2

There are 2 objects in main: A a,b;, one object in the body of function f() : A b; and then there is temporary object that is being copied and its copy stored into b.

When returning b in the body of your function, copy is created at first, then the local b is destructed, then copy is assigned into variable b declared in main and then this copy is destructed.

Add following line to class A definition and see yourself:

A(const A&) { cout << "copying" << endl; }

With Named Return Value Optimization, the compiler tries to eliminate redundant Copy constructor and Destructor calls which means that local b from the function f() will be assigned into variable b in main without copy being created. So with RVO / NRVO only 3 objects are created in your case.

Although there is a way how to avoid destructing this copy without RVO in your case:

A a;
A b = a.f();

in this case copy of return value of function f() is created and stored as a variable b. Which also means that no assigment operator is called and only 2 objects are created in main: a and copy of b returned by f().

Hope this helps.