智能指针思想实践(std::unique_ptr, std::shared_ptr) - 熊の熊

1 smart pointer 思想

​ 个人认为smart pointer实际上就是一个对原始指针类型的一个封装类，并对外提供了-> 和 * 两种操作，使得其能够表现出原始指针的操作行为。

​ 要理解smart pointer思想首先要了解一个概念RAII(Resource Acquisition Is Initialization), 直译为资源获取即初始化，核心理念为在对象创建时分配资源，而在对象销毁时释放资源.

​ 根据RAII理念，如果对象创建在栈(stack)上，由于栈上的对象在销毁是会自动调用析构函数，因此仅仅需要在构造函数内完成资源分配，而在析构函数内完成资源释放，此时程序员就不需要自己关心资源的释放问题。

​ 但当对象创建在自由存储区(free store)上时，例如:

class Fruit {
public:
    Fruit(std::string name = "fruit", int num = 1) :name_{ name }, num_{ num }{}
	~Fruit(){ cout << "destroy fruit" << endl;}
	std::string name_;
	int num_;
};

int main（）{
    Fruit* intPtr{new Fruit};//memory leak
	return 0；
}

此时系统仅仅能回收在栈上1创建的指针intPtr所占据的资源，对于指针所指向的动态分配的内存空间并不会自动调用析构函数进行资源释放，此时如果程序员不主动调用 delete 进行资源释放则会产生内存泄漏。

​ 那么如何让创建在自由存储区的对象也能够自动地释放资源，而不需要程序员自己手动释放资源呢？智能指针给出了一种非常巧妙的解决思路，它将一个原本定义在自由存储区的对象封装进了一个创建在栈上的资源管理对象中，由这个资源管理对象在自己的析构函数中释放定义在自由存储区上的对象所占据的资源。这使得程序员只需要利用资源管理对象接管在自由存储区上动态创建的对象资源，利用栈对象的生存机制能够实现资源的自动释放而不需要自己手动delete 对象资源。例如:

template <typename T>
class ResourceManager {
public:
	ResourceManager(T* ptr) :ptr_{ ptr } {}
	~ResourceManager() {
		cout << "delete arr in free store" << endl;
		delete ptr_;
	}

private:
	T* ptr_;
};

void AutoManage(){
    ResourceManager fruit{ new Fruit};
}
    
int main（）{
    AutoManage();//delete arr in free store
    system("pause");
	//cout << fruit->name_ << " " << (*fruit).num_ << endl;//fruit 1
	return 0；
}

在AutoManage()函数中动态分配一个Fruit对象，并将其封装进ResourceManager资源管理类中，当程序离开函数AutoManage()时，由于ResourceManager是一个定义在栈上的对象，程序会自动调用析构函数~ResourceManager()进行对象销毁操，此时由于ResourceManager在析构函数中进行了Fruit资源的释放，因此不会发生内存泄漏问题，一次不需要程序员手动释放资源的自动内存管理过程完美完成。

​ 以上仅仅完成了动态分配的资源的自动回收功能，要使得ResourceManager资源管理类能够像Fruit*指针一样操作Fruit对象的成员，还需要对外提供***** 以及->两种指针操作：

template <typename T>
class ResourceManager {
public:
	ResourceManager(T* ptr) :ptr_{ ptr } {}
	~ResourceManager() {
		cout << "delete arr in free store" << endl;
		delete ptr_;
	}
	T*& operator->() {return ptr_;}
	T& operator*() { return *ptr_; }

private:
	T* ptr_;
};

void AutoManage(){
    ResourceManager fruit{ new Fruit};
}
    
int main（）{
    AutoManage();//delete arr in free store
    system("pause");
	cout << fruit->name_ << " " << (*fruit).num_ << endl;//fruit 1
	return 0；
}

此时可以利用ResourceManager提供的***** 以及->操作符直接操作原始Fruit* 指针，使得ResourceManager对象就像一个真实的指向Fruit对象的Fruit* 指针。

2 unique_ptr 思想

​ unique_ptr作为最常用的智能指针，它提供了对资源的独占式管理，即对资源的唯一所有权(sole ownership), 这就要求unique_ptr是一个不可复制的对象。每一个unique_ptr对象都有义务对其管理的资源进行释放。但unique_ptr 并不限制移动(move)操作所导致的所有权转移。最后不要忘记unique_ptr作为一个智能指针概念，它必须能够自动管理动态分配的对象资源，并且提供对对象资源的指针操作。概括一下,unique_ptr要求：

1. 自动内存管理

template<typename T>
class UniquePtr {
public:
	UniquePtr(T* ptr):ptr_{ptr}{}
	~UniquePtr() {
		cout << "delete unique resource in free store" << endl;
		delete ptr_;//释放资源
	}
	UniquePtr(const UniquePtr&) = delete;//禁用拷贝构造
	UniquePtr& operator=(const UniquePtr&) = delete;//禁用拷贝复制
	UniquePtr(UniquePtr&& object) {//移动构造
		cout << "move construct" << endl;
		ptr_ = object.ptr_;
		object.ptr_ = nullptr;
	}
	UniquePtr& operator=(UniquePtr&& object) {//移动赋值
		cout << "move assign" << endl;
		ptr_ = object.ptr_;
		object.ptr_ = nullptr;
		return *this;
	}
	T*& operator->() { return ptr_; }//->
	T& operator*() { return *ptr_; }//*
    
private:
	T* ptr_;
};

template <typename T>
void ChangeOwnership(UniquePtr<T> move) {
	UniquePtr<T> newOwner{ nullptr };
	newOwner = std::move(move);
}

int main（）{
    UniquePtr uniquePtr{new Fruit};
	ChangeOwnership(std::move(uniquePtr));
    //ChangeOwnership(uniquePtr);//compile error! deny copy construction
	//UniquePtr uniquePtr1 = uniquePtr;//compile error! deny copy construction
	//UniquePtr<Fruit> uniquePtr2{nullptr};
	//uniquePtr2 = uniquePtr;//compile error! deny copy assignment
    system("pause");
	return 0；
}

​ 可以看到即使程序员没有自动释放创建在自由存储区上的对象，通过UniquePtr也能自动进行释放。同时UniquePtr无法进行拷贝，保证了UniquePtr对资源所有权的独占性，而通过std::move() 以及移动构造/赋值函数,UniquePtr能够将对资源的所有权转移给其他UniquePtr对象。基本简易得实现了一个std::unique_ptr智能指针。

3 shared_ptr 思想

​ shared_ptr作为另一个常用的智能指针，它和unique_ptr智能指针的理念有着很大的不同，它提供了对资源共享管理，即对资源所有权的共享(shared ownership)，这就要求shared_ptr必须是一个可复制的对象。但是由于shared_ptr对象有很多个，而具体的对象资源只有一个这就要求所有共享对象资源的shared_ptrs指针中最终只能有一个shared_ptr能够释放对象资源。因此shared_ptr引入了引用计数(reference counting)机制：多个shared_ptrs对象共享一个引用计数变量，通过引用计数记录当前对对象资源被引用的次数，仅当引用计数为0，也就是出当前shared_ptr对象外没有其他shared_ptr对象再共享当前对象资源时，当前shared_ptr对象才能够释放持有的对象资源。

​ 显然根据引用计数(reference counting)机制，释放对象资源的shared_ptr对象必然是最后一个持有对象资源的shared_ptr，这就很好得解决了另一个非常常见的内存问题：重复删除(double deletion)。最后概括一下，shared_ptr要求：

1. 共享引用计数
2. 自动内存管理

template <typename T>
class SharedPtr {
public:
	SharedPtr(T* ptr) :ptr_{ ptr }, count_{ new unsigned int{} } {}
	~SharedPtr() {
		if (*count_ == 0) {//引用计数==0，释放资源
			cout << "delete shared resource in free store" << endl;
			delete ptr_;
			delete count_;
		}
		else//引用计数不为0，引用计数-1
			--(*count_);
	}
	SharedPtr(const SharedPtr& object) :ptr_{ object.ptr_ }{//拷贝构造 引用+1
		count_ = object.count_;
		++(*count_);
	}
	SharedPtr& operator=(const SharedPtr& object) {//拷贝赋值 引用+1
		ptr_ = object.ptr_;
		count_ = object.count_;
		++(*count_);
		return *this;
	}
	unsigned int GetReferenceCount() { return *count_; }//输出当前资源引用个数
	T*& operator->() { return ptr_; }//->
	T& operator*() { return *ptr_; }//*

private:
	T* ptr_;
	unsigned int* count_;//reference counting
};

template <typename T>
void ShareOwnership(SharedPtr<T> copy) {
	cout << copy.GetReferenceCount() << endl;
};

int main（）{
    SharedPtr sharedPtr1{new Fruit};
	SharedPtr sharedPtr2{ sharedPtr1 };
	SharedPtr<Fruit> sharedPtr3{ nullptr };
	sharedPtr3 = sharedPtr2;
	ShareOwnership(sharedPtr3);
    system("pause");
	return 0；
}

​ 可以看到即使程序中存在多个shared_ptr对象，共享的Fruit对象资源也只会被释放一次。函数ShareOwnership()中的引用输出为3,这是因为:首先sharedPtr1持有了一个Fruit对象资源，初始化引用为0；其次sharedPtr2，sharedPtr3通过拷贝sharedPtr1的方式共享了Fruit对象资源，这使得引用0+2=2；最后将sharedPtr3拷贝至函数ShareOwnership()的参数copy中时又使得Fruit对象资源的共享者+1，最终使得引用计数2+1=3；

​ 最后补充一点，对于Fruit对象资源的共享，尽量采用直接拷贝shared_ptr对象的方式进行。如果利用原始Fruit* 指针创建新的shared_ptr对象，则很容易产生 重复删除(double deletion)问题：

auto sharedPtr{ std::make_shared<Fruit>("apple",2) };
//sharedPtr.get()返回Fruit对象的原始指针Fruit*
std::shared_ptr<Fruit> sharedPtr1{sharedPtr.get() };//cause double deletion

这是因为sharedPtr，sharedPtr1互相不知道对方的存在，都认为只有自己持有Fruit对象，导致两个shared_ptr的引用计数均为0，当程序走出作用范围后sharedPtr，sharedPtr1都会尝试释放Fruit对象，产生重复删除(double deletion).