rvalue references and move semantics.

-

  Rvalue reference


C++11 introduces a new category of reference types called rvalue references which bind only to rvalues and are declared with two ampersands rather than one.

Int&& rvalueRef = 99;


The primary reason for adding rvalue reference is move semantics. Unlike traditional copying, moving means that a target object pilfers the resources of the source object, leaving the source in an “empty” state. In certain cases where making a copy of an object is both expensive and unnecessary, a move operation can be use instead.

We cannot bind rvalue references to lvalues.


Int j = 99;
Int&& k = j;

We will get an error something like this :

Error: 'initializing' : cannot convert from 'int' to 'int &&'
                 You cannot bind an lvalue to an rvalue reference



An expression is an rvalue if it results in an temporary object as shown below


Int getVal ()
{
            Int a = 10;
            Return a;
}

Int main()
{
            Cout<<getVal();
            Return 0;
}

getVal() is a rvalue. Note that the value returned is not a reference to a, but it’s just temporary value.

In C++98, lvalue reference can bind to temporary object only if it was const.

Const int& value = getVal() ; // Fine
Int& value = getVal(); // Error

Rvalue references are perfect for detecting if a value is temporary object or not.

Const int&& value = getVal() ; // Fine
Int&& value = getVal(); // Fine


Some more examples.

Void displayValue(const int& val)
{
            Cout<<val;
}

Void displayValue(int && val)
{
            Cout<<val;
}

The displayValue() function taking const lvalue reference will accept any argument whether it can be lvalue or rvalue. The second function taking rvalue will accept only temporary/rvalue as argument.

            #include<iostream>

Using namespace std;

Void displayValue(const int& val)
{
            Cout<<”Lvalue - ”<<val;
}

Void displayValue(int && val)
{
            Cout<<”RValue - ”<<val;
}


Int returnVal()
{
            Int aa = 20;
            Return aa;
}

Int main()
{
            Int a = 10;
            displayValue(a);
            displayValue(returnValue());
            return 0;
}

g++ -std=c++11 rvalueReference.cpp

Execute and get the below output.

Lvalue – 10
RValue - 20




 Move Semantics


To move an object means to transfer ownership of some resource it manages to another object.

Now we have a way to determine if a reference variable refers to temporary object or permanent object.
The main usage of rvalue references is to create a move constructor and move assignment operator.

A move constructor, like a copy constructor, takes an instance of an object as its argument and creates a new instance from original object. However, the move constructor can avoid memory reallocation because we know it has been provided a temporary object, so rather than copy the fields of the object, we will move them.

In other words, the rvalue references and move semantics allows us to avoid unnecessary copies when working with temporary objects.

The rvalues are typically temporary, and they can be modified. If we know that our function parameter is an rvalue, we can use it as a temporary storage, or takes it contents without affecting the outpt of our program. This means we can just move the contents rather than copy the contents of an rvalues parameter.

What does it mean to move a field of the object ? 
If the field is a primitive type, like int, we just copy it. It gets more interesting if the field is a pointer : here, rather than allocate and initialize new memory, we can simply steal the pointer and null out the pointer in the temporary object ! We know that temporary object will no longer be needed.

A move constructor looks like this :

MyClass::MyClass(MyClass && obj) ;


It does’nt allocate new resources, instead it pilfers “obj” resources and then sets “obj” to its default constructed state.

Suppose you are designing a MemoryModel class that represents a memory buffer:

Class MemoryModel
{
            Size_t size;
            Char* buf;
            Public:
                        Explicit MemoryModel(int sz = 32):size(sz),buf(new char[sz])
                        {
                        }
                       
                        ~MemoryModel()
                        {
                                    Delete buf[];
                        }
                       
                        // Copy Constructor
                        MemoryModel(const MemoryModel& obj);

                        // Assignment Operator
                        MemoryModel& operator=(const MemoryModel& obj);
                       

}
// Move Constructor definition
MemoryModel(MemoryModel&& obj) : size(0),buf(nullptr)
{
            // Pilfer’s “obj” resource
            Size = obj.size;
            Buf = obj.buf;
           
            // Reset “obj”
            Obj.size = 0;
            Obj.buf = nullptr;
}



// Move Assignment operator :
MemoryModel& MemoryModel::operator=(MemoryModel&& obj);

A move assignment operator is similar to copy constructor except that before pilfering the source object, it releases any resources that its main object may own.
a.     Release any resource that *this currently owns.
b.     Pilfer “obj” resource
c.     Set “obj” to a default state
d.     Return *this

Definition of MemoryModel move Assignment Operator:

MemoryModel& MemoryModel::operator=(MemoryModel&& obj)
{
            If(this != &obj)
            {
                        Delete []buf;
                        Size = 0;
                       
                        // Pilfer obj’s resource
                        Size = obj.size;
                        Buf = obj.buf;

                        //Reset obj
                        Obj.size = 0;
                        Obj.buf = nullptr;

            }
            Return *this;


}

 The copy constructor is doing both allocate memory and copy every value from array one by one, and it may hit the performance of our code.

On the other hand, the move constructor is actually less work than the copy constructor. Note that the following two facts from the move constructor.


  • The parameter is a non-const rvalue reference. - - If we had taken a const-rvalue reference, we were not able to set obj.buf to nullptr.
  • obj.buf is set to nullptr - - The reason we are setting the ptr to nullptr is the destructor. When the temporary object goes out of scope, its destructor will be invoked, and it will free obj.buf. The same obj.buf that we copied, if we dont set obj.buf to nullptr, the move would not be an move. it would just be a copy that introduces a crash later on once we start using freed memory.

Comments

Post a Comment

Popular posts from this blog

C++ Guidelines for Multithreaded System

-
Image
Mutithreading è Parallelism è  Achieve concurrency. Below are some of the guidelines to follow for building C++ Multithreaded system. Ø std::thread function arguments are pass by value by default. Thread function arguments are pass by value by default. So, if you want the change to be persisted in the arguments passed in , then pass them by reference using std::ref(). Ø Protect shared data or resource using critical section.     In a multithreaded environment if there are more than one thread sharing the resource/data then often it results in a undefined behaviour if the resource/shared data is not protected using synchronise mechanism. So, the shared resource/data must be protected with std::mutex . Ø Release lock after critical section. If a thread T1 acquires lock (mutex.lock()) before entering critical section and forgets to unlock(mutex.unlock()) then all the other threads will be blocked indefinitely and the program might hang because thread T1 gets hol
Read more

Signalling System #7(SS7) Protocol.

-
Image
            Signaling System No. 7 ( SS7 ) is a set of telephony signaling protocols which are used to set up most of the world's public switched telephone network telephone calls. The main purpose is to set up and tear down telephone calls. Other uses include number translation, prepaid billing mechanisms, short message service (SMS), and a variety of other mass market services. SS5 and earlier systems used in-band signaling(In telecommunications, In-band signaling is the sending of metadata and control information in the same band, on the same channel, as used for data.). SS6 and SS7 implement out-of-band (out-of-band control signaling, signaling bits are sent in special order in a dedicated signaling frame.) signaling protocols.         The term signaling , when used in telephony, refers to the exchange of control information associated with the establishment of a telephone call on a telecommunications circuit. An example of this control information is the digits dialed by t
Read more

std::shared_ptr

-
Image
std::shared_ptr  for shared ownership An object accessed via std::shared_ptr s has its lifetime managed by those pointers through shared ownership. No specific std::shared_ptr owns the object. Instead all shared_ptr’s pointing to it collaborates to ensure its destruction at the point where it’s no longer needed. When the last shared_ptr pointing to an object stops pointing there, that shared_ptr destroys the object it points to. A shared_ptr can tell whether it’s the last one pointing to a resource by consulting the resource’s reference count, a value associated with the resource that keeps track of how many shared_ptrs point to it. Shared_ptrs constructors increments this count shared_ptr s destructors decrements it and copy assignment operators do both. If sp1 and sp2 are shared_ptr s to different objects, the assignment “ sp1=sp2 ” , modifies sp1 such that it points  to the object pointed to by sp2 . sp1 reference count is decremented, while that for the object point
Read more