std::move(3)

💅 std::move — the C++ Standard Library glow-up you've been waiting for (a.k.a. std::move(3))

okay so bestie, listen. this is std::move, and it lives in the C++ Standard Library — it's literally the main character of move semantics and you're about to be obsessed. 🎀

---

💖 NAME 💖

std::move — yes, the function is named std::move. iconic, no notes. ✨

---

🌸 SYNOPSIS 🌸

first things first: it's defined in header <utility> — go include it, bestie, it's not gonna include itself. 🫶

until C++14:

template< class T >
typename std::remove_reference<T>::type&& move( T&& t ) noexcept;

since C++14: (she got a constexpr glow-up 💅 — and the return type got the _t treatment)

template< class T >
constexpr std::remove_reference_t<T>&& move( T&& t ) noexcept;

(also, std::move has been hanging around since C++11, just so we're clear on the lore ✨)

So what does she do? std::move 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. no cap. 🔥

In particular, std::move produces an xvalue expression that identifies its argument t. It is exactly equivalent to a static_cast to an rvalue reference type. that's it. that's the whole function. she's literally one cast in a trench coat and she ate. 💀

---

🌈 PARAMETERS 🌈

• t — the object to be moved 🦋

---

👑 RETURN VALUE 👑

static_cast<typename std::remove_reference<T>::type&&>(t)

---

🧚 NOTES 🧚

okay this is the part where it gets good, so pay attention bestie. 📖

The functions that accept rvalue reference parameters — including move constructors, move assignment operators, and regular member functions such as std::vector::push_back — are selected, by overload resolution, when called with rvalue arguments (either prvalues such as a temporary object, or xvalues such as the one produced by std::move). If the argument identifies a resource-owning object, these overloads have the option, but aren't required, to move any resources held by the argument. like, they can, not they must, iykyk.

For example, a move constructor of a linked list might copy the pointer to the head of the list and store nullptr in the argument instead of allocating and copying individual nodes. efficiency slay. ✨

Names of rvalue reference variables are lvalues and have to be converted to xvalues to be bound to the function overloads that accept rvalue reference parameters — which is why move constructors and move assignment operators typically use std::move. it's giving "you have to announce it out loud or nobody knows it's an rvalue." 💅

// Simple move constructor
A(A&& arg) : member(std::move(arg.member)) // the expression "arg.member" is lvalue
{}

// Simple move assignment operator
A& operator=(A&& other)
{
    member = std::move(other.member);
    return *this;
}

One exception is when the type of the function parameter is a forwarding reference (which looks like an rvalue reference to type template parameter), in which case std::forward is used instead. different tool, different vibe. 🦋

⚠️ Unless otherwise specified, all standard library objects that have been moved from are placed in a "valid but unspecified state" — meaning the object's class invariants hold (so functions without preconditions, such as the assignment operator, can be safely used on the object after it was moved from). valid but unspecified is basically "she's alive but don't ask her questions." 😭

std::vector<std::string> v;
std::string str = "example";
v.push_back(std::move(str)); // str is now valid but unspecified
str.back(); // undefined behavior if size() == 0: back() has a precondition !empty()
if (!str.empty())
    str.back(); // OK, empty() has no precondition and back() precondition is met

str.clear(); // OK, clear() has no preconditions

Also, the standard library functions called with xvalue arguments may assume the argument is the only reference to the object; if it was constructed from an lvalue with std::move, no aliasing checks are made. 🙈 However, self-move-assignment of standard library types is guaranteed to place the object in a valid (but usually unspecified) state — so it's not UB, it's just... vibes. 💀

std::vector<int> v = {2, 3, 3};
v = std::move(v); // the value of v is unspecified

---

🔥 EXAMPLE 🔥

// Run this code

#include <iomanip>
#include <iostream>
#include <string>
#include <utility>
#include <vector>

int main()
{
    std::string str = "Salut";
    std::vector<std::string> v;

    // uses the push_back(const T&) overload, which means
    // we'll incur the cost of copying str
    v.push_back(str);
    std::cout << "After copy, str is " << std::quoted(str) << '\n';

    // uses the rvalue reference push_back(T&&) overload,
    // which means no strings will be copied; instead, the contents
    // of str will be moved into the vector. This is less
    // expensive, but also means str might now be empty.
    v.push_back(std::move(str));
    std::cout << "After move, str is " << std::quoted(str) << '\n';

    std::cout << "The contents of the vector are {" << std::quoted(v[0])
                  << ", " << std::quoted(v[1]) << "}\n";
}

⭐ Possible output ⭐

After copy, str is "Salut"
After move, str is ""
The contents of the vector are {"Salut", "Salut"}

see how str got emptied after the move?? that's the whole point, bestie. she gave her contents to the vector and now she's just a shell. valid but unspecified. 🫶

---

🎀 SEE ALSO 🎀

• forward (C++11) — forwards a function argument (function template) ✨
• move_if_noexcept (C++11) — obtains an rvalue reference if the move constructor does not throw (function template) 💜
• move (C++11) — moves a range of elements to a new location (function template) 🌈

---

okay that's the whole page, you're welcome, go move some objects responsibly. and remember: this tea was served fresh from http://cppreference.com, dated 2024.06.10 — periodt. 💅✨💖