Copying and Moving⚓︎

// 假设 Currency 是一个类
void displayCurrency(Currency item) { // item 是 bucks 的一个副本
    std::cout << "Value: " << item.dollars() << std::endl;
}

int main() {
    Currency bucks(100, 0);
    displayCurrency(bucks); // bucks 被拷贝到参数 item 中
    return 0;
}

#include <cstring>
#include <iostream>

class Person {
private:
    char* name;
    // 其他成员，如 age 等

public:
    Person(const char* n) {
        if (n) {
            name = new char[std::strlen(n) + 1];
            std::strcpy(name, n);
        } else {
            name = new char[1];
            name[0] = '\0';
        }
        std::cout << "Person created: " << (name ? name : "null") << std::endl;
    }

    ~Person() {
        std::cout << "Person destroyed: " << (name ? name : "null") << std::endl;
        delete[] name; // 释放动态分配的内存
    }

    // 如果不提供拷贝构造函数，编译器会生成一个浅拷贝版本：
    // Person(const Person& other) : name(other.name) {} // 错误的浅拷贝！

    // 正确的深拷贝构造函数
    Person(const Person& other) {
        if (other.name) {
            name = new char[std::strlen(other.name) + 1];
            std::strcpy(name, other.name);
        } else {
            name = new char[1];
            name[0] = '\0';
        }
        std::cout << "Person (deep) copied: " << name << std::endl;
    }

    // 通常还需要一个拷贝赋值运算符 (见后文)
    Person& operator=(const Person& other) {
        std::cout << "Person copy assignment for: " << (name ? name : "null") << " from " << (other.name ? other.name : "null") << std::endl;
        if (this == &other) { // 处理自我赋值
            return *this;
        }
        delete[] name; // 释放旧资源
        if (other.name) {
            name = new char[std::strlen(other.name) + 1];
            std::strcpy(name, other.name);
        } else {
            name = new char[1];
            name[0] = '\0';
        }
        return *this;
    }

    void print() const {
        std::cout << "Name: " << (name ? name : "N/A") << std::endl;
    }
};

class NonCopyable {
public:
    NonCopyable() = default;
    NonCopyable(const NonCopyable&) = delete;             // 禁用拷贝构造函数
    NonCopyable& operator=(const NonCopyable&) = delete;  // 禁用拷贝赋值运算符
};

class AnotherClass {
public:
    // ...
    AnotherClass(const AnotherClass& other) = default;              // 显式使用默认拷贝构造函数
    AnotherClass& operator=(const AnotherClass& other) = default;   // 显式使用默认拷贝赋值运算符
    ~AnotherClass() = default;                                      // 显式使用默认析构函数
};

#include <iostream>
#include <vector>
#include <algorithm> // For std::copy
#include <iterator>  // For std::back_inserter

int main() {
    std::vector<int> source = {1, 2, 3, 4, 5};
    std::vector<int> destination1(source.size()); // 目标容器需要有足够空间

    // 复制到预先分配好空间的容器
    std::copy(source.begin(), source.end(), destination1.begin());

    for (int val : destination1) {
        std::cout << val << " "; // 输出: 1 2 3 4 5
    }
    std::cout << std::endl;

    std::vector<int> destination2;
    // 使用 std::back_inserter 动态扩展目标容器 (通常用于 vector, list, deque)
    std::copy(source.begin(), source.end(), std::back_inserter(destination2));

    for (int val : destination2) {
        std::cout << val << " "; // 输出: 1 2 3 4 5
    }
    std::cout << std::endl;

    return 0;
}

class MyString {
public:
    char* data_;
    size_t size_;

    // ...
    // 移动构造函数
    MyString(MyString&& other) noexcept
        : data_(other.data_), size_(other.size_) {
        std::cout << "Move constructor from: \"" << (other.data_ ? other.data_ : "") << "\"\n";
        // 1. 窃取资源 (浅拷贝指针和大小)
        //    data_ = other.data_;
        //    size_ = other.size_; // 已在成员初始化列表完成

        // 2. 将源对象置于有效但未指定（通常是空）的状态
        //    确保源对象析构时不会释放已被窃取的资源
        other.data_ = nullptr;
        other.size_ = 0;
    }
    // ...
};

// 接着上面的例子
class MyString {
public:
    char* data_;
    size_t size_;

    // ...
    // 移动赋值运算符
    MyString& operator=(MyString&& other) noexcept {
        std::cout << "Move assignment operator from: \"" << (other.data_ ? other.data_ : "") << "\"\n";
        if (this == &other) { // 自我赋值检查（虽然对于右值引用源，别名情况较少，但仍是好习惯）
            return *this;
        }

        // 1. 释放当前对象持有的资源
        delete[] data_;

        // 2. 窃取源对象的资源
        data_ = other.data_;
        size_ = other.size_;

        // 3. 将源对象置于有效但未指定（通常是空）的状态
        other.data_ = nullptr;
        other.size_ = 0;

        return *this;
    }
    // ...
};

#include <vector>
#include <string>
#include <utility> 
#include <iostream>

int main() {
    std::string str1 = "hello";
    std::cout << "Before move, str1: " << str1 << std::endl;

    std::string str2 = std::move(str1); // 调用移动构造函数，str1 的资源被转移到 str2

    std::cout << "After move, str1: " << str1 << " (state is valid but unspecified)" << std::endl;
    std::cout << "After move, str2: " << str2 << std::endl;

    std::vector<std::string> vec1;
    vec1.push_back("world");

    std::vector<std::string> vec2 = std::move(vec1); // 移动，vec1 的内部缓冲区可能被 vec2接管

    std::cout << "vec1 size after move: " << vec1.size() << std::endl;
    std::cout << "vec2 size after move: " << vec2.size() << std::endl;
    if (!vec2.empty()) {
        std::cout << "vec2[0] after move: " << vec2[0] << std::endl;
    }

    return 0;
}

#include <iostream>
#include <string>
#include <utility>

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

    MyResource(size_t s = 0) : size(s), data(s > 0 ? new int[s] : nullptr) {
        if (data) {
            for (size_t i = 0; i < size; ++i) data[i] = i;
        }
        std::cout << "MyResource(" << size << ") constructed." << std::endl;
    }

    ~MyResource() {
        delete[] data;
        std::cout << "MyResource(" << size << ") destructed." << std::endl;
    }

    // 拷贝构造函数 (深拷贝)
    MyResource(const MyResource& other) : size(other.size), data(other.size > 0 ? new int[other.size] : nullptr) {
        if (data) {
            std::copy(other.data, other.data + other.size, data);
        }
        std::cout << "MyResource(" << size << ") copy constructed." << std::endl;
    }

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

    // 移动构造函数 (浅拷贝 + 源对象置空)
    MyResource(MyResource&& other) noexcept : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
        std::cout << "MyResource(" << size << ") move constructed." << std::endl;
    }

    // 移动赋值运算符 (浅拷贝 + 源对象置空 + 释放旧资源)
    MyResource& operator=(MyResource&& other) noexcept {
        if (this != &other) {
            delete[] data; // 释放当前资源
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        std::cout << "MyResource(" << size << ") move assigned." << std::endl;
        return *this;
    }

    // 推荐：提供一个成员 swap 函数 (通常是 noexcept)
    void swap(MyResource& other) noexcept {
        std::cout << "MyResource::swap() called." << std::endl;
        using std::swap; // 引入 std::swap，以防万一需要交换内部成员
        swap(data, other.data);
        swap(size, other.size);
    }
};

// 推荐：在与 MyResource 相同的命名空间中提供一个非成员 swap 函数
// 这个函数通常只是调用成员 swap 函数
namespace MyNamespace {
    void swap(MyResource& a, MyResource& b) noexcept {
        a.swap(b); // 调用 MyResource 的成员 swap 函数
    }
}

int main() {
    MyResource r1(10);
    MyResource r2(5);

    std::cout << "\n--- Calling std::swap ---" << std::endl;
    // 关键点：使用 using std::swap; 然后无限定调用 swap(r1, r2);
    // 这会触发 ADL (Argument-Dependent Lookup)，优先找到 MyNamespace::swap
    // 如果 MyNamespace::swap 不存在，则回退到 std::swap 的默认模板
    using std::swap;
    swap(r1, r2); // 优先调用 MyNamespace::swap(MyResource&, MyResource&)

    std::cout << "\n--- After swap ---" << std::endl;
    // r1 现在是 size 5，r2 是 size 10
    std::cout << "r1 size: " << r1.size << std::endl;
    std::cout << "r2 size: " << r2.size << std::endl;

    return 0;
}