怎样实现一个简单的智能指针 手写引用计数智能指针教程

#include <iostream>
#include <utility> // For std::swap

// 假设我们想管理一个简单的TestObject
class TestObject {
public:
    int id;
    TestObject(int i) : id(i) {
        std::cout << "TestObject " << id << " created." << std::endl;
    }
    ~TestObject() {
        std::cout << "TestObject " << id << " destroyed." << std::endl;
    }
};

template <typename T>
class MySharedPtr {
private:
    T* ptr_;         // 实际指向的内存
    int* ref_count_; // 引用计数器

public:
    // 默认构造函数
    MySharedPtr() : ptr_(nullptr), ref_count_(new int(0)) {}

    // 接受原始指针的构造函数
    explicit MySharedPtr(T* p) : ptr_(p) {
        if (ptr_) {
            ref_count_ = new int(1);
        } else {
            ref_count_ = new int(0);
        }
        // std::cout << "MySharedPtr(T*) constructed, count: " << *ref_count_ << std::endl;
    }

    // 拷贝构造函数
    MySharedPtr(const MySharedPtr& other) : ptr_(other.ptr_), ref_count_(other.ref_count_) {
        if (ref_count_) {
            (*ref_count_)++;
        }
        // std::cout << "MySharedPtr(const MySharedPtr&) copied, count: " << *ref_count_ << std::endl;
    }

    // 移动构造函数 (C++11 move semantics)
    MySharedPtr(MySharedPtr&& other) noexcept : ptr_(other.ptr_), ref_count_(other.ref_count_) {
        other.ptr_ = nullptr;
        other.ref_count_ = nullptr;
        // std::cout << "MySharedPtr(MySharedPtr&&) moved." << std::endl;
    }

    // 拷贝赋值运算符
    MySharedPtr& operator=(const MySharedPtr& other) {
        if (this != &other) { // 防止自赋值
            // 先处理当前持有的资源
            if (ref_count_) {
                (*ref_count_)--;
                if (*ref_count_ == 0) {
                    delete ptr_;
                    delete ref_count_;
                    // std::cout << "Old resource released during copy assignment." << std::endl;
                }
            }

            // 再接管新的资源
            ptr_ = other.ptr_;
            ref_count_ = other.ref_count_;
            if (ref_count_) {
                (*ref_count_)++;
            }
        }
        // std::cout << "MySharedPtr& operator=(const MySharedPtr&) assigned, count: " << (ref_count_ ? *ref_count_ : 0) << std::endl;
        return *this;
    }

    // 移动赋值运算符
    MySharedPtr& operator=(MySharedPtr&& other) noexcept {
        if (this != &other) {
            // 释放当前资源
            if (ref_count_) {
                (*ref_count_)--;
                if (*ref_count_ == 0) {
                    delete ptr_;
                    delete ref_count_;
                }
            }
            // 窃取资源
            ptr_ = other.ptr_;
            ref_count_ = other.ref_count_;
            // 清空源对象
            other.ptr_ = nullptr;
            other.ref_count_ = nullptr;
        }
        // std::cout << "MySharedPtr& operator=(MySharedPtr&&) moved." << std::endl;
        return *this;
    }

    // 析构函数
    ~MySharedPtr() {
        if (ref_count_) {
            (*ref_count_)--;
            // std::cout << "MySharedPtr destructor, count: " << *ref_count_ << std::endl;
            if (*ref_count_ == 0) {
                delete ptr_;
                delete ref_count_;
                ptr_ = nullptr;
                ref_count_ = nullptr;
                // std::cout << "Resource completely freed." << std::endl;
            }
        }
    }

    // 解引用操作符
    T& operator*() const {
        return *ptr_;
    }

    // 成员访问操作符
    T* operator->() const {
        return ptr_;
    }

    // 获取原始指针
    T* get() const {
        return ptr_;
    }

    // 获取当前引用计数
    int use_count() const {
        return ref_count_ ? *ref_count_ : 0;
    }

    // 判断是否为空
    explicit operator bool() const {
        return ptr_ != nullptr;
    }
};

// 示例用法
int main() {
    std::cout << "--- Test 1: Basic creation and destruction ---" << std::endl;
    {
        MySharedPtr<TestObject> p1(new TestObject(101));
        std::cout << "p1 count: " << p1.use_count() << std::endl;
    } // p1 goes out of scope, TestObject 101 destroyed

    std::cout << "\n--- Test 2: Copying ---" << std::endl;
    MySharedPtr<TestObject> p2(new TestObject(202));
    std::cout << "p2 count: " << p2.use_count() << std::endl;
    {
        MySharedPtr<TestObject> p3 = p2; // Copy constructor
        std::cout << "p2 count: " << p2.use_count() << ", p3 count: " << p3.use_count() << std::endl;
        MySharedPtr<TestObject> p4;
        p4 = p2; // Copy assignment
        std::cout << "p2 count: " << p2.use_count() << ", p3 count: " << p3.use_count() << ", p4 count: " << p4.use_count() << std::endl;
    } // p3, p4 go out of scope, count decrements
    std::cout << "After p3, p4 out of scope, p2 count: " << p2.use_count() << std::endl;
    // p2 goes out of scope, TestObject 202 destroyed

    std::cout << "\n--- Test 3: Self-assignment ---" << std::endl;
    MySharedPtr<TestObject> p5(new TestObject(303));
    std::cout << "p5 count: " << p5.use_count() << std::endl;
    p5 = p5; // Self-assignment
    std::cout << "After self-assignment, p5 count: " << p5.use_count() << std::endl;

    std::cout << "\n--- Test 4: Move semantics ---" << std::endl;
    MySharedPtr<TestObject> p6(new TestObject(404));
    std::cout << "p6 count: " << p6.use_count() << std::endl;
    MySharedPtr<TestObject> p7 = std::move(p6); // Move constructor
    std::cout << "After move construct, p6 count: " << p6.use_count() << ", p7 count: " << p7.use_count() << std::endl;

    MySharedPtr<TestObject> p8(new TestObject(505));
    std::cout << "p8 count: " << p8.use_count() << std::endl;
    p7 = std::move(p8); // Move assignment
    std::cout << "After move assign, p8 count: " << p8.use_count() << ", p7 count: " << p7.use_count() << std::endl;

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