Question

The following code was compiled and run in Visual Studio 2012 Express for Windows Desktop, as a learning exercise.

#include <cstdio>

class X
{
public:
    X()  { printf("default constructed\n"); }
    ~X() { printf("destructed\n");}
    X(const X&) { printf("copy constructed\n"); }
    X(X&&) { printf("move constructed\n"); }
    X & operator= (const X &) { printf("copy assignment operator\n"); }
};

X A() {
    X x;
    return x;
}

int main() {
    {
        A();
    }
    std::getchar();
}

When compiled with compiler optimizations disabled (/Od), the resulting output indicates that the destructor is called twice. This is a problem given that only one object is constructed. Why is the destructor being called twice? Wouldn’t this be a problem if the class was managing it own resources?

default constructed
move constructed
destructed
destructed   <<< Unexpected call 

I tried a couple of experiments to try and explain the output, but ultimately these didn’t lead to any useful explanations.

Experiment 1: When the same code is compiled with optimizations enabled (/O1 or /O2), the resulting output is:

default constructed
destructed

which indicates that the Named Return Value Optimization has elided the call to the move constructor, and masked the underlying problem.

Experiment 2: Disabled the optimization and commented out the move constructor. The output generated was what I expected.

default constructed
copy constructed
destructed
destructed

Answer 1

Although Michael’s and jspcal answers are accurate, they didn’t answer the heart of my question, which was why were there two destructor calls made. I was expecting just one.

The answer is that function A() returns a temporary object. Always. This is how function return values work, and move-semantics has no bearing on this fact. I guess Michael and jspcal assumed that I had not missed such a basic fact. I equated the term “moved” with the concept of “swap”. When swapped, objects are not constructed and destructed. Hence I was expecting just one destructor call.

Since the returned object must be constructed and destructed, the second destructor call was made (and a second constructor call).

Now, the actual constructor selected to be executed depends on what is provided in the class definition. If a move-constructor is available, that will be called. Otherwise the copy constructor will be called.