= default 和 = delete：驯服编译器的“小脾气”

class Cat {
public:
    std::string name;
};

Cat kitty; // ✅ 编译通过，毫无波澜

// --- 几个月后，你加了个构造函数 ---
class Cat {
public:
    // "我想让猫出生时就有个名字"
    Cat(std::string n) : name(n) {}
    std::string name;
};

Cat smokey("Smokey"); // ✅ 当然可以
Cat another_kitty;    // ❌ 编译失败！"没有合适的默认构造函数"

// 就像一个普普通通的宝箱 📦
class TreasureBox {};

// 你虽然什么都没写，但编译器已经悄悄在里面放了六件“法宝”
TreasureBox box1;                  // 1. 默认构造函数：凭空造一个宝箱
TreasureBox box2 = box1;           // 2. 复制构造函数：克隆一个一模一样的宝箱
box1 = box2;                       // 3. 复制赋值运算符：把一个宝箱的样子“画”到另一个上
TreasureBox box3 = std::move(box1); // 4. 移动构造函数 (C++11新增)：把一个宝箱里的财宝“瞬间转移”到新宝箱
box2 = std::move(box3);            // 5. 移动赋值运算符 (C++11新增)：瞬间转移财宝（用于已有宝箱）
// 6. 析构函数：当宝箱生命周期结束时，把它销毁

class Cat {
public:
    // "既然管家不干了，那我亲自动手..."
    Cat() {} // 写一个空的，什么也不做

    Cat(std::string n) : name(n) {}
    std::string name;
};

Cat kitty; // ✅ 好了，现在又能编译通过了

class Cat {
public:
    // 告诉编译器：请务必为我生成那个最标准的、默认的构造函数
    Cat() = default;

    // 这是我自己定义的版本
    Cat(std::string n) : name(n) {}
    std::string name;
};

Cat kitty; // ✅ 编译通过，意图清晰，代码优雅！

class DatabaseConnection {
public:
    DatabaseConnection(const std::string& address) {
        // 假设这里有一些复杂的逻辑来建立连接...
        std::cout << "🗄️ Connecting to " << address << std::endl;
        // 为了演示，我们用一个指针代表连接资源
        connection_handle_ = new int(123);
    }

    ~DatabaseConnection() {
        if (connection_handle_) {
            std::cout << "🔌 Disconnecting..." << std::endl;
            delete connection_handle_; // 释放资源
        }
    }
private:
    int* connection_handle_; // 代表数据库连接的“句柄”
};

void scary_code() {
    DatabaseConnection conn1("mysql://localhost");
    DatabaseConnection conn2 = conn1; // 糟糕！复制了一个连接对象
} // 函数结束，conn1 和 conn2 都要被析构

class DatabaseConnection {
    // ...
private:
    // "谁也别想调用我，我躲起来了"
    DatabaseConnection(const DatabaseConnection&);
    DatabaseConnection& operator=(const DatabaseConnection&);
};

class DatabaseConnection {
public:
    // ... 其他函数 ...

    // 明确告诉所有人：这个类就是不能被复制！
    DatabaseConnection(const DatabaseConnection&) = delete;
    DatabaseConnection& operator=(const DatabaseConnection&) = delete;
};

#include <cstdio> // 为了 FILE*
#include <utility> // 为了 std::move

class ManagedFile {
public:
    // 构造函数：获取资源 (打开文件)
    ManagedFile(const char* filename, const char* mode) {
        m_file_handle = fopen(filename, mode);
        if (m_file_handle == nullptr) {
            throw std::runtime_error("文件打开失败！");
        }
        std::cout << "📜 文件 '" << filename << "' 已打开。" << std::endl;
    }

    // 析构函数：释放资源 (关闭文件)
    ~ManagedFile() {
        if (m_file_handle) {
            std::cout << "덮 文件已关闭。" << std::endl;
            fclose(m_file_handle);
        }
    }

    // --- 核心设计：控制复制和移动 ---

    // 🚫 步骤1：明确禁止复制
    ManagedFile(const ManagedFile&) = delete;
    ManagedFile& operator=(const ManagedFile&) = delete;

    // ✅ 步骤2：显式启用移动构造
    // 我们要“偷”走 other 的资源，并让它“变空”
    ManagedFile(ManagedFile&& other) noexcept
        : m_file_handle(other.m_file_handle) {
        other.m_file_handle = nullptr; // 这是关键！让源对象“放手”
    }

    // ✅ 步骤3：显式启用移动赋值
    ManagedFile& operator=(ManagedFile&& other) noexcept {
        if (this != &other) { // 防止自己移动给自己
            if (m_file_handle) fclose(m_file_handle); // 先把自己持有的文件关掉
            m_file_handle = other.m_file_handle; // “偷”资源
            other.m_file_handle = nullptr;       // 让源对象“放手”
        }
        return *this;
    }

private:
    FILE* m_file_handle;
};