# Move semantics

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](https://pvs-studio.com/en/blog/terms/6517/), 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_](https://pvs-studio.com/en/blog/terms/6518/) and [_std::forward_](https://pvs-studio.com/en/blog/terms/6515/)\.

## 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:

```cpp
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:

```cpp
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](https://en.cppreference.com/w/cpp/named_req/TriviallyCopyable) 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\.

```cpp
#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:

```cpp
#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);
}
```