To get a trial key
fill out the form below
Team license
Enterprise license
** By clicking this button you agree to our Privacy Policy statement

Request our prices
New License
License Renewal
--Select currency--
USD
EUR
RUB
* By clicking this button you agree to our Privacy Policy statement

Free PVS-Studio license for Microsoft MVP specialists
** By clicking this button you agree to our Privacy Policy statement

To get the licence for your open-source project, please fill out this form
** By clicking this button you agree to our Privacy Policy statement

I am interested to try it on the platforms:
** By clicking this button you agree to our Privacy Policy statement

Message submitted.

Your message has been sent. We will email you at


If you haven't received our response, please do the following:
check your Spam/Junk folder and click the "Not Spam" button for our message.
This way, you won't miss messages from our team in the future.

>
>
>
Move semantics

Move semantics

Sep 17 2021

Move semantics is a set of semantic rules and tools of the C++ language. It was designed to move objects, whose lifetime expires, instead of copying them. The data is transferred from one object to another. In most cases, the data transfer does not move this data physically in memory. It helps to avoid expensive copying.

Move semantics was introduced in the C++11 standard. To implement it, rvalue references, move constructors, and the move assignment operator were added. Also, some functions were added to the standard template library (STL) to support move semantics. For example, std::move and std::forward.

Uses of move semantics

Let's say you need to write a Swap template function that accepts two objects of the same type and swaps them. The function may be implemented as follows:

template <typename T>
void Swap(T &lhs, T &rhs)
{
  T t = lhs;
  lhs = rhs;
  rhs = t;
}

Everything seems great – the function can work with two objects of the same type and swap them. However, such implementation has a significant drawback. Let's take a look at the following code fragment:

std::vector<int> arrA(1'000'000, 0);
std::vector<int> arrB(1'000'000, 1);
Swap(arrA, arrB);

Two objects of the std::vector<int> type are created. Each contains 1'000'000 elements. Then the Swap function swaps them. The std::vector class template contains a non-trivial copy constructor that has the following functions:

  • performs dynamic memory allocation to the desired number of elements;
  • makes a deep copy of the elements from the passed std::vector.

As a result, we have 3'000'000 copies of int type objects. The situation may get even worse if std::vector is instantiated by a non-trivially copied type.

Move semantics helps to get rid of unnecessary copying. To use it, we need to convert an object to an rvalue reverence. Thus, we tell the compiler that it can move the object.

#include <type_traits>

template <typename T>
void Swap(T &lhs, T &rhs) noexcept
{
  using rvalue_ref = typename std::remove_reference<T>::type &&;
  T t = static_cast<rvalue_ref>(lhs);
  lhs = static_cast<rvalue_ref>(rhs);
  rhs = static_cast<rvalue_ref>(t);
}

In case of std::vector, its non-trivial constructor/move operator swaps pointers to dynamic memory, thus eliminating expensive memory allocation and elements copying.

To simplify the process of coding when moving objects, the std::move function was introduced into the standard library. This function casts the object passed to it to an rvalue reference:

#include <utility>

template <typename T>
void Swap(T &lhs, T &rhs) noexcept
{
  T t = std::move(lhs);
  lhs = std::move(rhs);
  rhs = std::move(t);
}

Latest articles:

Poll:

Comments (0)

Next comments
Unicorn with delicious cookie
Our website uses cookies to enhance your browsing experience.
Accept