c++ 智能指针shared_ptr简单介绍

shared_ptr 智能指针允许多个对象共享资源指向一个资源，指针里面含有引用计数，当引用计数为0时自动调用析构函数释放内存空间，因此可以自动释放动态内存空间。下面时一些简单的使用和介绍

#include<iostream>
#include<memory>
#include<vector>
using namespace std;
struct data
{
	string name;
	int age;
	 
};

int main()
{	
	int a = 4;
	//shared_ptr构造函数是显式调用的，所以不能用new 初始化，且有shared_ptr内置有两个内存位置
	//1）是指向对象的指针 2）用于控制引用计数的数据指针


	//使用make_shared为数据对象和引用计数都申请了内存，而new操作只对数据对象分配了内存。
	shared_ptr<int>shared1 = make_shared<int>(a);
	cout << "初始值是 " << *shared1 << endl;
	cout << "使用计数 " << shared1.use_count() << endl;

	//将共享指向一个对象 ，下面两种方式均可
	shared_ptr<int>shared2 = shared1;
	shared_ptr<int>shared3(shared2);
	cout << "shared1 引用计数 " << shared1.use_count() << endl;
	cout << "shared2 引用计数 " << shared2.use_count() << endl;
	cout << "shared3 引用计数 " << shared3.use_count() << endl;

	//分离关联的原始指针
	shared1.reset();//不带参数引用计数--；
	cout << "shared1 引用计数 " << shared1.use_count() << endl;
	//分离关联原始指针之后，将其指向新的对象
	shared2.reset(new int(34));
	cout << "shared2 引用计数 " << shared2.use_count() << endl;

	cout << "shared3 引用计数 " << shared3.use_count() << endl;

	//自定义删除器deleter 当shared_ptr对象超出范围时候，将调用其析构函数，在析构函数中，将引用计数
	//减1，如果引用计数新值为0 则删除关联的原始指针。

	//析构函数中删除内部原始指针调用delete函数，但是有些时候delete并不能满足要求
	//std::shared_ptr<int>p3(new int[12])仅演示自定义删除器 。
	//像这样申请的数组，应该调用delete[]释放内存，但是shared_ptr<int>析构函数默认delete并不能满足
	//可以使用shared_ptr<int[]>形式或者添加自定义删除器




     //shared_ptr 相对于普通指针的优缺点 与普通指针相比，shared_ptr只提供了-> * 和==运算符 
	//并没有提供 + - ++ -- []等运算符 shared_ptr不分配任何值的时候就是空的，普通指针定义不初始化
	//会指向垃圾空间。

	shared_ptr<int>shared4 ;
	if (shared4 == nullptr)
		cout << " shared 4 is empty!!" << endl;


	//创建shared_ptr注意事项，不要使用同一个原始指针进行创建
	int* testdata = new int(10);
	shared_ptr<int>shared5 (testdata);

	shared_ptr<int>shared6(testdata);//不推荐 因为，当shared5超出作用域时 shared5会释放testdata的内存
	//当shared在释放的时候可能会出现错误。
	shared_ptr<int>shared7 =shared6; //推荐


	//另外不要使用栈中指针调用默认构造，因为删除器会调用析构函数，不是new出来的空间可能会失败

}

下面是升级版本

#include <atomic>
#include <iostream>
#include <atomic>

using namespace std;

template<typename smartptr,typename T>
class ptr_count
{
	friend smartptr;
	T* data;
	atomic<int>use;
	ptr_count(T* data_):data(data_),use(1)
	{
		
	}
	
	~ptr_count()
	{
		delete data;
	}
		
};
template<typename T>
class shared_ptr
{
	public:
	shared_ptr(T* data):ptrcount(new ptr_count<shared_ptr,T>(data)){}
	shared_ptr(const shared_ptr& rhs)
	{
		ptrcount=rhs.ptrcount;
		ptrcount->use++;
	}
	
	shared_ptr& operator= (const shared_ptr& rhs)
	{
		if(*this!=rhs)
		{
			ptrcount->use--;
			if(ptrcount->use==0)
			delete ptrcount;
			
			ptrcount=rhs.ptrcount;
			ptrcount->use++;
			
		}
		return *this;
	}
	~shared_ptr()
	{
		if(--ptrcount->use==0)
		delete ptrcount;
	}
	int use_count()const
	{
		return ptrcount->use;
	}
	
	private:
	ptr_count<shared_ptr,T>ptrcount;
};
int main()
{
	
}

下面是shared_ptr出现循环引用的情况

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


class A;
class B;

class A
{
	public:
	shared_ptr<B>ptrA;
	~A()
	{
		cout << "A析构函数 " << endl;
	}
};
class B
{
	public:
	shared_ptr<A>ptrB;
	~B()
	{
		cout << "B析构函数 " << endl;
	}
	
};
int main()
{
	
	{shared_ptr<A>a=make_shared<A>();
	shared_ptr<B>b=make_shared<B>();
	a->ptrA=b;
    b->ptrB=a;
    
    cout << a.use_count() << endl;}
}