Move Semantics in C++

---

---

Move semantics are used in C++ to transfer the ownership of resources from one object to another instead of copying them. It improves the performance as it avoid unnecessary copying of objects, reducing memory usage, improves efficiency, and efficiently handles the temporary objects like rvalue.

Why Move Semantics are Needed?

Before C++11, we used to copy the resource and it was less efficient and created duplicates. In C++11, move semantics were introduced to solve this problem of memory overhead and reducing the duplicates. Here are reasons why we need move semantics −

• Move semantics avoid copying of resources. It helps in avoiding duplicates and cause less memory overhead.
• It handles temporary objects like rvalues.
• It improves the performance by moving the resources instead of copying.

Expression Types in C++

An expression in C++ means any valid combination of variable, operator, constant, and function call that can give result. There are two types of expression which are as follows −

lvalue Expression

An lvalue is a type of expression in which object has a memory address and can be modified if it is not const. Example of lvalue can be a variable, array elements, and many more.

An lvalue reference is used to create a reference to an lvalue. It is denoted by (&) and is used for implementing copy semantics.

rvalue Expression

An rvalue is a type of expression that does not have a memory address and it represents a value that generally appears on the right side. It is a temporary expression that is about to get destroyed. Example of rvalue can be a constant, temporary object, and many more.

An rvalue reference is used to reference rvalues or temporary objects. It is denoted by (&&) and is used for implementing move semantics.

Here is an example of demonstrating lvalue and rvalue in C++. The x is an lvalue expression and x+5 is an rvalue expression.

#include <iostream>
using namespace std;

int main() {
    // x is an lvalue
    int x = 10;  
    // 'x + 5' is an rvalue         
    int y = x + 5;       

    cout << "Old x: " << x << endl;
    cout << "Old y: " << y << endl;

    // Demonstrating assignments
    x = 20;              // correct, as x is an lvalue
    // (x + 5) = 15;     // wrong, as x + 5 is an rvalue

    cout << "New x: " << x << endl;

    return 0;
}

The output of the above code is as follows −

Old x: 10
Old y: 15
New x: 20

The following example demonstrates lvalue reference(int &x) and rvalue reference(int &&x) −

#include <iostream>
using namespace std;

void printValue(int &x){
   cout << "Calling with Lvalue reference: " << x << endl; // lvalue reference
}

void printValue(int &&x){
   cout << "Calling with Rvalue reference: " << x << endl; // rvalue reference
}

int main(){
   int a = 10;

   printValue(a);  // a is an lvalue
   printValue(20); // 20 is an rvalue

   return 0;
}

The output of the above code is as follows −

Calling with Lvalue reference: 10
Calling with Rvalue reference: 20

Why do Move Semantics Apply to Rvalues Only?

The move semantics is applied only to rvalues because, the rvalues are temporary objects, that are about to get destroyed. The rvalue will not affect the program in future as they are temporary and can be changed. So, applying move semantics on rvalue to transfer the ownership won't affect the program.

Here are the techniques that can be used to implement move semantics −

Move Constructor

A move constructor is a special constructor used to transfer the ownership of resources from a temporary object or rvalue to a new object using rvalue reference. The move constructor is automatically called when initializing an object with an rvalue.

#include <iostream>
#include <cstring>
using namespace std;

class MyString {
   private:
      char *data;
      size_t length;

   public:
   
   // Regular constructor
   MyString(const char *str){
   
      length = strlen(str);
      data = new char[length + 1];
      strcpy(data, str);
      cout << "Constructor called\n";
   }

   // Move constructor 
   MyString(MyString &&other) noexcept {
   
      data = other.data; // transferring ownership
      length = other.length;
      other.data = nullptr; 
      other.length = 0;
      cout << "Move constructor called\n";
   }

   // Destructor
   ~MyString(){
      delete[] data;
      cout << "Destructor called\n";
   }

   void print() const {
      if (data)
         cout << data << endl;
   }
};

// Function returning a temporary object(rvalue)
MyString createString(){
   return MyString("Temporary");
}

int main(){

   // Calling move constructor 
   MyString s1 = createString(); 
   s1.print();

   return 0;
}

The output of the above code is as follows −

Constructor called
Temporary
Destructor called

In the above code, the desired output is not being displayed because of modern compiler apply RVO(Return Value Optimization).

Move Assignment Operator

The move assignment operator uses '(=)' and rvalue reference for move semantic. First, it releases the current resource of object and then take ownership of the source object's resources. Below is an example of move assignment operator −

#include <iostream>
#include <cstring>
using namespace std;

class MyString {
   private:
      char* data;
      size_t length;

   public:
      // Regular constructor
      MyString(const char* str) {
         length = strlen(str);
         data = new char[length + 1];
         strcpy(data, str);
         cout << "Constructor called\n";
      }

      // Move constructor
      MyString(MyString&& other) noexcept {
         data = other.data;
         length = other.length;
         other.data = nullptr;
         other.length = 0;
         cout << "Move constructor called\n";
      }

      // Move assignment operator
      MyString& operator=(MyString&& other) noexcept {
         if (this != &other) {
            delete[] data;          
            data = other.data;      // transferring ownership
            length = other.length;
            other.data = nullptr;   
            other.length = 0;
            cout << "Move assignment operator called\n";
         }
         return *this;
      }

      // Destructor
      ~MyString() {
         delete[] data;
         cout << "Destructor called\n";
      }

   void print() const {
      if (data)
        cout << data << endl;
   }
};

int main() {
   MyString s1("Hello");
   MyString s2("World");

   cout << "Before move assignment:\n";
   s1.print();
   s2.print();

   s1 = std::move(s2); // Move assignment operator called

   cout << "After move assignment:\n";
   s1.print();
   s2.print(); // s2 is now empty 

   return 0;
}

The output of the above code is as follows −

Constructor called
Constructor called
Before move assignment:
Hello
World
Move assignment operator called
After move assignment:
World
Destructor called
Destructor called

std::move() Function

Below is an example to transfer the ownership using the std::move() function −

#include <iostream>
#include <string>
#include <utility> // for move
using namespace std;

int main(){
   cout << "Before move() function:";
   string str1 = "Hello";
   cout << "\nstring 1: " << str1 << endl;

   cout << "\nAfter move() function:";
   string str2 = move(str1);
   cout << "\nstr2: " << str2;
   cout << "\nstr1: " << str1 << "\n";

   return 0;
}

The output of the above code is as follows −

Before move() function:
string 1: Hello

After move() function:
str2: Hello
str1: 

Conclusion

In this chapter, we discussed about move semantics. Its main purpose is to transfer the ownership of resources of rvalues to save memory overhead and increase the efficiency of the code.