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

要让C++结构体高效转移资源，必须定义移动构造函数和移动赋值运算符，通过窃取右值资源并置空源对象指针，避免深拷贝开销，实现高性能资源管理。

在C++中，结构体的移动语义与右值引用是性能优化的关键，尤其当结构体内部管理着动态分配的资源时。简单来说，它允许我们“偷取”临时对象（右值）的资源，而不是进行昂贵的深拷贝，从而实现资源的高效转移，大大减少不必要的内存分配和释放开销。这对于构建高性能、资源敏感的C++应用来说，几乎是不可或缺的。

解决方案

要让C++结构体能够利用移动语义，核心在于为其定义移动构造函数（Move Constructor）和移动赋值运算符（Move Assignment Operator）。当一个临时对象（右值）被用来初始化或赋值另一个对象时，编译器会优先选择调用这些移动操作，而不是传统的拷贝操作。这就像你搬家时，与其把所有家具都重新买一套，不如直接把旧家具搬到新家，这样既省钱又省力。

我们来看一个具体的例子，假设我们有一个

MyString

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

// 一个简单的结构体，拥有动态分配的C风格字符串
struct MyString {
    char* data;
    size_t length;

    // 默认构造函数
    MyString() : data(nullptr), length(0) {
        std::cout << "MyString() default constructor @ " << this << std::endl;
    }

    // 接收C风格字符串的构造函数
    MyString(const char* s) : length(s ? std::strlen(s) : 0) {
        std::cout << "MyString(const char*) constructor @ " << this << std::endl;
        data = new char[length + 1];
        if (s) {
            std::strcpy(data, s);
        } else {
            data[0] = '\0';
        }
    }

    // 析构函数：释放资源
    ~MyString() {
        std::cout << "~MyString() destructor @ " << this << std::endl;
        delete[] data;
    }

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

    // 拷贝赋值运算符：深拷贝
    MyString& operator=(const MyString& other) {
        std::cout << "MyString& operator=(const MyString&) copy assignment @ " << this << std::endl;
        if (this != &other) {
            delete[] data; // 释放旧资源
            length = other.length;
            data = new char[length + 1];
            std::strcpy(data, other.data);
        }
        return *this;
    }

    // 移动构造函数：窃取资源
    MyString(MyString&& other) noexcept : data(other.data), length(other.length) {
        std::cout << "MyString(MyString&&) move constructor @ " << this << std::endl;
        other.data = nullptr; // 关键：将源对象的指针置空，防止二次释放
        other.length = 0;
    }

    // 移动赋值运算符：窃取资源
    MyString& operator=(MyString&& other) noexcept {
        std::cout << "MyString& operator=(MyString&&) move assignment @ " << this << std::endl;
        if (this != &other) { // 尽管移动赋值中自赋值不常见，但仍是好习惯
            delete[] data; // 释放当前对象的旧资源

            data = other.data; // 窃取资源
            length = other.length;

            other.data = nullptr; // 将源对象的指针置空
            other.length = 0;
        }
        return *this;
    }

    const char* c_str() const {
        return data ? data : "";
    }
};

// 返回MyString的函数，通常会触发移动语义或RVO
MyString create_string(const char* s) {
    MyString temp(s);
    return temp; // 编译器通常会进行RVO/NRVO，否则会调用移动构造
}

int main() {
    std::cout << "--- 传统拷贝示例 ---" << std::endl;
    MyString s1("Hello"); // 调用MyString(const char*)
    MyString s2 = s1;     // 调用拷贝构造函数
    MyString s3;
    s3 = s1;              // 调用拷贝赋值运算符

    std::cout << "s1: " << s1.c_str() << std::endl;
    std::cout << "s2: " << s2.c_str() << std::endl;
    std::cout << "s3: " << s3.c_str() << std::endl;

    std::cout << "\n--- 移动语义示例 ---" << std::endl;
    MyString s4 = create_string("World"); // 这里通常会发生RVO，否则是移动构造
    std::cout << "s4 after create_string: " << s4.c_str() << std::endl;

    MyString s5;
    s5 = std::move(s4); // 显式调用移动赋值运算符
    std::cout << "s5 after move from s4: " << s5.c_str() << std::endl;
    std::cout << "s4 after move (should be empty): " << (s4.c_str() ? s4.c_str() : "nullptr") << std::endl;

    std::cout << "\n--- std::vector与移动语义 ---" << std::endl;
    std::vector vec;
    vec.reserve(3); // 预留空间，避免不必要的重新分配

    std::cout << "push_back一个临时对象..." << std::endl;
    vec.push_back(MyString("C++")); // 临时对象，会调用移动构造函数

    std::cout << "push_back一个函数返回的临时对象..." << std::endl;
    vec.push_back(create_string("Move")); // 函数返回的右值，通常会移动构造

    MyString temp_str("Semantics");
    std::cout << "push_back一个显式std::move的对象..." << std::endl;
    vec.push_back(std::move(temp_str)); // 显式将左值转换为右值引用，调用移动构造

    std::cout << "Vector contents:" << std::endl;
    for (const auto& s : vec) {
        std::cout << "- " << s.c_str() << std::endl;
    }
    std::cout << "Original temp_str after move: " << (temp_str.c_str() ? temp_str.c_str() : "nullptr") << std::endl;

    std::cout << "\n--- End of main ---" << std::endl;
    return 0;
}

上面的代码展示了

MyString

std::move(s4)

s4

data

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

为什么在C++中，大型结构体需要考虑移动语义而非传统拷贝？

我个人觉得，对于那些内部管理着堆内存、文件句柄、网络连接或其他稀缺资源的大型结构体来说，移动语义的引入简直是“雪中送炭”。传统的拷贝操作（拷贝构造函数和拷贝赋值运算符）通常会执行“深拷贝”，这意味着它会为所有内部资源重新分配内存，然后将源对象的内容逐一复制过来。

试想一下，如果你的

MyString

std::vector

push_back

erase

LargeObject

通义千问

阿里巴巴推出的全能AI助手

下载

而移动语义则完全不同。它不复制资源，而是转移资源的所有权。当一个右值（通常是即将销毁的临时对象）被用作源对象时，它的内部资源可以直接被“嫁接”到目标对象上，然后源对象的资源指针被置空，防止其析构函数重复释放资源。这就像是把一个硬盘从一台电脑拔下来，直接插到另一台电脑上，而不是把硬盘里的所有数据都复制一份。这种零开销的资源转移，对于性能敏感的场景来说，带来的提升是立竿见影的。特别是在容器（如

std::vector

如何为自定义C++结构体正确实现移动构造函数与移动赋值运算符？

正确实现移动构造函数和移动赋值运算符，是让你的结构体能够高效利用移动语义的关键。这并非仅仅是把拷贝操作里的

const MyString&

MyString&&

移动构造函数 (Move Constructor):

它的基本形式是

MyStruct(MyStruct&& other) noexcept;

1. 窃取资源： 将源对象

   other

   的内部资源指针（例如

   data

   ）直接赋值给当前对象的对应指针。
2. 置空源对象： 将源对象

   other

   的内部资源指针设置为

   nullptr

   ，并将其长度或大小等相关状态归零。这是至关重要的一步，它确保了当

   other

   被销毁时，不会尝试释放已经被转移走的资源，从而避免二次释放和内存错误。

// 移动构造函数示例
MyString(MyString&& other) noexcept : data(other.data), length(other.length) {
    std::cout << "MyString(MyString&&) move constructor @ " << this << std::endl;
    other.data = nullptr; // 将源对象的指针置空
    other.length = 0;
}

这里我习惯性地加上

noexcept

std::vector

移动赋值运算符 (Move Assignment Operator):

它的基本形式是

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

1. 自赋值检查： 尽管移动赋值中自赋值（

   a = std::move(a)

   ）并不常见，但为了健壮性，仍然建议进行

   if (this != &other)