Unexpected destructor call occurs when paired with move constuctor

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

Keep in mind that when an object is the source of a move operation it will still be destroyed. So the source of the move needs to put itself in a state such that being destructed will not release resources that it no longer owns (since they were moved to another object). For example, any raw pointers (that will now be owned by the move constructed object) in the source object should be set to NULL.