C++如何使用移动语义减少拷贝开销

&&

std::vector

std::string

MyVector

MyVector

MyVector

FileHandler

&&

MyString

#include <cstring> // For strlen, strcpy, etc.
#include <iostream>
#include <utility> // For std::move

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

public:
    // 默认构造函数
    MyString() : data(nullptr), length(0) {
        std::cout << "Default Constructor" << std::endl;
    }

    // 带参数构造函数
    MyString(const char* str) {
        std::cout << "Parameterized Constructor" << std::endl;
        if (str) {
            length = std::strlen(str);
            data = new char[length + 1];
            std::strcpy(data, str);
        } else {
            data = nullptr;
            length = 0;
        }
    }

    // 析构函数
    ~MyString() {
        std::cout << "Destructor" << std::endl;
        delete[] data;
    }

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

    // 拷贝赋值运算符 (深拷贝，使用 copy-and-swap idiom)
    MyString& operator=(const MyString& other) {
        std::cout << "Copy Assignment Operator" << std::endl;
        if (this != &other) { // 防止自赋值
            MyString temp(other); // 调用拷贝构造函数
            std::swap(data, temp.data);
            std::swap(length, temp.length);
        }
        return *this;
    }

    // 移动构造函数
    MyString(MyString&& other) noexcept : data(other.data), length(other.length) {
        std::cout << "Move Constructor" << std::endl;
        other.data = nullptr; // 将源对象置为有效但空的状态
        other.length = 0;
    }

    // 移动赋值运算符
    MyString& operator=(MyString&& other) noexcept {
        std::cout << "Move Assignment Operator" << 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对象
MyString createString() {
    return MyString("Hello Move Semantics");
}

int main() {
    MyString s1 = "Initial String"; // Parameterized Constructor
    MyString s2 = s1; // Copy Constructor
    MyString s3 = createString(); // Move Constructor (RVO/NRVO might optimize this, but if not, move happens)
    MyString s4; // Default Constructor
    s4 = std::move(s1); // Move Assignment Operator (s1现在是空状态)
    // std::cout << "s1 after move: " << s1.c_str() << std::endl; // s1.c_str()会返回""

    return 0;
}

std::move

std::forward

std::move

template <typename T>
typename std::remove_reference<T>::type&& move(T&& t) noexcept;

std::move

std::move

static_cast<T&&>(t)

std::move

std::vector<int> source_vec = {1, 2, 3, 4, 5};
std::vector<int> dest_vec = std::move(source_vec); // 调用std::vector的移动构造函数
// 此时 source_vec 处于有效但未指定状态，不应再使用其内容

std::move

source_vec

std::forward

template <typename T>
T&& forward(typename std::remove_reference<T>::type& arg) noexcept;

template <typename T>
T&& forward(typename std::remove_reference<T>::type&& arg) noexcept;

template <typename T>
T&& forward(T&& arg) noexcept;

T&&

T

X&

T&&

X&

T

X

T&&

X&&

std::forward

std::forward

template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    // std::forward 确保 args... 的值类别被正确传递给 T 的构造函数
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

class MyObject {
public:
    MyObject(int x, const std::string& s) { /* ... */ }
    MyObject(int x, std::string&& s) { /* ... */ } // 假设有移动构造
};

int main() {
    std::string name = "Alice";
    auto obj1 = make_unique<MyObject>(10, name); // name作为左值传递给MyObject构造函数
    auto obj2 = make_unique<MyObject>(20, std::string("Bob")); // std::string("Bob")作为右值传递给MyObject构造函数
    return 0;
}

std::move

std::forward