object destructed before move operation - c++11

Question

#include <iostream>
static int i=0;
using namespace std;
class Movable
{
public:
Movable ():mId(++i){
cout<<"constructing it "<<mId<<endl;
};
Movable (const Movable&)=delete;
Movable (Movable&)=delete;
void operator=(Movable&)=delete;
void operator=(const Movable&)=delete;
Movable (const Movable&& aObject)
{
cout<<"Moving it constant "<<mId<<endl;
// mId=++i;
};
Movable (Movable&&aObject)
{
cout<<"Moving it "<<mId<<endl;
};
Movable &operator=( Movable&&aObject)
{
cout<<"Moving it assignment "<<mId<<endl;
return *this;
}
Movable &operator=(const Movable&&aObject)
{
cout<<"Moving it assignment constant "<<mId<<endl;
return *this;
}
~Movable ()
{
cout<<"destroying it "<<mId<<endl;
}
int getId() const {
return mId;
}
private:
int mId;
};
Movable&& CreatenNewMovable ()
{
Movable lM;
return std::move(lM);
}
int main() {
Movable a;
a=CreatenNewMovable();
return 0;
}
The output result of this code is
constructing it 1
constructing it 2
destroying it 2
Moving it assignment 1
destroying it 1
I'm a little bit confused how is it possible to destroy the temp object then move it to second. Is that an undefined behavior ? m I missing something about the move operation?

Answer 1

Yes, this function
Movable&& CreatenNewMovable ()
{
Movable lM;
return std::move(lM);
}
is broken.
An r-value reference is still a reference, in this case its a reference to a local stack object which is destroyed when the function terminates (before it is moved from). Instead you should just return it by value, it will still get moved out of and if there is copy-ellision then it will be efficient.

Answer 2

Look at this snippet:
Movable&& CreatenNewMovable ()
{
Movable lM;
return std::move(lM);
}
Actually this is Undefined Behaviour. There are 2 problems:
A function can return its value only by value (probably a reference value). So, you must replace Movable&& with Movable here.
Creating Movable lM; on the stack and referencing it outside the function is UB. When the function exits, the object no longer exists. Return it simply by value - in your case copy elision will be in effect.
Finally, a valid way is :
Movable CreatenNewMovable ()
{
Movable lM;
return lM;
// ..or..
// Even better to return like this(copy elision has less chances to fail)
// return Movable();
}
This will produce result you are waiting:
$ ./w
constructing it 1
constructing it 2
Moving it assignment 1
destroying it 2
destroying it 1
You can reduce even this job by removing empty object creation in your main:
int main() {
Movable a=CreatenNewMovable();
return 0;
}
/* Results:
$ ./w
constructing it 1
destroying it 1
*/