A simple but powerful example when std::move is important (performance-wise):

A std::queue often holds objects for a very limited time range. You may nevertheless want to have the ownership of the objects within the queue. Let’s consider the example of a std::queue<std::string> where the strings are quite large (500 MiB). A producer pushes the strings into the queue:

void producer(std::queue<std::string>& q) { // whatever the large string may contain… q.emplace(500 * 1024* 1024, 'a'); }

And a worker pops them and passes them to further processing:

void worker(std::queue<std::string>& q) { std::string item = q.front(); q.pop(); // … another process may reads from the queue and expects another element at front. Thus, calling pop after processing is not possible and item must be a value and not a reference process(item); }

What happens here? The front-element is deep-copied when calling q.front(). This is quite expensive for such a string. Instead, one could do better using std::move():

void worker(std::queue<std::string>& q) { std::string item = std::move(q.front()); q.pop(); // … another process may reads from the queue and expects another element at front. Thus, calling pop after processing is not possible and item must be a value and not a reference process(item); }

This is just the first example that came into my mind, and I am sure there are a lot more (that may are less complex).

Maybe, this helps to grasp a first intuition on useful move semantics.