Move Constructors in C++

// C++ Program to illustrate how to use the move constructor
#include <iostream>

using namespace std;

class Simple {
private:
    int* data;

public:
    // Constructor
    Simple(int value) : data(new int(value))
    {
        cout << "Constructor called, data = " << *data
             << endl;
    }

    // Destructor
    ~Simple()
    {
        delete data;
        cout << "Destructor called" << endl;
    }

    // Move constructor
    Simple(Simple&& other)
        : data(other.data)
    {
        // nullify the other object resource
        other.data = nullptr;
        cout << "Move constructor called" << endl;
    }

    // Move assignment operator
    Simple& operator=(Simple&& other)
    {
        if (this != &other) {
            delete data; // Free existing resource
            data = other.data; // Transfer ownership
            other.data = nullptr; // Nullify source
            cout << "Move assignment called" << endl;
        }
        return *this;
    }

    // Disable copy constructor and copy assignment operator
    Simple(const Simple&) = delete;
    Simple& operator=(const Simple&) = delete;

    // Function to print the value
    void print()
    {
        if (data) {
            cout << "Data: " << *data << endl;
        }
        else {
            cout << "Data is null" << endl;
        }
    }
};

int main()
{
    // Create a Simple object with value 42
    Simple obj1(42);
    obj1.print();

    // Move obj1 to obj2 using move constructor
    Simple obj2 = move(obj1);
    // Print obj2's data
    obj2.print();
    // Print obj1's data after move
    obj1.print();

    // Create another Simple object with value 84
    Simple obj3(84);
    // Move obj2 to obj3 using move assignment
    obj3 = move(obj2);
    obj3.print();
    obj2.print();

    return 0;
}

// C++ program without declaring the
// move constructor
#include <iostream>
#include <vector>
using namespace std;

// Move Class
class Move {
private:
    // Declaring the raw pointer as
    // the data member of the class
    int* data;

public:
    // Constructor
    Move(int d)
    {
        // Declare object in the heap
        data = new int;
        *data = d;

        cout << "Constructor is called for " << d << endl;
    };

    // Copy Constructor to delegated
    // Copy constructor
    Move(const Move& source)
        : Move{ *source.data }
    {

        // Copying constructor copying
        // the data by making deep copy
        cout << "Copy Constructor is called - "
             << "Deep copy for " << *source.data << endl;
    }

    // Destructor
    ~Move()
    {
        if (data != nullptr)

            // If the pointer is not
            // pointing to nullptr
            cout << "Destructor is called for " << *data
                 << endl;
        else

            // If the pointer is
            // pointing to nullptr
            cout << "Destructor is called"
                 << " for nullptr" << endl;

        // Free the memory assigned to
        // data member of the object
        delete data;
    }
};

// Driver Code
int main()
{
    // Create vector of Move Class
    vector<Move> vec;

    // Inserting object of Move class
    vec.push_back(Move{ 10 });
    vec.push_back(Move{ 20 });
    return 0;
}

// C++ program for demonstrating the use of
// move constructor
#include <iostream>
#include <vector>
using namespace std;

// Move Class
class Move {
private:
    // Declare the raw pointer as
    // the data member of class
    int* data;

public:
    // Constructor
    Move(int d)
    {
        // Declare object in the heap
        data = new int;
        *data = d;
        cout << "Constructor is called for " << d << endl;
    };

    // Copy Constructor
    Move(const Move& source)
        : Move{ *source.data }
    {

        // Copying the data by making
        // deep copy
        cout << "Copy Constructor is called -"
             << "Deep copy for " << *source.data << endl;
    }

    // Move Constructor
    Move(Move&& source)
        : data{ source.data }
    {

        cout << "Move Constructor for " << *source.data
             << endl;
        source.data = nullptr;
    }

    // Destructor
    ~Move()
    {
        if (data != nullptr)

            // If pointer is not pointing
            // to nullptr
            cout << "Destructor is called for " << *data
                 << endl;
        else

            // If pointer is pointing
            // to nullptr
            cout << "Destructor is called"
                 << " for nullptr " << endl;

        // Free up the memory assigned to
        // The data member of the object
        delete data;
    }
};

// Driver Code
int main()
{
    // Vector of Move Class
    vector<Move> vec;

    // Inserting Object of Move Class
    vec.push_back(Move{ 10 });
    vec.push_back(Move{ 20 });
    return 0;
}

// C++ program to illustrate what happens when we
// don't use the noexcept move constructor
#include <bits/stdc++.h>
using namespace std;

class A {
public:
    A() {}
  
    // Move constructor not marked as noexcept
    A(A&& other) {
        cout << "Move constructor" << endl;
    }

    // Copy constructor
    A(const A& other) {
        cout << "Copy constructor" << endl;
    }
};

int main() {
    vector<A> v;

  	// Reserve space for at least two elements to
	// avoid immediate resizing
    v.reserve(2);

    // Uses the move constructor for the temporary objects
    v.push_back(A());
    v.push_back(A());

  	cout << "Resize happens" << endl;
    
    // Move constructor may be called again if resizing occurs
    v.push_back(A());
    
    return 0;
}

// C++ Program to illustrate the use of
// noexcept move constructor
#include <vector>
#include <iostream>
using namespace std;

class Test {
public:
    Test(){}
      
    // Move constructor marked as noexcept
    Test(Test&& other) noexcept {
        cout << "Move constructor  " << endl;
    }

    // Copy constructor
    Test(const Test& other) {
        cout << "Copy constructor  " << endl;
    }
};

int main() {
    vector<Test> vec;

    vec.reserve(2);  // Reserve space for at least two elements

  Test a;

    vec.push_back(Test());
    vec.push_back(Test());  // Uses the move constructor

    cout << "Resize happens" << endl;
    vec.push_back(Test());
    
    return 0;
}