C++ 11移动语义

什么是移动语义？

在C++11之前，当我们需要转移资源（如动态分配的内存）时，通常只能通过复制然后销毁原对象来实现，这种方式效率低下。C++11引入了移动语义，允许我们在某些情况下转移而不是复制资源，大幅提高程序性能。

移动语义的核心思想是：当一个对象是临时对象（右值）时，我们可以"偷取"它的资源，而不是复制这些资源。这种操作在处理大型对象（如容器）时尤为重要。

理解要点

移动语义可以看作是对资源的"转让"而非"复制"，就像将一本书直接交给别人，而不是复印一份再给别人。

右值引用

移动语义的基础是右值引用，使用双引号&&表示：

cpp
std::string&& rvalueRef = std::string("Hello");

右值引用可以绑定到临时对象（右值），这与传统的左值引用不同：

cpp
std::string s = "Hello";
// std::string& ref = std::string("World");  // 错误：不能将左值引用绑定到右值
std::string&& ref = std::string("World");    // 正确：右值引用绑定到右值

移动构造函数与移动赋值运算符

要实现移动语义，类需要定义：

移动构造函数
移动赋值运算符

下面是一个简单示例：

cpp
#include <iostream>
#include <utility>  // 为std::move引入

class MyString {
private:
    char* data;
    size_t length;

public:
    // 构造函数
    MyString(const char* str) {
        length = strlen(str);
        data = new char[length + 1];
        strcpy(data, str);
        std::cout << "构造: " << data << std::endl;
    }

    // 拷贝构造函数
    MyString(const MyString& other) {
        length = other.length;
        data = new char[length + 1];
        strcpy(data, other.data);
        std::cout << "拷贝构造: " << data << std::endl;
    }

    // 移动构造函数
    MyString(MyString&& other) noexcept {
        // 窃取资源
        data = other.data;
        length = other.length;
        
        // 将源对象置于有效但可销毁的状态
        other.data = nullptr;
        other.length = 0;
        
        std::cout << "移动构造: " << data << std::endl;
    }

    // 析构函数
    ~MyString() {
        delete[] data;
    }

    // 显示字符串
    void print() const {
        if (data)
            std::cout << data << std::endl;
        else
            std::cout << "空字符串" << std::endl;
    }
};

int main() {
    // 使用移动构造函数
    MyString s1 = "Hello";
    MyString s2 = std::move(s1);  // 调用移动构造函数
    
    std::cout << "s1: ";
    s1.print();  // s1现在应该是空的
    
    std::cout << "s2: ";
    s2.print();  // s2现在拥有原来s1的数据
    
    return 0;
}

输出:

构造: Hello
移动构造: Hello
s1: 空字符串
s2: Hello

std::move 的作用

std::move 是一个用于将左值转换为右值引用的工具函数。它本身不会移动任何东西，只是告诉编译器将对象视为可移动的。

cpp
std::string str = "Hello";
std::string str2 = std::move(str);  // str的内容被移动到str2
// 此时str可能为空（取决于实现）

警告

使用 std::move 后，除非重新赋值，否则不应再使用原对象的值，因为其资源可能已被转移。

移动语义的实际应用

1. 容器性能优化

考虑下面的代码，展示了移动语义如何优化std::vector的性能：

cpp
#include <iostream>
#include <vector>
#include <string>
#include <chrono>

const int ITERATIONS = 100000;

int main() {
    // 测试复制
    auto start = std::chrono::high_resolution_clock::now();
    std::vector<std::string> vecCopy;
    
    for (int i = 0; i < ITERATIONS; ++i) {
        std::string str = "测试字符串很长很长很长很长很长很长很长很长";
        vecCopy.push_back(str);  // 复制str到vector
    }
    
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> diffCopy = end - start;
    
    // 测试移动
    start = std::chrono::high_resolution_clock::now();
    std::vector<std::string> vecMove;
    
    for (int i = 0; i < ITERATIONS; ++i) {
        std::string str = "测试字符串很长很长很长很长很长很长很长很长";
        vecMove.push_back(std::move(str));  // 移动str到vector
    }
    
    end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> diffMove = end - start;
    
    std::cout << "复制用时: " << diffCopy.count() << "s\n";
    std::cout << "移动用时: " << diffMove.count() << "s\n";
    std::cout << "性能提升: " << diffCopy.count() / diffMove.count() << "倍\n";
    
    return 0;
}

在这个例子中，使用移动语义可能会比复制快几倍，尤其是处理大型字符串时。

2. 返回大型对象

移动语义使得函数返回大型对象变得更加高效：

cpp
std::vector<int> createLargeVector() {
    std::vector<int> result(10000, 42);
    // 返回时，移动构造函数会被调用，避免不必要的复制
    return result;  
}

int main() {
    // 高效地获取大型vector，没有额外复制
    std::vector<int> myVec = createLargeVector();
    std::cout << "Vector大小: " << myVec.size() << std::endl;
    return 0;
}

3. 独占资源的安全转移

移动语义对于智能指针等独占资源尤为重要：

cpp
#include <iostream>
#include <memory>

class Resource {
public:
    Resource() { std::cout << "Resource 创建\n"; }
    ~Resource() { std::cout << "Resource 销毁\n"; }
    void use() { std::cout << "Resource 使用中\n"; }
};

int main() {
    // 创建独占资源
    std::unique_ptr<Resource> res1(new Resource());
    
    // 无法复制unique_ptr，但可以移动
    // std::unique_ptr<Resource> res2 = res1;  // 编译错误
    std::unique_ptr<Resource> res2 = std::move(res1);  // 成功
    
    // res1现在为nullptr
    if (res1) {
        std::cout << "res1 仍然持有资源\n";
    } else {
        std::cout << "res1 不再持有资源\n";
    }
    
    // res2现在持有资源
    res2->use();
    
    return 0;
}

输出:

Resource 创建
res1 不再持有资源
Resource 使用中
Resource 销毁

移动语义的最佳实践

实现移动操作时使用 noexcept：这有助于标准库容器提供更强的异常安全保证。
移动后保持对象的有效状态：被移动的对象应该保持可析构的状态，通常会将其设置为一个表示"空"的状态。
使用 std::move 的适当时机：
- 当对象不再需要使用时
- 当函数参数是右值引用时
- 当从函数返回局部对象时
遵循规则：如果你实现了移动构造函数或移动赋值运算符，通常也应实现拷贝构造函数和拷贝赋值运算符（或禁用它们）。

何时不使用移动语义

当对象是 const 时，不能使用移动语义
当对象后续还需要使用时，不应使用 std::move
对于小型对象（如内置类型），移动的成本可能与复制相同

cpp
int x = 42;
int y = std::move(x);  // 不会带来性能提升，因为int是小型对象
std::cout << x << std::endl;  // x仍然是42，因为基本类型的移动实际上是复制

移动语义与完美转发

与移动语义密切相关的是完美转发，它使用右值引用和模板参数推导来转发函数参数，保持它们的值类别（左值还是右值）：

cpp
template<typename T>
void wrapper(T&& arg) {
    // std::forward保持参数的值类别
    someFunction(std::forward<T>(arg));
}

int main() {
    int x = 10;
    wrapper(x);       // x作为左值传递
    wrapper(10);      // 10作为右值传递
    return 0;
}

总结

移动语义是C++11中引入的一项关键特性，它允许我们：

通过转移而非复制资源来提高性能
使用右值引用（&&）接收临时对象
通过移动构造函数和移动赋值运算符实现高效的资源转移
使用 std::move 将左值转换为右值引用
特别适用于处理大型对象、容器和不可复制的独占资源

掌握移动语义对于编写高性能的C++程序至关重要，尤其是在处理资源密集型操作时。

练习

为一个简单的动态数组类实现移动构造函数和移动赋值运算符。
比较使用复制和移动语义向std::vector添加1000个对象的性能差异。
创建一个资源管理类，它只能移动而不能复制。
实现一个函数模板，完美转发其参数到另一个函数。
研究标准库容器（如std::vector和std::string）如何利用移动语义优化性能。

学习提示

要深入理解移动语义，请尝试查看标准库类的实现，特别是容器类和std::unique_ptr，它们是移动语义应用的绝佳示例。

什么是移动语义？​

右值引用​

移动构造函数与移动赋值运算符​

std::move 的作用​

移动语义的实际应用​

1. 容器性能优化​

2. 返回大型对象​

3. 独占资源的安全转移​

移动语义的最佳实践​

何时不使用移动语义​

移动语义与完美转发​

总结​

练习​