什么是移动语义？

什么是移动语义？

技术背景

在传统的 C++ 编程中，对象的复制操作往往会带来较高的开销，尤其是对于那些管理着大量外部资源（如动态分配的内存）的对象。例如，当我们从一个函数返回一个大对象，或者在容器中重新分配元素时，会频繁地进行复制操作，这不仅消耗大量的时间，还会占用额外的内存。为了解决这些问题，C++11 引入了移动语义。

实现步骤

1. 理解基本概念

  • lvalue 和 rvalue：lvalue 是可以出现在赋值语句左边的表达式，通常是有名称的变量；rvalue 则是只能出现在赋值语句右边的表达式，通常是临时对象。
  • rvalue 引用：C++11 引入了 rvalue 引用，其语法为 X&&，它只能绑定到 rvalue 上。

2. 实现移动构造函数

移动构造函数的作用是将源对象的资源所有权转移到当前对象，而不是进行深拷贝。以下是一个简单的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <cstring>
#include <algorithm>

class string
{
    char* data;

public:
    string(const char* p)
    {
        size_t size = std::strlen(p) + 1;
        data = new char[size];
        std::memcpy(data, p, size);
    }

    ~string()
    {
        delete[] data;
    }

    string(const string& that)
    {
        size_t size = std::strlen(that.data) + 1;
        data = new char[size];
        std::memcpy(data, that.data, size);
    }

    string(string&& that)   // string&& 是对 string 的 rvalue 引用
    {
        data = that.data;
        that.data = nullptr;
    }
};

在上述代码中，string(string&& that) 就是移动构造函数。它将源对象的 data 指针复制到当前对象，并将源对象的 data 指针置为 nullptr，从而避免了深拷贝。

3. 实现移动赋值运算符

移动赋值运算符的作用是释放当前对象的旧资源，并从参数中获取新资源。以下是示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class string
{
    // ... 之前的代码 ...

    string& operator=(string&& source)
    {
        if (this != &source)
        {
            delete[] data;
            data = source.data;
            source.data = nullptr;
        }
        return *this;
    }
};

也可以使用移动交换惯用法来简化实现：

1
2
3
4
5
6
7
8
9
10
class string
{
    // ... 之前的代码 ...

    string& operator=(string source)
    {
        std::swap(data, source.data);
        return *this;
    }
};

4. 使用 std::move 显式移动

有时我们需要将 lvalue 当作 rvalue 处理，以便调用移动构造函数。这时可以使用 std::move 函数：

1
2
string a("hello");
string b(std::move(a)); // 显式移动

核心代码

以下是一个完整的 unique_ptr 类的简化实现，展示了移动构造函数和移动赋值运算符的使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include <iostream>

template<typename T>
class unique_ptr
{
    T* ptr;

public:
    T* operator->() const
    {
        return ptr;
    }

    T& operator*() const
    {
        return *ptr;
    }

    explicit unique_ptr(T* p = nullptr)
    {
        ptr = p;
    }

    ~unique_ptr()
    {
        delete ptr;
    }

    unique_ptr(unique_ptr&& source)   // 移动构造函数
    {
        ptr = source.ptr;
        source.ptr = nullptr;
    }

    unique_ptr& operator=(unique_ptr&& source)   // 移动赋值运算符
    {
        if (this != &source)
        {
            delete ptr;
            ptr = source.ptr;
            source.ptr = nullptr;
        }
        return *this;
    }
};

class Shape {};
class Triangle : public Shape {};

unique_ptr<Shape> make_triangle()
{
    return unique_ptr<Shape>(new Triangle);
}

int main()
{
    unique_ptr<Shape> c(make_triangle());
    return 0;
}

最佳实践

  • 避免不必要的复制：在函数返回大对象时，使用移动语义可以避免不必要的复制开销。
  • 正确使用 std::move：当需要将 lvalue 转换为 rvalue 时，使用 std::move，但要注意移动后的对象将不再拥有其资源。
  • 实现移动操作：对于管理外部资源的类，实现移动构造函数和移动赋值运算符，以提高性能。

常见问题

1. 移动操作是否总是安全的？

移动操作对于 rvalue 是安全的，因为 rvalue 通常是临时对象，移动后不会再被使用。但对于 lvalue，移动操作可能会导致原对象处于无效状态，因此需要谨慎使用。

2. 为什么不能隐式地从 lvalue 移动？

从 lvalue 移动可能会导致后续对该 lvalue 的使用出现未定义行为，因此 C++ 要求显式地使用 std::move 来进行移动操作。

3. 如何区分 rvalue 引用和转发引用？

X&& 通常是 rvalue 引用，但在模板参数推导中，T&& 是转发引用，它可以绑定到 lvalue 和 rvalue。可以使用 std::is_rvalue_reference 结合 SFINAE 来约束函数模板只接受 rvalue。