Move Constructors in C++

ClassName(ClassName&& other);

#include <iostream>
using namespace std;

class Geeks {
private:
    int* ptr;

public:
    // Constructor
    Geeks(int value) {
        // Dynamically allocate memory
        ptr = new int(value); 
        cout << "Constructor called\n";
    }

    // Move Constructor
    Geeks(Geeks&& obj) {
        cout << "Move Constructor called\n";
        // Steal the pointer
        ptr = obj.ptr;        
        obj.ptr = nullptr;    
    }

    // Destructor
    ~Geeks() {
        if (ptr != nullptr) {
            cout << "Destructor deleting data: " << *ptr << endl;
        } else {
            cout << "Destructor called on nullptr\n";
        }
        delete ptr;
    }

    // Display function
    void display() {
        if (ptr)
            cout << "Value: " << *ptr << endl;
        else
            cout << "No data\n";
    }
};

int main() {
    // Constructor is called
    Geeks obj1(42);              
    // Move constructor is called
    Geeks obj2 = std::move(obj1); 

    cout << "\nAfter move:\n";
    cout << "obj1: ";
    // Should show "No data"
    obj1.display();              
    cout << "obj2: ";
    // Should show "Value: 42"
    obj2.display();              

    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;
}