智能指针-shared_ptr

智能指针

我们平时使用指针的话，自己new出来的，使用完毕后需要去手动进行删除，但是在一个大的工程项目中，经常会忘掉这件事。所以智能指针就出现了。
看下面的例子：

#include <iostream>
#include <memory>
using namespace std;

class Person{
	string name;
	int age;
public: 
	Person(){
		cout<<"构造函数"<<endl;
	}
	~Person(){
		cout<<"析构函数"<<endl;
	}
};

void test(){
	shared_ptr<Person> sp = make_shared<Person>();
	shared_ptr<Person> sp2 = sp;
	cout<<sp.use_count()<<endl; //引用计数
	cout<<sp2.use_count()<<endl;
}


int main(){
	test();
	return 0;
}

上面的例子使用了一个共享指针，指针的类型是Person类型，共享指针可以进行复制操作，如sp2 = sp，这样的话引用计数会+1；来看下程序执行的结果：

root@k8s-master1:/home/hl/work/test/smartPtr# ./a.out 
构造函数
2
2
析构函数

从执行结果可以看出，析构函数会被自动调用，这样就避免了我们忘掉析构new出来的指针，而且当有多个指针指向同一对象的时，它的引用会++。

重写智能指针

智能指针的核心就是有一个引用计数器和指向对象的指针，我们可以根据其特点来自己重写一个智能指针。代码如下：

#include <iostream>
#include <cassert>
using namespace std;

class Person{
public:
	string name;
	int age;
public:
	Person(){
		name = "薯片";
		age = 18;
		cout<<"构造函数"<<endl;
	}
	~Person(){
		cout<<"析构函数"<<endl;
	}
};
template<class T>
class smartPointer{
private:
	T* _ptr;
	size_t* _count;
public: 
	smartPointer(T* p = nullptr){
		_ptr = p;
		if(p == nullptr){
			_count = new size_t(0);
		}else{
			_count = new size_t(1);
		}
	}
	//拷贝构造函数
	smartPointer(smartPointer& sp){
		_ptr = sp._ptr;
		_count = sp._count;
		(*_count)++;
	}
	//重载->
	T* operator->(){
		assert(_ptr != nullptr);
		return _ptr;
	}
	//重载*
	T& operator*(){
		assert(_ptr != nullptr);
		return *_ptr;
	}
	size_t use_count(){
		return *_count;
	}
	~smartPointer(){
		if(_ptr == nullptr){
			cout<<"指针为空"<<endl;
			delete _count;
			return;
		}
		(*_count)--;//引用计数--
		if(*_count == 0){
			delete _ptr;//释放指针
			delete _count;
			cout<<"智能指针指向的对象已释放"<<endl;
		}
	}
	smartPointer& operator=(smartPointer& sp){
		if(sp._ptr == nullptr) return *this;
		//解决旧的
		(*_count)--;
		if(*_count == 0){
			delete _ptr;
			delete _count;
			cout<<"智能指针指向的对象已释放"<<endl;
		}
		//2、指向新的
		_ptr = sp._ptr;
		_count = sp._count;
		(*_count)++;//引用计数++
		return *this;
	}

};

int main(){
	smartPointer<Person> sp(new Person());
	cout<< sp->name<<endl;
	cout<< (*sp).age <<endl;
	cout<< sp.use_count()<<endl;
	smartPointer<Person> sp2(sp); //拷贝构造
	cout<<sp2.use_count()<<endl;
	smartPointer<Person> sp3(new Person());
	sp3 = sp; //赋值
	cout<<sp3.use_count()<<endl;
}

首先，定义了一个smartPointer的智能指针类，根据智能指针的特点，需要有两个成员属性：_ptr和_count。为了让这个智能指针具有通用性，我们将其定义为模板类。
首先定义其构造函数，当指针为空指针时，其引用计数的初值为0，否则的话就为1。
定义拷贝构造函数：把拷贝对象的指针和引用计数都赋值给新对象，并且引用计数++。
因为其为指针类型，所以我们需要去定义->和操作符。
智能指针还有个use_count的功能，所以需要去实现该函数，返回_count的值_count。
定义析构函数，如果指针为空的话，我们直接delete掉_count，否则的话，_count–, 当引用计数的值为0的时候，delete掉引用计数指针和_ptr 。
智能指针还可以进行赋值操作，所以需要重载=运算符。
程序执行结果：

root@k8s-master1:/home/hl/work/test/smartPtr# ./a.out 
构造函数
薯片
18
1
2
构造函数
析构函数
智能指针指向的对象已释放
3
析构函数
智能指针指向的对象已释放

线程安全的智能指针

当两个智能指针相互指向的时候，会造成引用计数无法为0的情况，所以我们就需要使用锁，对临界资源进行保护，防止同一时间有两个不同的指针指向同一资源。
代码如下：

#include <iostream>
#include <cassert>
#include <mutex>
using namespace std;

class Person{
public:
	string name;
	int age;
public:
	Person(){
		name = "薯片";
		age = 18;
		cout<<"构造函数"<<endl;
	}
	~Person(){
		cout<<"析构函数"<<endl;
	}
};
template<class T>
class smartPointer{
private:
	T* _ptr;
	size_t* _count;
	mutex* m_mutex;
public: 
	smartPointer(T* p = nullptr){
		_ptr = p;
		m_mutex = new mutex;
		if(p == nullptr){
			_count = new size_t(0);
		}else{
			_count = new size_t(1);
		}
	}
	//拷贝构造函数
	smartPointer(smartPointer& sp){
		_ptr = sp._ptr;
		_count = sp._count;
		m_mutex = sp.m_mutex;
		myadd();		
	}
	//重载->
	T* operator->(){
		assert(_ptr != nullptr);
		return _ptr;
	}
	//重载*
	T& operator*(){
		assert(_ptr != nullptr);
		return *_ptr;
	}
	size_t use_count(){
		return *_count;
	}
	~smartPointer(){
		if(_ptr == nullptr){
			cout<<"指针为空"<<endl;
			delete _count;
			return;
		}
		mydelete();
	}
	//重载赋值操作符
	smartPointer& operator=(smartPointer& sp){
		if(sp._ptr == nullptr) return *this;
		//解决旧的
		mydelete();
		//2、指向新的
		_ptr = sp._ptr;
		_count = sp._count;
		m_mutex = sp.m_mutex;
		myadd();	
		return *this;
	}
private:
	void myadd(){
		m_mutex->lock();
		(*_count)++;
		m_mutex->unlock();
	}
	void mydelete(){
		bool deleteMutex = false;
		m_mutex->lock();
		(*_count)--;
		if(*_count == 0){
			delete _ptr;
			delete _count;
			deleteMutex = true;
			cout<<"智能指针指向的对象已释放"<<endl;
		}
		m_mutex->unlock();
		if(deleteMutex == true) delete m_mutex;
	}
};

在智能指针类中，我们需要加一个成员属性 mutex，在构造函数中将锁进行初始化。当引用计数++的时候，我们需要先上锁，再++，然后在解锁；当引用计数–的时候，就不能单纯的–前加锁，–完解锁，锁本身也是个指针，所以也需要释放，解决办法就是使用一个标志flag，初始值为false，然后上锁，当引用计数为0的时候，我们将flag设置为true，接下来进行解锁，并判断flag的值如果为true的话，直接delete掉。