c++11 shared_ptr源码

引用中提到的是C++11标准中shared_ptr的源码部分。其中，1.2.1是shared_ptr的移动构造函数的实现，1.2.2是shared_ptr的拷贝构造函数的实现。这两个构造函数是shared_ptr的成员函数，用于创建shared_ptr对象。此外，C++11标准还支持shared_ptr对象之间的比较运算。

相关问题

shared_ptr源码

shared_ptr是C++11中引入的一种智能指针，用于管理动态分配的内存。它可以自动释放内存，避免了手动释放内存的繁琐过程，同时也避免了内存泄漏和悬空指针的问题。

shared_ptr的源码实现主要包括两个部分：引用计数和内存释放。

引用计数是指在多个shared_ptr对象共享同一个指针时，通过计数器来记录指针被引用的次数。每当一个新的shared_ptr对象指向该指针时，计数器加1；当一个shared_ptr对象被销毁时，计数器减1。当计数器为0时，表示没有任何shared_ptr对象指向该指针，此时可以释放该指针所指向的内存。

内存释放是指在引用计数为0时，释放该指针所指向的内存。shared_ptr使用delete操作符来释放内存，因此需要保证该指针是通过new操作符分配的内存。

下面是shared_ptr的简化版源码实现：

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

在上面的代码中，ptr_表示指向动态分配内存的指针，count_表示引用计数。构造函数中，如果ptr_为空，则count_初始化为1；否则，count_初始化为新分配的int类型指针，其值为1。析构函数中，如果引用计数为0，则释放ptr_和count_所指向的内存。拷贝构造函数和赋值运算符重载函数中，需要先将原有的引用计数减1，然后再将新的引用计数加1。

shared ptr源码

下面是一个简单的 shared_ptr 的实现，供参考：

template<typename T>
class shared_ptr {
public:
    shared_ptr() : ptr_(nullptr), ref_count_(nullptr) {}

    explicit shared_ptr(T* ptr) : ptr_(ptr) {
        ref_count_ = new int(1);
    }

    shared_ptr(const shared_ptr<T>& other) : ptr_(other.ptr_), ref_count_(other.ref_count_) {
        ++(*ref_count_);
    }

    ~shared_ptr() {
        release();
    }

    shared_ptr<T>& operator=(const shared_ptr<T>& other) {
        if (this != &other) {
            release();
            ptr_ = other.ptr_;
            ref_count_ = other.ref_count_;
            ++(*ref_count_);
        }
        return *this;
    }

    T* get() const {
        return ptr_;
    }

    void reset() {
        release();
        ptr_ = nullptr;
        ref_count_ = nullptr;
    }

    bool operator==(const shared_ptr<T>& other) const {
        return ptr_ == other.ptr_;
    }

    bool operator!=(const shared_ptr<T>& other) const {
        return !(*this == other);
    }

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

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

    int use_count() const {
        return *ref_count_;
    }

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

private:
    T* ptr_;
    int* ref_count_;
};

这个实现中，我们使用一个计数器 ref_count_ 来记录当前有多少个 shared_ptr 共享一个对象。每当有一个新的 shared_ptr 被创建时，计数器会加一。每当一个 shared_ptr 被销毁时，计数器会减一。只有当计数器为 0 时，才会销毁对象。在拷贝构造函数和赋值操作符中，我们需要注意将计数器加一。在析构函数中，我们需要注意将计数器减一，并在计数器为 0 时销毁对象和计数器。