从零简单实现一个线程安全的C++共享指针(shared_ptr)

本文详细介绍了C++中的共享指针shared_ptr的工作原理,包括引用计数机制、复制构造函数、析构函数以及在多线程环境下的线程安全改进,通过实例展示了如何创建和管理对象生命周期。
摘要由CSDN通过智能技术生成

共享指针原理:

shared_ptr主要是用来自动管理动态创建对象的销毁,记录对象被引用的次数,当引用计数清零的时候,把指向的内存区域自动释放掉

如果要手动实现一个共享指针的话就需要一个共享指针类,类中存着被指向的对象的指针

当对象被多个共享指针指向的时候,就需要一个共享的引用计数器counter

当对象被共享指针指向的时候,引用计数器为2

当一个共享指针被释放后,引用计数器的值减1

当都断的时候,引用计数器变为0,这时候清理对象A

共享指针计数器:

class Counter
{
public:
	Counter()
	{
		count = 1;	
	}
	
	void add()
	{
		count++;
	}
	
	void sub()
	{
		count--;
	}
	
	int get() const
	{
		return count;
	}
	
private:
	int count;
};

 共享指针类:

template <typename T>
class Sp
{
public:
	Sp();                           //默认构造函数
	~Sp();                          //析构函数
	Sp(T *ptr);                     //参数构造函数
	Sp(const Sp &obj);              //复制构造函数
	Sp &operator=(const Sp &obj);   //重载=
	T *get();                       //得到共享指针指向的类
	   
	int getcount();                 //得到引用计数器
private:
	
	T *my_ptr;                      //共享指针所指向的对象
	Counter* counter;                   //引用计数器
	void clear();                   //清理函数
};

//默认构造函数,参数为空,构造一个引用计数器
template<typename T>
Sp<T>::Sp()
{
	my_ptr = nullptr;
	counter = new Counter();
}

//复制构造函数,新的共享指针指向旧的共享指针所指对象
template<typename T>
Sp<T>::Sp(const Sp &obj)
{
    //将所指对象也变为目标所指的对象
	my_ptr = obj.my_ptr;
    //获取引用计数器,使得两个共享指针用一个引用计数器
	counter = obj.counter;
    //使这个对象的引用计数器+1
	counter->add();	
};

//重载=
template<typename T>
Sp<T> &Sp<T>::operator=(const Sp&obj)
{
    //清理当前所引用对象和引用计数器
	clear();
    //指向新的对象,并获取目标对象的引用计数器
	my_ptr = obj.my_ptr;
	counter = obj.counter;
    //引用计数器+1
	counter->add();
    //返回自己
	return *this;	
}

//创建一个共享指针指向目标类,构造一个新的引用计数器
template<typename T>
Sp<T>::Sp(T *ptr)
{
	my_ptr = ptr;
	counter = new Counter();
}

//析构函数,出作用域的时候,调用清理函数
template<typename T>
Sp<T>:: ~Sp()
{
	clear();
}

//清理函数,调用时将引用计数器的值减1,若减为0,清理指向的对象内存区域
template<typename T>
void Sp<T>::clear()
{
    //引用计数器-1 
	counter->sub();
    //如果引用计数器变为0,清理对象
	if(0 == counter->get())
	{
		if(my_ptr)
		{
			delete my_ptr;
		}
		delete counter;
	}
}

//当前共享指针指向的对象,被几个共享指针所引用
template<typename T>
int Sp<T>::getcount()
{
	return counter->get();	
};

class A{
public:
	A()
	{
		cout<<"A construct!"<<endl;
	};
	~A()
	{
		cout<<"A destruct!"<<endl;
	};
};

构造测试对象A:

class A{
public:
	A()
	{
		cout<<"A construct!"<<endl;
	};
	~A()
	{
		cout<<"A destruct!"<<endl;
	};
};

测试函数:

int main()
{
	cout<<"start"<<endl;
    { 
      	//创建共享指针sp指向新创建的对象A 
	    Sp<A> sp(new A);
        cout<<sp.getcount()<<endl;
	    {
	  		//创建共享指针sp2指向A,这时有两个共享指针指向A
	    	Sp<A> sp2 = sp;
            cout<<sp.getcount()<<endl;
		}
	    cout<<sp.getcount()<<endl;
	}
    //出了作用域后,引用计数器-1,此时对象被析构,内存被回收
    cout<<"over"<<endl;
}

 输出结果:

这时候,如果多个线程都在使用这个引用计数器的时候,容易引发多线程安全问题,所以在这里添加互斥锁

为计数器类添加线程安全保障

class Counter
{
public:
	Counter()
	{
		my_Mutex = new mutex;
		count = 1;	
	}
	
	void add()
	{
		my_Mutex->lock();
		count++;
		my_Mutex->unlock();
	}
	
	void sub()
	{
		my_Mutex->lock();
		count--;
		my_Mutex->unlock();
	}
	
	int get() const
	{
		return count;
	}
	
private:
	mutex* my_Mutex;
	int count;
};

使用原子变量实现多线程安全保障

count使用原子变量来实现线程安全

class Counter
{
public:
	Counter()
	{
		count = 1;	
	}
	
	void add()
	{
		count++;
	}
	
	void sub()
	{
		count--;
	}
	
	int get() const
	{
		return count;
	}
	
private:
	std::atomic<int> count;
};

全部代码:

#include<iostream>
#include<atomic>

using namespace std;

class Counter
{
public:
	Counter()
	{
		count = 1;	
	}
	
	void add()
	{
		count++;
	}
	
	void sub()
	{
		count--;
	}
	
	int get() const
	{
		return count;
	}
	
private:
	std::atomic<int> count;
};

template <typename T>
class Sp
{
public:
	Sp();                           //默认构造函数
	Sp(T *ptr);                     //参数构造函数
	Sp(const Sp &obj);              //复制构造函数
	~Sp();                          //析构函数
	Sp &operator=(const Sp &obj);   //重载=
	T *get();                       //得到共享指针指向的类
	   
	int getcount();                 //得到引用计数器
private:
	T *my_ptr;                      //共享指针所指向的对象
	Counter* counter;                   //引用计数器
	void clear();                   //清理函数
};

//默认构造函数,参数为空,构造一个引用计数器
template<typename T>
Sp<T>::Sp()
{
	my_ptr = nullptr;
	counter = new Counter();
	counter->add();
}

//复制构造函数,新的共享指针指向旧的共享指针所指对象
template<typename T>
Sp<T>::Sp(const Sp &obj)
{
    //将所指对象也变为目标所指的对象
	my_ptr = obj.my_ptr;
    //获取引用计数器,使得两个共享指针用一个引用计数器
	counter = obj.counter;
    //使这个对象的引用计数器+1
	counter->add();	
};

//重载=
template<typename T>
Sp<T> &Sp<T>::operator=(const Sp&obj)
{
    //清理当前所引用对象和引用计数器
	clear();
    //指向新的对象,并获取目标对象的引用计数器
	my_ptr = obj.my_ptr;
	counter = obj.counter;
    //引用计数器+1
	counter->add();
    //返回自己
	return *this;	
}

//创建一个共享指针指向目标类,构造一个新的引用计数器
template<typename T>
Sp<T>::Sp(T *ptr)
{
	my_ptr = ptr;
	counter = new Counter();
}

//析构函数,出作用域的时候,调用清理函数
template<typename T>
Sp<T>:: ~Sp()
{
	clear();
}

//清理函数,调用时将引用计数器的值减1,若减为0,清理指向的对象内存区域
template<typename T>
void Sp<T>::clear()
{
    //引用计数器-1 
	counter->sub();
    //如果引用计数器变为0,清理对象
	if(0 == counter->get())
	{
		if(my_ptr)
		{
			delete my_ptr;
		}
		delete counter;
	}
}

//当前共享指针指向的对象,被几个共享指针所引用
template<typename T>
int Sp<T>::getcount()
{
	return counter->get();	
};

class A{
public:
	A()
	{
		cout<<"A construct!"<<endl;
	};
	~A()
	{
		cout<<"A destruct!"<<endl;
	};
};


int main()
{
	cout<<"start"<<endl;
    { 
      	//创建共享指针sp指向新创建的对象A 
	    Sp<A> sp(new A);
        cout<<sp.getcount()<<endl;
	    {
	  		//创建共享指针sp2指向A,这时有两个共享指针指向A
	    	Sp<A> sp2 = sp;
            cout<<sp.getcount()<<endl;
		}
	    cout<<sp.getcount()<<endl;
	}
    //出了作用域后,引用计数器-1,此时对象被析构
    cout<<"over"<<endl;
}

  • 10
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
shared_ptr是一种智能指针,它是C++11引入的一种新特性。shared_ptr的设计思路是利用三个主要组件来实现智能指针的功能:一块空间、计数器和锁。 首先,shared_ptr通过一块堆空间来存储所指向的对象。这个堆空间是由shared_ptr自动管理的,当最后一个指向对象的shared_ptr被销毁时,这块空间会被释放。 其次,shared_ptr使用一个计数器来记录当前有多少个shared_ptr共享一个对象。每当有一个新的shared_ptr指向对象时,计数器就会加1;当有一个shared_ptr被销毁时,计数器就会减1。当计数器为0时,表示没有任何shared_ptr指向对象,此时对象会被释放。 最后,shared_ptr还使用锁来确保多线程环境下的安全访问。由于shared_ptr是可以被多个指针共享的,因此在多线程环境中,可能存在多个线程同时操作同一个shared_ptr。为了避免竞争条件,shared_ptr内部使用了锁来保证多线程操作的原子性和线程安全性。 总结起来,shared_ptr实现了智能指针的功能,通过一块空间、计数器和锁来管理所指向对象的生命周期。它可以跟踪对象的引用计数,并在最后一个shared_ptr被销毁时自动释放对象。同时,shared_ptr还具备多线程安全的特性,可以在多线程环境下使用。 参考文献: 前面介绍的auto_ptr和unique_ptr都存在着些许的缺陷,显得不是那么的“智能”,下面我们来看一下较为智能的shared_ptr的设计思路(一块空间、计数器、锁) 主要介绍了C++11新特性之智能指针,包括shared_ptr, unique_ptr和weak_ptr的基本使用,感兴趣的小伙伴们可以参考一下 这是因为weak_ptr是一种不控制所指向对象生存期的智能指针,它指向由一个shared_ptr管理的对象。将一个weak_ptr绑定到shared_ptr不会改变shared_ptr的引用计数。一旦最后一个指向对象的shared_ptr被销毁,对象就会被释放。即使weak_ptr指向对象,对象也会被释放。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值