Move semantics и rvalue references в C++

1int x = 42;      // x — lvalue, 42 — rvalue
2int* p = &x;     // p — lvalue, &x — rvalue
3std::string s = "hello"; // s — lvalue
4s + " world"     // rvalue (временная строка)

1void process(int& x) {
2    std::cout << "Lvalue reference: " << x << "\n";
3}
4
5void process(int&& x) {
6    std::cout << "Rvalue reference: " << x << "\n";
7}
8
9int main() {
10    int a = 10;
11    process(a);      // Lvalue reference: 10
12    process(42);     // Rvalue reference: 42
13    process(a + 1);  // Rvalue reference: 11
14}

1class Buffer {
2    int* data;
3    size_t size;
4public:
5    // Constructor
6    Buffer(size_t size) : data(new int[size]), size(size) {}
7    
8    // Copy constructor (deep copy)
9    Buffer(const Buffer& other) : data(new int[other.size]), size(other.size) {
10        std::copy(other.data, other.data + size, data);
11    }
12    
13    // Move constructor (transfer ownership)
14    Buffer(Buffer&& other) noexcept : data(other.data), size(other.size) {
15        other.data = nullptr;
16        other.size = 0;
17    }
18    
19    // Destructor
20    ~Buffer() { delete[] data; }
21    
22    // Copy assignment
23    Buffer& operator=(const Buffer& other) {
24        if (this != &other) {
25            delete[] data;
26            data = new int[other.size];
27            size = other.size;
28            std::copy(other.data, other.data + size, data);
29        }
30        return *this;
31    }
32    
33    // Move assignment
34    Buffer& operator=(Buffer&& other) noexcept {
35        if (this != &other) {
36            delete[] data;
37            data = other.data;
38            size = other.size;
39            other.data = nullptr;
40            other.size = 0;
41        }
42        return *this;
43    }
44};

1std::string s1 = "hello";
2std::string s2 = std::move(s1); // Move constructor
3// s1 теперь в "moved-from" состоянии
4
5std::vector<int> v1 = {1, 2, 3};
6std::vector<int> v2 = std::move(v1); // Move assignment
7// v1 теперь пуст

1template <typename T>
2void wrapper(T&& arg) {
3    // arg — forwarding reference (не rvalue reference!)
4    process(std::forward<T>(arg));
5}
6
7// std::forward возвращает:
8// - lvalue reference, если T — lvalue reference
9// - rvalue reference, если T — не reference

1template <typename T, typename... Args>
2std::unique_ptr<T> make_unique_custom(Args&&... args) {
3    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
4}
5
6auto ptr = make_unique_custom<MyClass>(1, "hello", 3.14);

1class NonCopyable {
2    std::unique_ptr<int> data;
3public:
4    NonCopyable(int value) : data(std::make_unique<int>(value)) {}
5    
6    // Только move, без copy
7    NonCopyable(NonCopyable&&) = default;
8    NonCopyable& operator=(NonCopyable&&) = default;
9    
10    NonCopyable(const NonCopyable&) = delete;
11    NonCopyable& operator=(const NonCopyable&) = delete;
12};

1std::vector<std::string> v1 = {"hello", "world"};
2std::vector<std::string> v2 = std::move(v1); // Move assignment
3
4// Элементы перемещены, v1 пуст
5// Вместо deep copy всех строк