Using std::move with std::unique_ptr

std::move, defined in the <utility> header, is used to indicate that an object t may be "moved from", i.e., allowing the efficient transfer of resources from t to another object.

In the context of std::unique_ptr, std::move is used to transfer ownership of the managed resource from one unique_ptr to another.

Consider this example:

1#include <memory>
2#include <utility>
3#include <iostream>
4
5int main() {
6  std::unique_ptr<int> p1{
7    std::make_unique<int>(42)};
8
9  std::cout << *p1 << '\n';
10
11  std::unique_ptr<int> p2{std::move(p1)};
12
13  std::cout << *p2 << '\n'
14    << (p1 ? "p1 is not null" : "p1 is null");
15}

142
242
3p1 is null

Here, p1 initially manages an int with the value 42. We then use std::move to transfer ownership of this int to p2. After the move, p2 manages the int, and p1 is set to nullptr.

This move operation is efficient because it just transfers the pointer from p1 to p2. No deep copy of the managed int is made.

std::move is often used when passing a unique_ptr to a function that takes ownership of the managed resource:

1#include <memory>
2#include <utility>
3#include <iostream>
4
5void TakeOwnership(std::unique_ptr<int> p) {
6  if (p) {
7    std::cout << "Taking ownership of " << *p;
8  }
9}
10
11int main() {
12  std::unique_ptr<int> p{
13    std::make_unique<int>(42)};
14  TakeOwnership(std::move(p));
15}

1Taking ownership of 42

Here, std::move is used to transfer ownership of the int managed by p to the p parameter of TakeOwnership.

It's important to note that after a unique_ptr has been moved from, it no longer manages a resource. Attempting to use a unique_ptr after it has been moved from leads to undefined behavior:

1#include <iostream>
2#include <memory>
3#include <utility>
4
5int main() {
6  std::unique_ptr<int> p1{
7    std::make_unique<int>(42)};
8  std::unique_ptr<int> p2{
9    std::move(p1)};
10
11  std::cout << *p1;  // undefined behavior!
12}

Therefore, it's crucial to be aware of when a unique_ptr has been moved from and to not use it afterwards.

In summary, std::move with std::unique_ptr is used to efficiently transfer ownership of a managed resource from one unique_ptr to another, leaving the original unique_ptr in a state where it no longer manages a resource.