Move constructor never gets called [duplicate] - c++

Question

This question already has an answer here:
Why is the move-constructor not called?
(1 answer)
Closed 4 years ago.
I have written the below piece of code:
#define LOG cout << __PRETTY_FUNCTION__ << endl;
class MyClass
{
private:
int* ptr;
public:
MyClass()
: ptr(new int(10))
{
LOG
}
~MyClass()
{
LOG
if (ptr)
{
delete ptr;
ptr = nullptr;
}
}
MyClass(const MyClass& a)
: ptr(nullptr)
{
LOG
ptr = new int;
*ptr = *(a.ptr);
}
MyClass& operator=(const MyClass& a)
{
LOG
if (this == &a)
{
return *this;
}
delete ptr;
ptr = new int;
*ptr = *(a.ptr);
return *this;
}
MyClass(MyClass&& a)
: ptr(nullptr)
{
LOG
ptr = a.ptr;
a.ptr = nullptr;
}
MyClass& operator=(MyClass&& a)
{
LOG
if (this == &a)
{
return *this;
}
delete ptr;
ptr = a.ptr;
a.ptr = nullptr;
return *this;
}
void printClass()
{
LOG;
}
};
MyClass function()
{
MyClass m;
return m;
}
int main()
{
MyClass m = function();
return 0;
}
Output of the program:
MyClass::MyClass()
MyClass::~MyClass()
This does not call the move constructor. Is there something is wrong?
I was expecting the below output:
MyClass::MyClass()
MyClass::MyClass(MyClass&&)
MyClass::~MyClass()
MyClass::MyClass(MyClass&&)
MyClass::~MyClass()
MyClass::~MyClass()
It might look like the compiler is doing some optimisation. If this the case then why we need move constructor or move assignment operator for our case.

Answer 1

This does not call the move constructor. Is there something is wrong?
No, there is nothing wrong.
It might look like the compiler is doing some optimisation.
That's exactly what the compiler did.
If this the case then why we need move constructor or move assignment operator for our case.
Your class needs a custom move constructor and assignment operator, since the implicitly generated ones would not handle the allocated resource correctly.
Just because the compiler might optimise, is not a good reason to leave them out. Especially because in some other program, the move can not be optimized away at all.
PS.
if (ptr) in the destructor is redundant. It's fine to delete nullptr. You don't make the check in operator= either, which is fine.
deleteMe is a dangerous function. Deleting self might be useful in some very obscure cases, but your class doesn't show any need for it. The behaviour of calling this function on a non-dynamic instance would be undefined.
Initialising ptr to null in the move and copy constructor is redundant, since you overwrite the value unconditionally in the body of the constructor.