解释C++的移动构造函数和移动赋值运算符如何优化内存使用

P粉602998670

发布时间：2025-08-30 09:09:01

515人浏览过

来源于php中文网

原创

C++的移动构造函数和移动赋值运算符通过“资源窃取”机制避免深拷贝，将资源所有权从右值对象转移给新对象，仅需指针赋值而不进行内存分配与数据复制，显著提升性能。

解释c++的移动构造函数和移动赋值运算符如何优化内存使用

C++的移动构造函数和移动赋值运算符通过“资源窃取”而非“深拷贝”的机制，显著优化了内存使用。它们允许在对象生命周期结束或即将被销毁时，将其内部动态分配的资源（如堆内存、文件句柄）高效地转移给另一个新对象，避免了不必要的内存分配、数据复制和随后的资源释放，从而降低了内存带宽消耗，提升了程序性能。

解决方案

在C++11引入移动语义之前，对象的拷贝（无论是通过拷贝构造函数还是拷贝赋值运算符）通常意味着进行“深拷贝”。对于那些管理着动态分配资源（如

std::vector

或

std::string

内部的缓冲区）的类来说，深拷贝会创建一份全新的资源副本。这意味着先分配一块新的内存，然后将所有数据从源对象复制到新内存中。当源对象是临时对象或即将被销毁时，这种深拷贝无疑是巨大的浪费：我们分配了内存，复制了数据，然后立即释放了源对象的内存，最后新对象的内存也可能很快被释放。

移动构造函数（

T(T&& other)

）和移动赋值运算符（

T& operator=(T&& other)

）正是为了解决这种效率问题而生。它们的核心思想是，当源对象是一个右值（即临时对象或通过

std::move

显式转换为右值的对象）时，我们不需要复制它的资源，而是可以直接“偷走”这些资源。

立即学习“C++免费学习笔记（深入）”；

具体来说：

移动构造函数：当一个新对象需要从一个右值源对象构造时，它不会为内部资源重新分配内存并复制数据。相反，它会将源对象内部指向资源的指针（或其他句柄）直接复制过来，然后将源对象内部的指针设为
```
nullptr
```
（或置于一个有效的空状态），从而确保源对象在销毁时不会错误地释放已被移动的资源。这样，新对象获得了资源的完全所有权，而源对象则被“清空”。
移动赋值运算符：当一个现有对象需要从一个右值源对象赋值时，它会首先释放自己当前持有的资源（如果有的话），然后同样地“窃取”源对象的资源，并将源对象的指针置空。这同样避免了不必要的内存分配和数据复制。

通过这种“资源窃取”的方式，移动操作将原本涉及两次内存分配（新对象分配、源对象释放）和一次数据复制的开销，大幅降低为仅仅是几次指针的赋值操作。这对于管理大型数据结构（如

std::vector

在扩容时需要移动大量元素）或在函数间传递大型对象（如

return std::vector(...)

）的场景，内存和性能的提升是立竿见影的。

为什么C++11之前的深拷贝机制会导致内存效率问题？

在C++11之前，C++中的拷贝语义是基于“值语义”的，这意味着当一个对象被拷贝时，通常会创建一个与源对象完全独立的新对象。对于那些不管理动态资源的简单类型（如

int

double

），这不成问题，因为它们的拷贝就是简单的位复制。但对于像

std::string

、

std::vector

或我们自定义的资源管理类，情况就复杂了。

以一个简单的动态数组类

MyVector

为例，它内部可能有一个指向堆内存的指针

data

和一个表示大小的

size

。当我们拷贝一个

MyVector

对象时，其拷贝构造函数通常会：

为新对象分配一块与源对象
```
data
```
所指向内存大小相同的新内存。
将源对象
```
data
```
指向的所有数据逐一复制到新分配的内存中。

这种“深拷贝”在很多情况下是必要的，比如当你需要一个完全独立的数据副本时。但问题在于，C++的语义常常导致在不必要的地方也进行深拷贝。例如：

函数按值返回大型对象：当一个函数返回一个大型对象时，编译器可能会创建一个临时对象来存储返回值，然后将这个临时对象深拷贝到调用方的变量中。
函数按值传递大型对象：将大型对象按值传递给函数参数，同样会导致在函数内部创建一个深拷贝的临时副本。
容器操作：
```
std::vector
```
在需要重新分配内存以增加容量时，会将所有现有元素从旧内存深拷贝到新内存中。

这些场景中，源对象（无论是函数返回的临时对象、函数参数的副本还是容器扩容前的旧元素）往往在拷贝操作完成后就立即不再需要了。进行深拷贝意味着：

额外的内存分配：为副本分配新的堆内存，这本身就是一项耗时操作，涉及到系统调用。
额外的数据复制：将大量数据从一处内存复制到另一处，这会消耗CPU周期和内存带宽。
资源浪费：分配的内存和复制的数据很快就会被抛弃，因为源对象即将被销毁并释放其资源。

所有这些开销，在对象生命周期短暂且资源规模庞大的场景下，会累积成显著的性能瓶颈和内存效率问题。这就是C++11之前深拷贝机制的痛点，也是移动语义诞生的主要驱动力。

蕉点AI

AI电商商品图生成平台 | 智能商品素材制作工具

下载

移动语义如何通过‘资源窃取’实现内存优化？

移动语义的核心在于改变了“拷贝”的传统观念，引入了“移动”的概念。它不是复制数据，而是转移资源的所有权。这种“资源窃取”机制，对于那些管理着堆内存或其他系统资源的类来说，是实现内存优化的关键。

想象一下，你有一个

std::vector

对象，里面存储了数百万个整数。如果你要将这个

vector

传递给一个函数，或者从一个函数返回它，传统的深拷贝会创建一个全新的

vector

，并把所有整数都复制一遍。这就像你搬家时，不是把家具从旧房子搬到新房子，而是把所有家具都重新买一遍，然后把旧家具扔掉——显然这是巨大的浪费。

移动语义的“资源窃取”就像是搬家时直接把家具从旧房子搬到新房子。对于我们的

std::vector

：

识别可移动对象：移动操作只针对右值（rvalue），通常是临时对象或你明确表示“我不再需要这个对象了”的具名对象（通过
```
std::move
```
）。这些对象要么生命周期即将结束，要么你已经决定放弃其所有权。
转移所有权：当目标对象（通过移动构造或移动赋值）从源右值对象“窃取”资源时，它会将源对象内部指向资源的指针（例如
```
std::vector
```
内部的
```
_data
```
指针）直接复制到自己内部。
“掏空”源对象：在转移所有权之后，源对象的内部指针会被置为
```
nullptr
```
，或者将其内部状态设置为一个“空”但有效的状态（比如
```
std::vector
```
的
```
size
```
和
```
capacity
```
都设为0）。这样做是为了确保当源对象最终被销毁时，它不会试图释放那些已经被转移走的资源，从而避免二次释放或悬空指针问题。

#include 
#include  // For std::move

class MyResource {
public:
    int* data;
    size_t size;

    // 构造函数
    MyResource(size_t s) : size(s) {
        data = new int[size];
        std::cout << "MyResource created, allocated " << size * sizeof(int) << " bytes at " << data << std::endl;
    }

    // 析构函数
    ~MyResource() {
        if (data) {
            std::cout << "MyResource destroyed, deallocated " << size * sizeof(int) << " bytes at " << data << std::endl;
            delete[] data;
        } else {
            std::cout << "MyResource destroyed (empty/moved from)." << std::endl;
        }
    }

    // 拷贝构造函数 (深拷贝)
    MyResource(const MyResource& other) : size(other.size) {
        data = new int[size];
        for (size_t i = 0; i < size; ++i) {
            data[i] = other.data[i];
        }
        std::cout << "MyResource copied (deep copy), allocated " << size * sizeof(int) << " bytes at " << data << std::endl;
    }

    // 移动构造函数 (资源窃取)
    MyResource(MyResource&& other) noexcept : data(other.data), size(other.size) {
        other.data = nullptr; // 掏空源对象
        other.size = 0;       // 确保源对象安全销毁
        std::cout << "MyResource moved (resource stolen), new owner at " << data << std::endl;
    }

    // 拷贝赋值运算符 (深拷贝)
    MyResource& operator=(const MyResource& other) {
        if (this != &other) {
            if (data) delete[] data; // 释放旧资源
            size = other.size;
            data = new int[size];
            for (size_t i = 0; i < size; ++i) {
                data[i] = other.data[i];
            }
            std::cout << "MyResource copy assigned (deep copy), allocated " << size * sizeof(int) << " bytes at " << data << std::endl;
        }
        return *this;
    }

    // 移动赋值运算符 (资源窃取)
    MyResource& operator=(MyResource&& other) noexcept {
        if (this != &other) {
            if (data) delete[] data; // 释放旧资源
            data = other.data;
            size = other.size;
            other.data = nullptr; // 掏空源对象
            other.size = 0;       // 确保源对象安全销毁
            std::cout << "MyResource move assigned (resource stolen), new owner at " << data << std::endl;
        }
        return *this;
    }
};

// 示例函数：按值返回MyResource
MyResource createResource() {
    return MyResource(100); // 这里会发生移动构造，而非深拷贝 (RVO/NRVO)
}

// 示例函数：按值接受MyResource
void processResource(MyResource r) {
    std::cout << "Processing resource (size: " << r.size << ")" << std::endl;
}

// int main() {
//     std::cout << "--- Creating r1 ---" << std::endl;
//     MyResource r1(50); // 构造函数
//
//     std::cout << "\n--- Moving r1 to r2 ---" << std::endl;
//     MyResource r2 = std::move(r1); // 移动构造
//
//     std::cout << "\n--- r1 after move: data=" << r1.data << ", size=" << r1.size << std::endl; // r1已为空
//
//     std::cout << "\n--- Creating r3 from createResource() ---" << std::endl;
//     MyResource r3 = createResource(); // 移动构造 (或RVO优化)
//
//     std::cout << "\n--- Copying r3 to r4 ---" << std::endl;
//     MyResource r4 = r3; // 拷贝构造
//
//     std::cout << "\n--- Move assigning r4 from createResource() ---" << std::endl;
//     r4 = createResource(); // 移动赋值
//
//     std::cout << "\n--- Processing r3 by value ---" << std::endl;
//     processResource(std::move(r3)); // 移动构造到函数参数
//
//     std::cout << "\n--- End of main ---" << std::endl;
//     return 0;
// }

（为了文章简洁，

main

函数代码作为示例，不直接输出在正文）

在这个

MyResource

例子中，移动构造和移动赋值仅仅是复制了

data

指针和

size

成员，然后将源对象的

data

设为

nullptr

。与深拷贝相比，这避免了

new int[size]

的内存分配和

for

循环的数据复制，将操作开销从O(N)（N是数据量）降低到O(1)，极大地提升了效率和内存利用率。

在实际编程中，何时应该显式使用

std::move

，何时又无需干预？

std::move

是C++11引入的一个非常强大的工具，但它常常被误解。它的本质不是“移动”数据，而是一个

static_cast

，将一个左值表达式无条件地转换为一个右值引用（

&&

）。这个右值引用接着就可以绑定到移动构造函数或移动赋值运算符上，从而触发真正的移动操作。理解这一点至关重要：

std::move

本身不执行任何移动操作，它只是一个“信号”，告诉编译器“这个对象我不再需要了，你可以安全地从它那里窃取资源”。

那么，何时需要显式地使用

std::move

，何时又可以信赖编译器的智能判断呢？

无需显式使用

std::move

的常见情况：

返回局部变量（Return Value Optimization - RVO / Named RVO）：当函数返回一个局部变量时，C++编译器（特别是现代编译器）有能力进行返回值优化（RVO或NRVO）。这意味着编译器可以直接在调用方的内存位置构造这个对象，从而完全避免拷贝或移动构造。
```
std::vector createVector() {
    std::vector vec(1000);
    // ...填充vec...
    return vec; // 编译器通常会优化掉这里的移动或拷贝
}
// 调用方：std::vector myVec = createVector();
```
在这种情况下，显式地写
```
return std::move(vec);
```
反而可能抑制某些编译器的RVO，导致强制进行移动构造，虽然通常仍比拷贝好，但不如RVO高效。

将临时对象传递给函数：临时对象本身就是右值，它们可以直接绑定到接受右值引用的函数参数上，触发移动语义。

void processLargeObject(MyResource&& res) { /* ... */ }
// ...
processLargeObject(MyResource(100)); // MyResource(100)是临时对象，直接触发移动

需要显式使用

std::move

的常见情况：

从具名左值对象移动资源，且你明确知道该对象之后不再使用：这是
```
std::move
```
最常见的用途。当你有一个具名的左值对象，并且你知道在
```
std::move
```
之后你不会再使用它（或者即使使用，其状态也无关紧要），那么就可以使用
```
std::move
```
将其转换为右值，从而触发移动语义。
```
std::string s1 = "Hello World!";
std::string s2 = std::move(s1); // s1的资源被移动到s2，s1现在处于有效但未指定状态（通常为空）
// 此时不应再使用s1，或仅在确定其空状态下使用
```

将容器中的元素移动到另一个位置或另一个容器：在容器操作中，如果你想避免深拷贝，而是移动元素，

std::move

是必要的。

std::vector sourceVec;
sourceVec.emplace_back(10);
sourceVec.emplace_back(20);

std::vector destVec;
// 将sourceVec的第一个元素移动到destVec
destVec.push_back(std::move(sourceVec[0])); // 触发MyResource的移动构造

管理独占所有权的智能指针（如

std::unique_ptr

）：

std::unique_ptr

代表独占所有权，它没有拷贝语义，只有移动语义。要将

unique_ptr

的所有权从一个变量转移到另一个变量，必须使用

std::move

。

std::unique_ptr ptr1 = std::make_unique(50);
std::unique_ptr ptr2 = std::move(ptr1); // 转移所有权，ptr1现在为空
// std::unique_ptr ptr3 = ptr2; // 编译错误，unique_ptr不能拷贝

在自定义的交换（

swap

）函数中：为了实现高效的交换，通常会利用移动语义。

void swap(MyResource& a, MyResource& b) noexcept {
    MyResource temp = std::move(a); // 移动构造
    a = std::move(b);               // 移动赋值
    b = std::move(temp);            // 移动赋值
}

总结： 核心原则是“移动你明确不再需要的左值”。如果一个对象是临时对象（右值），或者编译器已经能通过RVO等优化处理，那么就不需要