What is the difference between std::move and std:: forward in C++?

Both std::move and std::forward were introduced in C++11 to support move semantics and perfect forwarding, but they serve distinct purposes and usage scenarios.

std::move

std::move is used to convert an lvalue to an rvalue reference, enabling the object's resources to be moved rather than copied. This is primarily used to optimize performance, especially when dealing with large data structures such as large arrays or containers.

Example

Suppose we have a large std::vector that we need to pass to another vector.

cpp
#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec1 = {1, 2, 3, 4, 5};
    std::vector<int> vec2 = std::move(vec1);  // Using std::move to move vec1's data to vec2

    std::cout << "vec1 size: " << vec1.size() << std::endl;  // vec1 is now empty
    std::cout << "vec2 size: " << vec2.size() << std::endl;  // vec2 holds the original data from vec1
}

In this example, std::move allows the data of vec1 to be moved directly to vec2, avoiding data copying. After the move operation, vec1 becomes empty.

std::forward

std::forward is used for perfect forwarding, which involves forwarding parameters to another function while preserving their original lvalue or rvalue nature. This is essential for implementing function templates, ensuring parameters are correctly forwarded based on their initial type (lvalue or rvalue).

Example

Suppose we have a function template that forwards parameters to another function.

cpp
#include <iostream>
#include <utility>

void process(int& x) {
    std::cout << "Processing lvalue: " << x << std::endl;
}

void process(int&& x) {
    std::cout << "Processing rvalue: " << x << std::endl;
}

template <typename T>
void relay(T&& arg) {
    process(std::forward<T>(arg));  // Perfectly forwarding arg to process
}

int main() {
    int a = 5;
    relay(a);  // a is forwarded as an lvalue
    relay(10); // 10 is forwarded as an rvalue
}

In this example, std::forward ensures that regardless of whether the argument passed to relay is an lvalue or rvalue, it is forwarded to the process function in its original type. This allows the process function to perform optimal operations based on the parameter type.

Summary

• std::move is used to explicitly convert an lvalue to an rvalue reference for move operations.
• std::forward is used to forward parameters while preserving their original lvalue or rvalue nature in generic programming.

Both are essential tools in modern C++ for handling object semantics, improving code efficiency and flexibility.