C++ 智能指针(unique_ptr, shared_ptr)的源码分析

在博文https://blog.csdn.net/qq_27717921/article/details/82940519已经介绍了unique_ptr和shared_ptr的使用，但是这两类的智能指针是如何做到管理指针的呢？

shared_ptr

头文件

template 
class SharedPointer {
public:
	SharedPointer(T *ptr = nullptr, const std::function &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 &del = Deleter());

	void swap(SharedPointer&);

	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 deleter;

	void release();
};

1. 构造函数

shared_ptr p1(new int (2));

SharedPointer(T *ptr = nullptr, const std::function &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 
SharedPointer::SharedPointer(const SharedPointer &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 
SharedPointer &SharedPointer::operator=(SharedPointer rhs)
{
	SharedPointer temp(rhs); // 拷贝构造函数
	swap(temp); //调用swap
	return *this;
}

template 
void SharedPointer::swap(SharedPointer &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 
SharedPointer &SharedPointer::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 
void SharedPointer::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> t (new vector);
///
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 >
class UniquePointer {
public:
	UniquePointer(const UniquePointer&) = delete;
	UniquePointer& operator=(const UniquePointer&) = delete;

	UniquePointer(T *raw_p = nullptr, const std::function &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&);

	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 deleter = D();
};

对比shared_ptr的头文件，拷贝构造函数和=操作符重载函数是delete.这也就说明unique_ptr中不能进行直接拷贝和赋值操作。

UniquePointer(const UniquePointer&) = delete;
UniquePointer& operator=(const UniquePointer&) = delete;

构造函数

UniquePointer(T *raw_p = nullptr, const std::function &del = Deleter())
			: p(raw_p), deleter(del) { }

swap函数 

template 
void UniquePointer::swap(UniquePointer &rhs)
{
	using std::swap;
	swap(p, rhs.p);
	swap(deleter, rhs.deleter);
}

析构函数和release函数

~UniquePointer() { deleter(p); }

和shared_ptr的析构函数不同，unique_ptr的析构函数更简单， 只需要调用类型T的析构函数，如果是自定义类型需要重写deleter

template 
T *UniquePointer::release() noexcept
{
	T *tmp = p;
	p = nullptr;
	return tmp;
}

release函数会将unique_ptr的p置为nullptr,但是会返回这块地址。

unique_ptr m (new int(2));
m.release();//造成内存泄漏

这块代码存在内存泄漏问题，假设m.p = 0x55555555 , m.release()会将m.p = nullptr,但是0x55555555这块内存还没有释放， 造成内存泄漏。下面这块代码才能正确释放内存。

unique_ptr m (new int(2));
auto p = m.release();
delete p;//释放掉内存

 unique_ptr还有一个很重要的操作，reset操作。

template 
void UniquePointer::reset(T *ptr) noexcept
{
	UniquePointer temp(ptr);
	swap(temp);
}

下面举个具体的例子：p将所有权转移给了q, p释放了对那块内存的所有权。

unique_ptr p(m.release());
unique_ptr q(new int(5));
q.reset(p.release());

最后介绍Deleter,将在下一篇博文中介绍。