Only default constructor was called instead of default construtor then move constructor

My program is as follow:

class X {
public:
    X(int x):m_x(new int{x}) {
        cout << this << '\t';
        cout << "Constuctor X(int x)"<<endl;

    } 
    X() {
        cout << this << '\t';
        cout << "Constuctor X()"<<endl;
    }
    X(const X& x) {
        cout << this << '\t';
        cout << "Constuctor X(const X&)"<<endl;
        cout << "addr of const X& x = " << &x <<endl;
        
    }
    X(X&& x)
    {
        cout << this << '\t';
        cout << "Constuctor X(X&&)"<<endl;
        cout << "addr of X&& x = " << &x <<endl;
        this->m_x = x.m_x;
        x.m_x = nullptr;
    }
    X& operator=(const X& x) {
        cout << this << '\t';
        cout << "= copy operator"<<endl;
        m_x = x.m_x;
    }
    X& operator=(X&& x){
        cout << this << '\t';
        cout << "= move operator"<<endl;
    }
    X& operator++(){
        cout << this << '\t';
        *m_x++;
        cout << "++ operator"<<endl;
        return *this;
    }
    ~X() {
        cout << this << '\t';
        cout << "Destructor"<<endl;
        if(m_x)
            delete m_x;
        else
            cout << "m_x null\t";

    }
    int* m_x = nullptr;
};


int main() {
    X x(X{});
}

And the output:

0x7ffcc5a0b150  Constuctor X()
0x7ffcc5a0b150  Destructor
m_x null 

I think first, default constructor is called to construct X{}, then an rvalue is returned to construct x which calls move constructor. But actualy only default constuctor was called.

Can someone help me to understand this?

It happens because of what is called Copy elision.

What is happening here is :

1. First of all, the call of X{} for the temporary object uses the default constructor as shown in the output

2. Now, because of Copy Elision, the optimizer can see that the temp object is not used anywhere else that in the constructor by copy. So, it optimizes the code, bypasses the constructor by copy and constructs the main X object in place, using the default copy of objects, instead of having to create a copy of the temp object in the memory.

3. Then, it deletes the temp object as shown in the output.

You can force the compiler to use your constructor by copy like this :

X temp{}; 
X x(temp);

Note that most of the time, this optimization results in better performances, because it avoids unnecessary copies.