C++_手写share_ptr

拷贝构造函数：

#include <iostream>

class MyClass {
public:
    int* data;

    // 普通构造函数
    MyClass(int value) : data(new int(value)) {
        std::cout << "普通构造函数被调用\n";
    }

    // 拷贝构造函数
    MyClass(const MyClass& other) : data(new int(*other.data)) {
        std::cout << "拷贝构造函数被调用\n";
    }

    // 析构函数
    ~MyClass() {
        delete data;
        std::cout << "析构函数被调用\n";
    }
};

int main() {
    MyClass obj1(10);  // 调用普通构造函数
    MyClass obj2 = obj1;  // 调用拷贝构造函数

    std::cout << "obj1.data: " << *obj1.data << std::endl;
    std::cout << "obj2.data: " << *obj2.data << std::endl;

    return 0;
}

以下是一个简化版的 shared_ptr 的实现：

#include <iostream>
template <typename T>
class SimpleSharedPtr {
public:
    // 构造函数
    explicit SimpleSharedPtr(T* ptr = nullptr) : ptr_(ptr), count_(ptr ? new size_t(1) : nullptr) {}

    // 拷贝构造函数
    SimpleSharedPtr(const SimpleSharedPtr& other) : ptr_(other.ptr_), count_(other.count_) {
        if (count_) {
            ++(*count_);
        }
    }

    // 赋值操作符
    SimpleSharedPtr& operator=(const SimpleSharedPtr& other) {
        if (this != &other) {
            release();
            ptr_ = other.ptr_;
            count_ = other.count_;
            if (count_) {
                ++(*count_);
            }
        }
        return *this;
    }

    // 析构函数
    ~SimpleSharedPtr() {
        release();
    }

    T& operator*() const { return *ptr_; }
    T* operator->() const { return ptr_; }
    T* get() const { return ptr_; }
    size_t use_count() const { return count_ ? *count_ : 0; }

private:
    void release() {
        if (count_ && --(*count_) == 0) {
            delete ptr_;
            delete count_;
        }
    }

    T* ptr_;
    size_t* count_;
};

class MyClass {
public:
    MyClass() { std::cout << "MyClass 构造函数\n"; }
    ~MyClass() { std::cout << "MyClass 析构函数\n"; }
    void do_something() { std::cout << "MyClass::do_something() 被调用\n"; }
};

int main() {
    {
        SimpleSharedPtr<MyClass> ptr1(new MyClass());
        {
            SimpleSharedPtr<MyClass> ptr2 = ptr1;
            ptr1->do_something();
            ptr2->do_something();
            std::cout << "引用计数: " << ptr1.use_count() << std::endl;
        }
        std::cout << "引用计数: " << ptr1.use_count() << std::endl;
    }
    return 0;
}

这个简化版的 shared_ptr 实现了基本的共享所有权和引用计数功能，方便我们学习了解原理。
但是这个实现并不完整，它缺少了很多 std::shared_ptr 的高级功能，例如自定义删除器、std::make_shared() 和 std::allocate_shared() 函数以及线程安全性等。
在实际项目中，还是使用 C++ 标准库提供的 std::shared_ptr。