C++ 智能指针(unique_ptr, shared_ptr)的源码分析
C++ 智能指针(unique_ptr, shared_ptr)的源码分析
在博文https://blog.csdn.net/qq_27717921/article/details/82940519已经介绍了unique_ptr和shared_ptr的使用，但是这两类的智能指针是如何做到管理指针的呢？
shared_ptr
头文件
template <typename T>
class SharedPointer {
public:
SharedPointer(T *ptr = nullptr, const std::function<void(T*)> &del = Deleter()):
p(ptr), use_c(new std::size_t(ptr != nullptr)), deleter(del) { }
SharedPointer(const SharedPointer &);
SharedPointer(SharedPointer &&) noexcept;
SharedPointer& operator=(SharedPointer);
~SharedPointer() { release(); }
std::size_t use_count() { return *use_c; }
bool unique() const { return *use_c == 1; }
operator bool() const { return p != nullptr; }
void reset(T* ptr = nullptr, const std::function<void(T*)> &del = Deleter());
void swap(SharedPointer<T>&);
T* get() const { return p; }
T& operator*() const { return *p; }
T* operator->() const { return p; }
private:
std::size_t *use_c;
T *p;
std::function<void(T*)> deleter;
void release();
};1. 构造函数
shared_ptr<int> p1(new int (2));SharedPointer(T *ptr = nullptr, const std::function<void(T*)> &del = Deleter()):
p(ptr), use_c(new std::size_t(ptr != nullptr)), deleter(del) { }涉及到的Deleter放在最后来讲。
采用new返回的指针初始化shared_ptr，调用构造函数，在堆上开辟一块存储空间，存放指向这块空间指针的数量，这块空间的地址初始化use_c. new int(2)返回的指针用于初始化p.
2. shared_ptr的拷贝和赋值操作，更新use_count的相关源码
auto q(p) //调用拷贝构造函数auto q = p //调用 = 操作符重载这两句代码涉及到shared_ptr的拷贝构造函数 和 =操作符的重载问题， 主要涉及下面三个函数。
拷贝构造函数：
template <typename T>
SharedPointer<T>::SharedPointer(const SharedPointer<T> &rhs):
use_c(rhs.use_c), p(rhs.p), deleter(rhs.deleter)
{
++*use_c;
}auto q(p) 假设p.use_c = 0xff11ff12, p.p = 0x12fa2334, p.deleter=0xd232455f, 用p的use_c, p, deleter初始化q的use_c, p, delter,显然，q.use_c = 0xff11ff12, q.p = 0x12fa2334, q.deleter=0xd232455f。 显然，p, q都保存了地址0x12fa2334，而在拷贝之前，只有一个指针保存这个地址，那么*(p.use_c) = 1， 所以进行了++*use_c。这个时候地址0xff11ff12保存的内容就是2. 所以无论是p还是q的use_c都是2.
= 操作符重载
template <typena me T>
SharedPointer<T> &SharedPointer<T>::operator=(SharedPointer rhs)
{
SharedPointer<T> temp(rhs); // 拷贝构造函数
swap(temp); //调用swap
return *this;
}template <typename T>
void SharedPointer<T>::swap(SharedPointer<T> &rhs)
{
using std::swap;
swap(use_c, rhs.use_c);
swap(p, rhs.p);
swap(deleter, rhs.deleter);
}函数swap操作，主要是交换shared_ptr的成员变量，比如p.use_c = 0xff11ff12, p.p = 0x12fa2334, p.deleter=0xd232455f,
q.use_c = 0xff11ff5f, q.p = 0x12fa90f3f, q.deleter=0xd232455f, 暂存在tmp，*(tmp.use_c) 和 *(p.use_c) 都等于2， 这个地方拷贝构造弯沉后已经完全相同了，为什么还有调用swap操作, 为了递减赋值号左侧对象的use_c, 这个时候rhs存放的就是赋值号左侧的信息,在=结束后临时变量会调用析构函数, 从而减少左侧的q的use_c。
上面的=重载也可以写成不调用swap的形式,如下
template <typena me T>
SharedPointer<T> &SharedPointer<T>::operator=(SharedPointer rhs)
{
++*rhs.use_c;
if (--*use == 0) {
if (p) {
deleter(p);
}
delete use_c
}
p = rhs.p;
use_c = rhs.use_c;
deleter = rhs.deleter;
return *this;
}3.析构函数，release 操作
shared_ptr中release()只会在shared_ptr的析构函数中被调用。
~SharedPointer() { release(); }template <typename T>
void SharedPointer<T>::release()
{
if (--*use_c == 0) {
if (p) {
deleter(p);
}
delete use_c;
}
use_c = nullptr;
p = nullptr;
}release()操作， 当*use_c == 1 时，也就代表只有一个指针指向这个内存。
void test() {
shared_ptr<vector<int>> t (new vector<int>);
///
t相关的操作
///
}*(t.use_c)=1, t是局部变量，保存在栈内存上，当函数退出时，t调用析构函数时, 也就是最后一个对象调用析构函数时，如果t.p不是空指针时，会调用p指向内存类型的删除器。这里，p是vector* 类型，会调用deleter(p),而vector是栈变量，直接delete掉就可以。除了释放p，还要释放use_c, 并将use_c和p 等于nullptr。
和unique_ptr不同， release操作只在析构函数中调用，所以是私有函数。
4. 其他相关shared_ptr操作的源码实现
std::size_t use_count() { return *use_c; }
bool unique() const { return *use_c == 1; }
operator bool() const { return p != nullptr; }
T* get() const { return p; }
T& operator*() const { return *p; }
T* operator->() const { return p; }unique_ptr
头文件
template <typename T, typename D = std::function<void(T*)>>
class UniquePointer {
public:
UniquePointer(const UniquePointer&) = delete;
UniquePointer& operator=(const UniquePointer&) = delete;
UniquePointer(T *raw_p = nullptr, const std::function<void(T*)> &del = Deleter())
: p(raw_p), deleter(del) { }
UniquePointer(UniquePointer &&) noexcept;
UniquePointer& operator=(UniquePointer &&) noexcept;
~UniquePointer() { deleter(p); }
T* get() const { return p; }
T* release() noexcept;
void reset(T* ptr = nullptr) noexcept;
void swap(UniquePointer<T>&);
operator bool() const { return p != nullptr; }
D& get_deleter() noexcept;
const D& get_deleter() const noexcept;
T& operator*() const { return *p; }
T* operator->() const { return p; }
private:
T *p;
std::function<void(T*)> deleter = D();
};对比shared_ptr的头文件，拷贝构造函数和=操作符重载函数是delete.这也就说明unique_ptr中不能进行直接拷贝和赋值操作。
UniquePointer(const UniquePointer&) = delete;
UniquePointer& operator=(const UniquePointer&) = delete;构造函数
UniquePointer(T *raw_p = nullptr, const std::function<void(T*)> &del = Deleter())
: p(raw_p), deleter(del) { }swap函数
template <typename T, typename D>
void UniquePointer<T, D>::swap(UniquePointer<T> &rhs)
{
using std::swap;
swap(p, rhs.p);
swap(deleter, rhs.deleter);
}析构函数和release函数
~UniquePointer() { deleter(p); }和shared_ptr的析构函数不同，unique_ptr的析构函数更简单， 只需要调用类型T的析构函数，如果是自定义类型需要重写deleter
template <typename T, typename D>
T *UniquePointer<T, D>::release() noexcept
{
T *tmp = p;
p = nullptr;
return tmp;
}release函数会将unique_ptr的p置为nullptr,但是会返回这块地址。
unique_ptr<int> m (new int(2));
m.release();//造成内存泄漏这块代码存在内存泄漏问题，假设m.p = 0x55555555 , m.release()会将m.p = nullptr,但是0x55555555这块内存还没有释放， 造成内存泄漏。下面这块代码才能正确释放内存。
unique_ptr<int> m (new int(2));
auto p = m.release();
delete p;//释放掉内存unique_ptr还有一个很重要的操作，reset操作。
template <typename T, typename D>
void UniquePointer<T, D>::reset(T *ptr) noexcept
{
UniquePointer<T> temp(ptr);
swap(temp);
}下面举个具体的例子：p将所有权转移给了q, p释放了对那块内存的所有权。
unique_ptr<int> p(m.release());
unique_ptr<int> q(new int(5));
q.reset(p.release());最后介绍Deleter,将在下一篇博文中介绍。