C++ 11 feature rvalue reference and move constructor

In this chapter we shall learn about:

1. what are lvalue and rvalue.
2. What are reference variables?
3. what are rvalue reference.
4. Example for rvalue reference.
5. Move constructor

What are lvalue and rvalue?

The value on the left side of assignment operator is lvalue.

The value on the right side of assignment operator is rvalue. “rvalue” is a constant value that doesn’t have any memory location.

It will be stored in tempruary memory and won’t exist on the next line of code.

Example:

int a;

a = 10;

In the statement “a = 10;”
a is lvalue
10 is rvalue

After the line “a = 10”, the rvalue i.e “10” will not be having any memory.

Sometimes a lvalue can also be rvalue. But a rvalue cannot be lvalue.

Example:

int a = 10;

int b;

b = a;

The statement “b = a”; Here ‘a’ is acting as rvalue eventhough it is an lvalue.

But the statement “20 = a” is wrong. Because ’20’ is rvalue and it cannot become lvalue.

What are reference variables?

A reference variable is used as an alias to already existing variable.

Example:

int i = 10;

int &j = i;

Now both i and j will have the value 10 and point to the same memory location.

Now, can you do something like below?

int &j = 10;

No, we cannot do. OYu cannot create a reference to a constant.

But you can do

const int &j = 10;

Now what is rvalue reference?

Any rvalue reference is represented as ‘&&’ double ampersand.

Then below line is valid in C++11

int &&j = 10;

You can also increment ‘j’ value by “j++”;

Example to show rvalue reference:

#include<iostream>
//for more C++ tutorial visit www.ProDeveloperTutorial.com
using namespace std;

void fun(int &num)
{
    cout<<"Normal function"<<endl;
    
}

void fun(int &&num)
{
    cout<<"rvalue reference function"<<endl;
    
}

int main() 
{ 
    int i = 10;
    fun(i);
    
    fun(20);
    
    return 0; 
} 

Output:

Normal function
rvalue reference function

So this is how the compiler will call the rvalue reference function.

All this is good untill now.

But what is the use of rvalue reference? Why has C++ 11 has this feature?

Consider the example below:

In the below example we have taken a int pointer. Then in the constructor we are creating a new instance of ptr and in the destructor we are deleting it.

Then we have a copy constructor. We do a deep copy. Here we do a ownership transfer.

#include<iostream>
#include<vector>
//for more C++ tutorial visit www.ProDeveloperTutorial.com
using namespace std;

class A
{
  
  public:
  
  int *ptr;
  
  //default constructor
  A()
  {
      cout<<"In default constructor"<<endl;
      ptr = new int;
  }
  
  //copy constructor
  A(const A& a1)
  {
      cout<<"In copy constructor"<<endl;
      this->ptr = new int;
      *this->ptr = *a1.ptr;
  }
    
  //destructor
  ~A()
  {
      cout<<"In destructor"<<endl;
      delete ptr;
  }
  
  
};

void fun(int &&num)
{
    cout<<"rvalue reference function"<<endl;
    
}

int main() 
{ 
    //create a vector variable
    vector<A> v1;
    
    v1.push_back(A());
    
    
    return 0; 
} 

Output:

In default constructor
In copy constructor
In destructor
In destructor