怎样实现类似智能指针的类 手写简化版智能指针教学示例

#include <iostream> // 仅用于示例中的输出

// 示例：一个简单的资源类，用于观察构造和析构
struct MyResource {
    int value;
    MyResource(int v) : value(v) {
        std::cout << "MyResource(" << value << ") constructed.\n";
    }
    ~MyResource() {
        std::cout << "MyResource(" << value << ") destroyed.\n";
    }
    void do_something() {
        std::cout << "MyResource(" << value << ") doing something.\n";
    }
};

// 简化版智能指针：MyUniquePtr
// 模仿std::unique_ptr，实现独占所有权
template <typename T>
class MyUniquePtr {
private:
    T* ptr; // 持有的原始指针

public:
    // 构造函数：接受一个原始指针
    // explicit关键字避免隐式类型转换
    explicit MyUniquePtr(T* p = nullptr) : ptr(p) {
        // std::cout << "MyUniquePtr constructed with ptr: " << ptr << "\n";
    }

    // 析构函数：确保在MyUniquePtr对象销毁时，其管理的资源也被释放
    ~MyUniquePtr() noexcept { // 析构函数应为noexcept
        // std::cout << "MyUniquePtr destructed, deleting ptr: " << ptr << "\n";
        delete ptr;
    }

    // 禁用拷贝构造函数和拷贝赋值运算符
    // 独占所有权意味着不能复制，只能移动
    MyUniquePtr(const MyUniquePtr&) = delete;
    MyUniquePtr& operator=(const MyUniquePtr&) = delete;

    // 移动构造函数：从另一个MyUniquePtr对象“窃取”所有权
    MyUniquePtr(MyUniquePtr&& other) noexcept : ptr(other.ptr) {
        other.ptr = nullptr; // 将原对象置空，防止其析构时误删资源
        // std::cout << "MyUniquePtr move constructed.\n";
    }

    // 移动赋值运算符：同理，转移所有权
    MyUniquePtr& operator=(MyUniquePtr&& other) noexcept {
        if (this != &other) { // 避免自我赋值
            delete ptr; // 先释放当前持有的资源
            ptr = other.ptr;
            other.ptr = nullptr;
        }
        // std::cout << "MyUniquePtr move assigned.\n";
        return *this;
    }

    // 解引用运算符：允许像操作原始指针一样操作对象
    T& operator*() const {
        // 实际使用时，这里应该检查ptr是否为nullptr，避免空指针解引用
        // 但为了简化，这里暂时省略
        return *ptr;
    }

    // 成员访问运算符：允许通过->访问成员
    T* operator->() const {
        return ptr;
    }

    // 获取原始指针：通常不建议直接使用，除非必要
    T* get() const noexcept {
        return ptr;
    }

    // 释放所有权：返回原始指针，并将MyUniquePtr置空
    // 调用者现在负责管理返回的原始指针
    T* release() noexcept {
        T* oldPtr = ptr;
        ptr = nullptr;
        return oldPtr;
    }

    // 重置：释放当前资源，并管理新的原始指针
    void reset(T* p = nullptr) noexcept {
        if (ptr != p) { // 避免删除自身（如果p就是当前ptr）
            delete ptr;
            ptr = p;
        }
    }

    // 转换为bool：判断是否持有有效指针
    explicit operator bool() const noexcept {
        return ptr != nullptr;
    }
};

// 示例用法
// int main() {
//     std::cout << "--- Creating p1 ---\n";
//     MyUniquePtr<MyResource> p1(new MyResource(10)); // 独占MyResource(10)
//     p1->do_something();
//     std::cout << "p1 value: " << (*p1).value << "\n";

//     std::cout << "--- Attempting copy (will fail to compile) ---\n";
//     // MyUniquePtr<MyResource> p2 = p1; // 编译错误：拷贝构造函数被禁用

//     std::cout << "--- Moving p1 to p3 ---\n";
//     MyUniquePtr<MyResource> p3 = std::move(p1); // 移动所有权，p1变空
//     if (p1) {
//         std::cout << "p1 is still valid (should not happen).\n";
//     } else {
//         std::cout << "p1 is now empty.\n";
//     }
//     p3->do_something();
//     std::cout << "p3 value: " << p3->value << "\n";

//     std::cout << "--- Resetting p3 ---\n";
//     p3.reset(new MyResource(20)); // MyResource(10)被销毁，p3现在管理MyResource(20)
//     p3->do_something();

//     std::cout << "--- Releasing p3's ownership ---\n";
//     MyResource* rawPtr = p3.release(); // p3放弃所有权，MyResource(20)未被销毁
//     if (!p3) {
//         std::cout << "p3 is now empty after release.\n";
//     }
//     std::cout << "Manually deleting released rawPtr...\n";
//     delete rawPtr; // 必须手动删除，否则MyResource(20)会泄漏

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

new

delete

new

delete

delete

delete

new

delete

shared_ptr

std::unique_ptr

MyUniquePtr

std::unique_ptr

MyUniquePtr