C++结构体移动语义支持右值引用应用实例

P粉602998670

发布时间：2025-08-21 08:34:01

943人浏览过

来源于php中文网

原创

C++结构体支持移动语义以提升性能，核心是通过定义移动构造函数和移动赋值运算符实现资源所有权转移，避免深拷贝开销。

c++结构体移动语义支持右值引用应用实例

C++结构体支持移动语义，这在处理资源密集型对象时至关重要。简单来说，它允许我们“转移”资源的所有权，而不是进行昂贵的深拷贝，从而显著提升程序性能，尤其是在函数参数传递、返回值以及容器操作等场景下。当你的结构体内部包含动态分配的内存或其它资源（比如文件句柄、网络连接、大块数据缓冲区）时，移动语义就能发挥它真正的魔力。在我看来，这不仅仅是性能优化，更是现代C++设计中避免不必要开销、编写更高效代码的一种基本思维方式。

解决方案

要让C++结构体支持移动语义，核心在于为其显式定义移动构造函数（move constructor）和移动赋值运算符（move assignment operator）。这与类（class）的处理方式是完全一致的，因为在C++中，

struct

本质上就是

class

，只不过默认成员访问权限是

public

。

想象一下，我们有一个结构体，它内部管理着一块动态分配的内存。如果只是简单地复制它，那块内存的数据就得重新分配并逐字节拷贝，这显然效率不高。而移动语义做的是什么呢？它直接“偷走”了源对象的资源指针，然后把源对象的指针置空，这样源对象在析构时就不会去释放那块已经被“偷走”的内存了。整个过程，没有一次内存的重新分配和数据拷贝。

#include 
#include 
#include  // For strlen, strcpy, etc.
#include  // For std::move

// 一个简单的结构体，模拟管理动态内存资源
struct MyResourceHolder {
    char* data;
    size_t size;

    // 构造函数
    MyResourceHolder(const char* str = "") : size(strlen(str) + 1) {
        data = new char[size];
        strcpy(data, str);
        std::cout << "构造函数: '" << data << "' (" << (void*)data << ")\n";
    }

    // 析构函数
    ~MyResourceHolder() {
        if (data) { // 确保不是空指针才删除
            std::cout << "析构函数: '" << data << "' (" << (void*)data << ")\n";
            delete[] data;
            data = nullptr; // 避免悬垂指针
        } else {
            std::cout << "析构函数: 空对象\n";
        }
    }

    // 拷贝构造函数 (深拷贝)
    MyResourceHolder(const MyResourceHolder& other) : size(other.size) {
        data = new char[size];
        strcpy(data, other.data);
        std::cout << "拷贝构造函数: '" << data << "' (" << (void*)data << ") from '" << other.data << "'\n";
    }

    // 拷贝赋值运算符 (深拷贝)
    MyResourceHolder& operator=(const MyResourceHolder& other) {
        if (this != &other) { // 防止自赋值
            delete[] data; // 释放旧资源
            size = other.size;
            data = new char[size];
            strcpy(data, other.data);
            std::cout << "拷贝赋值: '" << data << "' (" << (void*)data << ") from '" << other.data << "'\n";
        }
        return *this;
    }

    // 移动构造函数 (关键)
    MyResourceHolder(MyResourceHolder&& other) noexcept : data(nullptr), size(0) {
        // "偷走"other的资源
        data = other.data;
        size = other.size;

        // 将other置为有效但空的（或可析构的）状态
        other.data = nullptr;
        other.size = 0;
        std::cout << "移动构造函数: 资源从 " << (void*)other.data << " 转移到 " << (void*)data << "\n";
    }

    // 移动赋值运算符 (关键)
    MyResourceHolder& operator=(MyResourceHolder&& other) noexcept {
        if (this != &other) { // 防止自赋值
            delete[] data; // 释放自己的旧资源

            // "偷走"other的资源
            data = other.data;
            size = other.size;

            // 将other置为有效但空的（或可析构的）状态
            other.data = nullptr;
            other.size = 0;
            std::cout << "移动赋值: 资源从 " << (void*)other.data << " 转移到 " << (void*)data << "\n";
        }
        return *this;
    }

    void print() const {
        if (data) {
            std::cout << "内容: '" << data << "', 地址: " << (void*)data << "\n";
        } else {
            std::cout << "内容: (空), 地址: (空)\n";
        }
    }
};

// 辅助函数，返回一个MyResourceHolder对象
MyResourceHolder createResource(const char* str) {
    return MyResourceHolder(str); // 这里会触发移动构造（RVO/NRVO优化）
}

// 辅助函数，接受一个MyResourceHolder对象
void processResource(MyResourceHolder res) { // 这里可能会触发移动构造
    std::cout << "处理资源中...\n";
    res.print();
}

/*
int main() {
    std::cout << "--- 1. 拷贝语义示例 ---\n";
    MyResourceHolder r1("Hello");
    MyResourceHolder r2 = r1; // 拷贝构造
    MyResourceHolder r3;
    r3 = r1; // 拷贝赋值
    r1.print();
    r2.print();
    r3.print();

    std::cout << "\n--- 2. 移动语义示例 ---\n";
    MyResourceHolder r4 = createResource("World"); // 返回值优化（RVO/NRVO），可能不触发移动构造
    std::cout << "r4 after createResource:\n";
    r4.print();

    MyResourceHolder r5("MoveMe");
    std::cout << "r5 before move:\n";
    r5.print();
    MyResourceHolder r6 = std::move(r5); // 显式触发移动构造
    std::cout << "r5 after move to r6:\n";
    r5.print();
    std::cout << "r6 after move from r5:\n";
    r6.print();

    MyResourceHolder r7("Original");
    MyResourceHolder r8("Target");
    std::cout << "r7 before move assignment:\n";
    r7.print();
    std::cout << "r8 before move assignment:\n";
    r8.print();
    r8 = std::move(r7); // 显式触发移动赋值
    std::cout << "r7 after move assignment to r8:\n";
    r7.print();
    std::cout << "r8 after move assignment from r7:\n";
    r8.print();

    std::cout << "\n--- 3. 容器中的移动语义 ---\n";
    std::vector vec;
    vec.reserve(2); // 预留空间避免重新分配导致拷贝
    std::cout << "Pushing 'VecItem1'\n";
    vec.push_back(MyResourceHolder("VecItem1")); // 移动构造
    std::cout << "Pushing 'VecItem2'\n";
    vec.push_back(createResource("VecItem2")); // RVO/NRVO 或 移动构造
    std::cout << "Vector contents:\n";
    for (const auto& item : vec) {
        item.print();
    }

    std::cout << "\n--- 4. 函数参数传递中的移动语义 ---\n";
    MyResourceHolder tempRes("FunctionArg");
    std::cout << "tempRes before passing to function:\n";
    tempRes.print();
    processResource(std::move(tempRes)); // 移动构造参数
    std::cout << "tempRes after passing to function:\n";
    tempRes.print(); // tempRes现在是空的

    return 0;
}
*/

在上面的

MyResourceHolder

结构体中，我们清晰地定义了移动构造函数和移动赋值运算符。核心思想就是将源对象的内部资源指针直接赋值给目标对象，然后将源对象的指针置为

nullptr

。这样，当源对象生命周期结束时，其析构函数就不会错误地释放已经被转移走的资源了。

noexcept

关键字也非常重要，它告诉编译器这个操作不会抛出异常，这对于容器（如

std::vector

）在重新分配内存时选择更高效的移动操作而非拷贝操作至关重要。

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

为什么C++结构体需要支持移动语义？

嗯，这个问题问得好，因为它直接触及了性能和资源管理的痛点。在我看来，C++结构体需要支持移动语义，主要有以下几个原因：

首先，最直接的便是性能优化。当你的结构体内部持有像

std::string

、

std::vector

这样本身就管理着动态内存的成员，或者直接持有原始指针指向一大块数据时，传统的拷贝操作意味着要为这些成员重新分配内存，然后把数据从源头一字不差地复制过来。这对于内存开销大、数据量大的结构体来说，是极其耗时的。想象一下，一个结构体里封装了一个几百MB的图片数据缓冲区，每次传递都深拷贝，那程序效率就没法看了。移动语义则避免了这种不必要的内存分配和数据拷贝，它只是简单地“换了个主人”，把指针指向了新的对象，原对象则被“掏空”，效率自然高出一大截。

其次，这关乎资源所有权的清晰转移。有些资源是独占的，比如文件句柄、网络套接字、互斥锁等等，它们不能被简单地复制。移动语义提供了一种优雅且安全的方式来转移这些资源的所有权。一个对象拥有了资源，通过移动操作，这个资源的所有权就干净利落地转移给了另一个对象，原对象不再拥有它。这比手动管理资源所有权，比如通过智能指针（虽然智能指针内部也利用了移动语义），在某些场景下更为直接和高效。

再者，它让C++标准库容器的性能得到极大提升。当你把自定义的结构体放入

std::vector

、

std::list

、

std::map

等容器时，如果你的结构体支持移动语义，那么在容器进行元素插入、删除、重新分配内存等操作时，就可以利用移动而不是拷贝。特别是

std::vector

在容量不足需要重新分配内存时，如果元素支持移动，它会尝试移动旧元素到新内存区域，而不是拷贝，这能显著减少内存分配和数据复制的次数，从而避免性能瓶颈。

所以，在我看来，移动语义不仅仅是一个语言特性，它更是现代C++中编写高效、资源管理得当代码的必备工具。尤其是在处理大型数据结构或需要精细控制资源生命周期的场景下，它的价值是不可替代的。

如何在自定义C++结构体中实现移动构造函数和移动赋值运算符？

实现自定义结构体的移动构造函数和移动赋值运算符，其实遵循一个相对固定的模式，我个人觉得理解这个模式比死记硬背更重要。它的核心思想就是“窃取”资源，然后“清理”原主。

ReRoom AI

专为室内设计打造的AI渲染工具，可以将模型图、平面图、草图、照片转换为高质量设计效果图。

下载

我们以上面提到的

MyResourceHolder

结构体为例，它内部有一个

char* data

成员，管理着一块动态分配的字符数组。

1. 移动构造函数（Move Constructor）： 它的签名通常是

MyStruct(MyStruct&& other) noexcept;

。这里的

&&

就是右值引用，表示它接受一个“即将消亡”的临时对象或通过

std::move

转换过来的对象。

    MyResourceHolder(MyResourceHolder&& other) noexcept
        : data(nullptr), size(0) // 先将自己的成员初始化为安全状态
    {
        // 1. "窃取"资源：将源对象(other)的资源指针和大小直接赋给当前对象
        data = other.data;
        size = other.size;

        // 2. "清理"原主：将源对象(other)的资源指针置空，防止其析构时重复释放资源
        other.data = nullptr;
        other.size = 0; // 或者设置为其他有效但“空”的状态
        std::cout << "移动构造函数: 资源从 " << (void*)other.data << " 转移到 " << (void*)data << "\n";
    }

这里

noexcept

关键字表示这个构造函数不会抛出异常。这对于使用它的标准库容器来说非常重要，因为如果移动操作是

noexcept

的，容器在扩容时就能安全地使用移动语义，否则可能会退化到拷贝语义，影响性能。

2. 移动赋值运算符（Move Assignment Operator）： 它的签名通常是

MyStruct& operator=(MyStruct&& other) noexcept;

。

    MyResourceHolder& operator=(MyResourceHolder&& other) noexcept {
        if (this != &other) { // 避免自赋值：将自身移动给自己没有意义，且可能导致问题
            // 1. 释放当前对象持有的旧资源
            delete[] data;

            // 2. "窃取"资源：将源对象(other)的资源指针和大小直接赋给当前对象
            data = other.data;
            size = other.size;

            // 3. "清理"原主：将源对象(other)的资源指针置空
            other.data = nullptr;
            other.size = 0;
            std::cout << "移动赋值: 资源从 " << (void*)other.data << " 转移到 " << (void*)data << "\n";
        }
        return *this; // 返回*this以支持链式赋值
    }

移动赋值运算符与移动构造函数类似，但多了一步：首先要释放当前对象（

*this

）可能已经持有的旧资源，然后再“窃取”源对象的资源。同样，

noexcept

在这里也扮演着重要角色。

关于“Rule of Five”： 一旦你为结构体（或类）手动定义了析构函数、拷贝构造函数或拷贝赋值运算符中的任何一个，编译器就不会再为你自动生成移动构造函数和移动赋值运算符了。在这种情况下，如果你希望你的结构体支持移动语义，就必须手动实现它们。这就是所谓的“Rule of Five”（析构函数、拷贝构造函数、拷贝赋值、移动构造、移动赋值）。现代C++中，更推荐的理念是“Rule of Zero/Three/Five”，简单来说，如果你的结构体不管理任何原始资源（比如只包含

std::string

、

std::vector

等标准库类型），那么通常不需要手动定义任何特殊的成员函数（Rule of Zero），编译器会生成正确的拷贝/移动操作。但一旦你手动管理资源（如原始指针），那么通常就需要定义全部五个特殊成员函数（Rule of Five），以确保正确的资源管理和语义。

总的来说，实现移动操作并不复杂，关键在于理解其背后的“窃取-清理”逻辑，并确保在实现时遵循

noexcept

的建议以及“Rule of Five”的原则。

C++11自动生成的移动操作与自定义有何不同？何时需要手动定义？

C++11引入移动语义后，编译器在某些特定条件下确实会为你的结构体（和类）自动生成移动构造函数和移动赋值运算符。这听起来很方便，但了解其生成规则和限制非常重要，否则可能会导致意想不到的行为。

自动生成的条件： 编译器会自动生成一个隐式的移动构造函数，如果：

没有用户声明的拷贝构造函数。
没有用户声明的拷贝赋值运算符。
没有用户声明的移动赋值运算符。
没有用户声明的析构函数。
所有非静态数据成员和基类都可移动构造。

编译器会自动生成一个隐式的移动赋值运算符，如果：

没有用户声明的拷贝构造函数。
没有用户声明的拷贝赋值运算符。
没有用户声明的移动构造函数。
没有用户声明的析构函数。
所有非静态数据成员和基类都可移动赋值。

如果一个结构体满足上述条件，那么编译器生成的移动操作会对其非静态成员进行逐成员的移动。对于像

std::string

、

std::vector

这样本身就支持移动语义的成员，这会非常高效。

何时需要手动定义？

这才是关键所在，也是我个人觉得最容易踩坑的地方。以下几种情况，你几乎总是需要手动定义移动操作：

当你的结构体直接管理原始资源时（比如原始指针、文件句柄、网络套接字等）：这是最典型的场景，就像我们
```
MyResourceHolder
```
的例子。如果你的结构体内部有一个
```
char*
```
或
```
int*
```
，并且你在构造函数中
```
new
```
了内存，在析构函数中
```
delete
```
了内存，那么你就必须手动定义拷贝构造、拷贝赋值、移动构造和移动赋值。因为编译器自动生成的移动操作只会进行浅拷贝（直接复制指针值），这会导致多个对象指向同一块内存，最终在析构时发生双重释放（double-free）错误，或者数据被错误地修改。手动定义才能确保资源被正确地“转移”所有权。
当编译器因为你定义了其他特殊成员函数而抑制了自动生成时： 如前面所说，只要你手动定义了析构函数、拷贝构造函数或拷贝赋值运算符中的任何一个，编译器就不会再为你自动生成移动操作了。这是一种“如果你需要自定义析构或拷贝，那么你可能也需要自定义移动”的信号。这种情况下，如果你希望你的结构体具备移动语义，就必须亲力亲为。
当自动生成的移动操作不符合你的预期逻辑时： 虽然罕见，但理论上存在这种可能性。如果你的结构体有非常特殊的资源管理逻辑，自动生成的逐成员移动可能无法满足你的需求，这时你就需要介入并提供自定义的实现。
为了确保
```
noexcept
```
语义： 即使自动生成的移动操作在逻辑上是正确的，它们默认可能不是
```
noexcept
```
的。对于某些标准库容器（如
```
std::vector
```
），如果元素的移动操作不是
```
noexcept
```
的，在某些情况下（如扩容时旧内存区域析构），它们可能会退化为拷贝操作，从而影响性能。如果你想确保移动操作是无异常的，并且希望容器能够充分利用移动语义，那么手动定义并加上
```
noexcept
```
是必要的。