C++ 手写智能指针

在C++中手写智能指针可以通过实现一个类来实现。智能指针主要有两种类型：shared_ptr和unique_ptr。

对于shared_ptr，你可以使用引用计数的方式来管理指针的生命周期。你需要在实现中包含一个计数器，每当有一个shared_ptr指向同一个对象时，计数器加一，当没有shared_ptr指向该对象时，计数器减一。当

相关问题

c++ 手写智能指针

以下是一个简单的C++手写智能指针的实现，它使用引用计数来跟踪指针的使用情况，确保在不再需要指针时正确地释放内存：

template <typename T>
class SmartPtr {
public:
    SmartPtr(T* ptr = nullptr) : ptr_(ptr) {
        if (ptr_) {
            shared_count_ = new int(1);
        }
    }

    ~SmartPtr() {
        release();
    }

    SmartPtr(const SmartPtr& other) {
        ptr_ = other.ptr_;
        if (ptr_) {
            shared_count_ = other.shared_count_;
            (*shared_count_)++;
        }
    }

    template <typename U>
    SmartPtr(const SmartPtr<U>& other) {
        ptr_ = other.get();
        if (ptr_) {
            shared_count_ = other.get_shared_count();
            (*shared_count_)++;
        }
    }

    SmartPtr& operator=(const SmartPtr& other) {
        if (this != &other) {
            release();
            ptr_ = other.ptr_;
            if (ptr_) {
                shared_count_ = other.shared_count_;
                (*shared_count_)++;
            }
        }
        return *this;
    }

    T& operator*() const {
        return *ptr_;
    }

    T* operator->() const {
        return ptr_;
    }

    T* get() const {
        return ptr_;
    }

    int use_count() const {
        return *shared_count_;
    }

    int* get_shared_count() const {
        return shared_count_;
    }

    void reset(T* ptr = nullptr) {
        release();
        ptr_ = ptr;
        if (ptr_) {
            shared_count_ = new int(1);
        }
    }

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

    T* ptr_;
    int* shared_count_;
};

手写智能指针shared_ptr

shared_ptr 是 C++ 标准库中的智能指针之一，用于管理动态分配的对象。它可以跟踪对象的引用计数，并在没有引用时自动释放内存。下面是一个手写的简单版本：

template<typename T>
class shared_ptr {
public:
    shared_ptr(T* ptr = nullptr) : m_ptr(ptr), m_refCount(new unsigned int(1)) {}
    ~shared_ptr() {
        release();
    }
    shared_ptr(const shared_ptr<T>& other) {
        copy(other);
    }
    shared_ptr<T>& operator=(const shared_ptr<T>& other) {
        if (this != &other) {
            release();
            copy(other);
        }
        return *this;
    }
    
    T& operator*() const {
        return *m_ptr;
    }
    
    T* operator->() const {
        return m_ptr;
    }
    
    unsigned int use_count() const {
        return *m_refCount;
    }
    
private:
    void release() {
        if (--(*m_refCount) == 0) {
            delete m_ptr;
            delete m_refCount;
        }
    }
    
    void copy(const shared_ptr<T>& other) {
        m_ptr = other.m_ptr;
        m_refCount = other.m_refCount;
        ++(*m_refCount);
    }
    
    T* m_ptr;
    unsigned int* m_refCount;
};

这只是一个简单实现的示例，实际上 shared_ptr 还涉及到更多的细节，比如原子操作、自定义删除器等。在实际开发中，建议使用标准库提供的 shared_ptr，以避免潜在的问题。