C++智能指针的使用和仿写(auto_ptr、unique_ptr、shared_ptr、weak_ptr)(详解)

本博客主要记录以下内容:
1.auto_ptr(包括使用讲解和仿写)
2.unique_ptr(包括使用讲解和仿写)
3.shared_ptr(包括使用讲解和仿写)
4.weak_ptr(包括使用讲解和仿写)

一、auto_ptr

1.auto_ptr的使用和讲解

使用示例及讲解:

int main()
{
     
	int* p = new int(10);
	//auto_ptr a_ptr1 = p;//不允许让普通指针为实参,进行隐式构造
	auto_ptr<int> a_ptr1(p);
	//delete p;//error 这句代码没错,会执行,但是对象a_ptr1的生存期到了之后调用析构函数时,会崩溃
	//原因是p和a_ptr1指向同一个堆空间,delete p释放了该空间,但是a_ptr1的析构函数会对该空间进行再次释放,就会崩溃
	//如下a_ptr1.get()是获取对象a_ptr1的指针成员变量
	cout << "a_ptr1拥有的堆空间的首地址:" << a_ptr1.get() << "\t        "  << "p指向的堆空间的首地址:" << p << endl;
	//发现a_ptr1和p指向同一个堆空间,所以为了避免重复释放堆空间引起的崩溃问题,一般会执行以下操作:
	//auto_ptra_ptr1(p);	p = NULL;即让裸指针失去对堆空间的拥有权

	auto_ptr<int>a_ptr2 = a_ptr1;//允许隐式构造,a_ptr1的资源被转移给a_ptr2,a_ptr1失去对资源的拥有权
	//auto_ptra_ptr3(a_ptr1);//用这句代替上句代码当然也可以,这个是显示构造
	cout << "a_ptr1拥有的资源的首地址:" << a_ptr1.get() << "\t        " << "a_ptr2拥有的资源的首地址:" << a_ptr2.get() << endl;
	//发现a_ptr2拥有的资源的首地址就是一开始的时候a_prt1拥有的资源的首地址
	//执行这句操作后,发现对象a_ptr1不再对资源有拥有权,a_ptr1的指针成员变量指向NULL
	//所以这句代码是将a_ptr1拥有的资源转让给a_ptr2,a_ptr1失去对资源的拥有权,指针成员变量指向NULL

	//auto_ptra_ptr3(p);//这句代码语法没错,但是这样会造成a_ptr3也指向p指向的资源的首地址
	//但是a_ptr2也指向这块资源,这样的话a_ptr2和a_ptr3就会指向同一个资源
	//对象生存期到了之后a_ptr2和a_ptr3都会调用析构函数,都会对拥有的资源进行delete释放,会引发对一个堆空间多次释放的问题,会导致程序崩溃
	//所以为了从源头避免这个问题,当用p构造一个auto_ptr指针对象之后,就应该立即执行p = NULL,让p失去对资源的拥有权


	//成员函数的使用
	int* pp = a_ptr2.get();//a_ptr2.get()是将a_ptr2的成员指针变量以临时指针变量的形式返回
	cout << "pp指向的堆空间的首地址:" << pp << endl;//这个时候pp存放的堆空间的首地址和a_ptr2的拥有的资源的首地址一样
	//a_ptr2.reset();//将a_ptr2拥有的资源释放,a_ptr2的成员指针变量指向NULL
	int* q = a_ptr2.release();//返回资源的首地址,将a_ptr2的指针成员变量指向NULL(注意:只是a_ptr2失去对资源的拥有权,但是并没有释放资源)
	cout << "a_ptr2的成员指针变量指向的空间:" << a_ptr2.get() << "\t" << "q指向的资源的首地址:" << q << endl;
	cout << "q指向的资源的内容:" << *q << endl;//输出10
	//没有对bool运算符的重载,后面讲述的指针有对bool运算符的重载
	
	
	cout << "/" << endl;
	int* x = new int(100);
	auto_ptr<int>a_p1(x);
	cout << "a_p1拥有的资源的首地址:" << a_p1.get() << endl;

	int* y = new int(200);
	auto_ptr<int>a_p2(y);
	cout << "a_p2拥有的资源的首地址:" << a_p2.get() << endl;

	a_p1 = a_p2;
	cout << "a_p1拥有的资源的首地址:" << a_p1.get() << endl;
	cout << "a_p2拥有的资源的首地址:" << a_p2.get() << endl;
	cout << "a_p1原本的资源的内容:" << *x << endl;//会输出随机值,因为原本的资源已经被释放了
	//会先对a_p1拥有的资源进行释放,然后将a_p2的资源转让给a_p1
	//然后让a_p2的成员指针变量指向NULL,即让a_p2失去对资源的拥有权
	


	//对智能指针进行仿写的时候,发现我一直以来的错误观点
	//我一直以为对一个指向NULL的指针delete会崩溃,后来发现对一个指向NULL的指针delete,不会发生错误
}

运行结果:
C++智能指针的使用和仿写(auto_ptr、unique_ptr、shared_ptr、weak_ptr)(详解)_第1张图片

auto_ptr总结:

关于构造和赋值:
(1)不允许以裸指针为实参对auto_ptr指针进行隐式构造,只允许裸指针对auto_ptr进行显示的构造。允许用auto_ptr类型的对象对auto_ptr类型的对象进行隐式构造和显示构造,但是构造之后,资源拥有权会转移给新构造出来的auto_ptr对象,以前的对象不再有资源的拥有权。
(2)不要用裸指针对多个智能指针进行构造,否则会引发堆空间被多次释放,程序崩溃。
为了避免因为同一个裸指针构造多个auto_ptr对象而引发堆空间重复释放程序崩溃的问题,在构造之后,将裸指针置空。
(3)用一个auto_ptr对象给另一个auto_ptr对象进行赋值操作的时候,后者如果本身拥有资源,那么会先将后者本身的资源进行释放,然后前者的资源给后者,再将前者的成员指针变量置空,让前者失去对资源的拥有权。

关于auto_ptr的成员函数:
(1)get()函数返回对象的成员指针变量(即资源的首地址)。
(2)reset()函数将对象的资源释放,将对象的成员指针变量置NULL。
(3)release()函数将对象拥有的资源的首地址返回,将成员指针变量指向NULL(即让对象失去资源的拥有权,返回资源的首地址,并没有释放资源)。

2.auto_ptr部分功能的仿写

#ifndef MAUTO_PTR_H
#define MAUTO_PTR_H

template<typename T>
class Mauto_ptr
{
     
public:
	explicit Mauto_ptr(const T*& ptr = NULL)//explicit关键字是告诉编译器不允许用裸指针隐式构造
	{
     
		_ptr = ptr;//新对象获取裸指针的资源(注意没有将裸指针置NULL,所以原指针和新对象共享资源)
	}

	Mauto_ptr(Mauto_ptr& src)//拷贝构造函数
	{
     
		_ptr = src._ptr;  //新对象获取资源的拥有权
		src._ptr = NULL;//传进来的实参失去对资源的拥有权
	}

	~Mauto_ptr()
	{
     
		delete _ptr;//如果_ptr == NULL,这句代码也不会出错
	}

	T* get()//返回成员指针变量(该成员指针变量保存资源的首地址)
	{
     
		return _ptr;
	}
	T* release()//失去资源的拥有权,返回资源的首地址(注意该操作并没有释放资源)
	{
     
		T* tmp = _ptr;
		_ptr = NULL;//失去对资源的拥有权
		return tmp;  //返回资源的首地址
	}
	void reset()//将拥有的资源释放,成员指针变量置空
	{
     
		delete _ptr;  //释放拥有的资源
		_ptr = NULL;//成员指针变量置空
	}



	//=、*、->  运算符重载
	Mauto_ptr& operator=(Mauto_ptr& src)//赋值运算符重载
	{
     
		if (this == &src)//如果自己给自己赋值,那么什么都不做,返回本身
		{
     
			return *this;
		}
		_ptr = src._ptr;//新对象获取资源的拥有权
		src._ptr = NULL;//传进来的实参失去对资源的拥有权
		return *this;
	}
	T& operator*()
	{
     
		return *_ptr;
	}

	T* operator->()
	{
     
		return _ptr;
	}
private:
	T* _ptr;//成员指针变量,保存资源的首地址,即指向对象拥有的资源
};

#endif

二、unique_ptr的使用

1.unique_ptr的使用和讲解

使用示例及讲解:

unique_ptr<int> fun()//如果有形参,参数必须是引用(指针),否则形参涉及拷贝构造,unique_ptr不允许
{
     
	return unique_ptr<int>(new int(100));//OK,临时对象
}

int main()
{
     
	int* p = new int(10);
	//unique_ptr u_ptr1 = p;//不允许隐式构造
	unique_ptr<int> u_ptr1(p);
	cout << "u_ptr1拥有的堆空间的首地址:" << u_ptr1.get() << "\t" << "p指向的堆空间的首地址:" << p << endl;
	//发现u_ptr1和p指向同一个堆空间,所以为了避免重复释放堆空间引起的崩溃问题,一般会执行以下操作:
	//unique_ptru_ptr1(p);	p = NULL;即让裸指针失去对堆空间的拥有权
	//delete p;//error 这句代码没错,会执行,但是对象u_ptr1的生存期到了之后调用析构函数时,会崩溃,因为有对一个堆空间重复释放的问题
	//不允许用一个裸指针对多个unique_ptr进行赋值或者拷贝构造等和资源有关的操作
	//因为每一个unique_ptr对象生存期到了之后,都会对拥有的资源进行释放,会发生对同一个堆空间重复释放的问题,程序会崩溃
	//所以任何造成“让多个unique_ptr指向同一个资源的”结果的操作,都要避免,否则就会对一个堆空间重复释放,程序会崩溃

	
	//unique_ptru_ptr2 = u_ptr1;//error,不允许隐式构造
	//unique_ptru_ptr2(u_ptr1);//error,不允许普通的拷贝构造

	//unique_ptru_ptr2 = fun();//OK,允许用右值进行隐式拷贝构造
	/*//OK,允许用右值对unique_ptr进行赋值操作
	unique_ptru_ptr2;//OK
	u_ptr2 = fun();//OK
	*/
	
	unique_ptr<int>u_ptr2(fun());//OK,允许用右值(在这里是即将销毁的临时对象)为实参拷贝构造
	cout << "u_ptr2拥有的堆空间的首地址:" << u_ptr2.get() << "\t" << "u_ptr2的资源的内容为:" << *u_ptr2 << endl;
	//u_ptr2 = u_ptr1;//error,不允许unique_ptr类型的对象之间的赋值操作

	//成员方法:
	//get()会返回对象的成员指针变量(以临时存在的方式返回)
	cout << "u_ptr1拥有的资源的首地址:" << u_ptr1.get() << endl;
	//reset()会将对象拥有的资源释放,成员指针变量置空
	//release()会将对象的成员指针变量置空,返回资源的首地址(并没有释放资源,只是失去对资源的拥有权)
	//int*q =  u_ptr1.release();//OK,注意,在这里是以成员指针变量的类型返回,这里是int*
	unique_ptr<int>u_ptr3(u_ptr1.release());
	cout << "u_ptr1拥有的堆空间的首地址:" << u_ptr1.get() << "\t" << "u_ptr3拥有的堆空间的首地址:" << u_ptr3.get() << endl;
	//operator bool;对bool运算符进行了重载,可以根据以下语句判断u_ptr1是否拥有资源
	if (u_ptr1) {
      cout << "u_ptr1有资源" << endl; }
	else {
      cout << "u_ptr1没有资源" << endl; }

	cout << "swap()//" << endl;
	//swap()//将对象拥有的资源交换
	cout << u_ptr2.get() << "    " << u_ptr3.get() << endl;
	u_ptr2.swap(u_ptr3);
	cout << u_ptr2.get() << "    " << u_ptr3.get() << endl;
	
	//=运算符重载
	u_ptr3 = fun();//右值赋值给unique_ptr类型的指针,但是u_ptr3原来的资源并没有被释放
	cout << "u_ptr3拥有的资源的首地址:" << u_ptr3.get() << "\t" << "u_ptr3的资源的内容为:" << *u_ptr3 << endl;
	//注意u_ptr2也是用fun()构造的,但是u_ptr2和u_ptr3的资源不一样,请参考博客右值引用的实质。
	cout << "访问u_ptr3原本的资源内容:" << *p << endl;//注意u_ptr3被fun()赋值之前拥有的资源和p指向的堆空间是同一个
	//上面这句代码输出成功,说明fun()赋值给u_ptr3,u_ptr3并没有把原来拥有的资源释放
	
	
	return 0;
}

C++智能指针的使用和仿写(auto_ptr、unique_ptr、shared_ptr、weak_ptr)(详解)_第2张图片
unique_ptr总结:
关于构造和赋值:
(1)对于两个unique_ptr的对象(非右值)来说,unique_ptr杜绝了两个unique_ptr对象之间的操作(包括赋值和拷贝构造)。
(2)对于右值和unique_ptr的对象来说,允许右值和unique_ptr对象之间的操作,包括用右值拷贝构造(隐式也可以),用右值赋值。但是用右值给unique_ptr对象赋值时,如果unique_ptr原本有资源,那么原本的资源不会被释放。
(3)对于裸指针和unique_ptr的对象来说,用裸指针构造unique_ptr对象之后,裸指针仍旧指向资源,所以要注意不要用同一个裸指针构造多个unique_ptr对象,否则每个unique_ptr对象生存期到了之后,都会调用析构对象释放堆空间,会造成一个堆空间被重复释放,导致程序崩溃。所以为了误操作,用裸指针构造了unique_ptr对象之后,最好将裸指针置空。不允许用裸指针隐式构造unique_ptr对象,必须用显示构造。不允许裸指针对unique_ptr进行赋值操作。

关于unique_ptr的成员函数:
(1)get()函数返回对象的成员指针变量(即资源的首地址)
(2)reset()函数将对象的资源释放,将对象的成员指针变量置NULL
(3)release()函数将对象拥有的资源的首地址返回,将成员指针变量指向NULL(即让对象失去资源的拥有权,返回资源的首地址,并没有释放资源)
(4)operator boo;unique_ptr对bool运算符进行了重载,成员指针指向NULL则返回假,代表没资源;成员指针指向资源则为真,代表有资源
(5)unique_ptr释放资源用的是deleter,deleter会自动识别这个资源是应该用delete释放好还是用delete[]释放好。

2.unique_ptr部分功能的仿写

#ifndef MUNIQUE_PTR_H
#define MUNIQUE_PTR_H

template<typename T>
class Munique_ptr
{
     
public:
	explicit Munique_ptr(T* ptr = NULL)//允许裸指针显示构造
	{
     
		_ptr = ptr;
	}
	//右值引用--只能用来引用即将死亡的对象
	Munique_ptr(const Munique_ptr&& src)//允许用右值属性的对象拷贝构造
	{
     
		_ptr = src._ptr;
		src._ptr = NULL;
	}
	Munique_ptr& operator=(Munique_ptr&& src)//允许右值对象进行赋值操作,注意并没有将原资源释放
	{
     
		if (this == &src)
		{
     
			return *this;
		}
		_ptr = src._ptr;
		src._ptr = NULL;
		return *this;
	}

	~Munique_ptr()
	{
     
		delete _ptr;
	}
	T* get()
	{
     
		return _ptr;
	}
	T* release()//注意只是失去对资源的拥有权,并没有释放资源
	{
     
		T* tmp = _ptr;
		_ptr = NULL;
		return tmp;
	}
	void reset()
	{
     
		delete _ptr;
		_ptr = NULL;
	}
	T* operator->()
	{
     
		return _ptr;
	}
	T& operator*()
	{
     
		return *_ptr;
	}
	operator bool()
	{
     
		return _ptr != NULL;
	}
private:
	T* _ptr;
};

#endif

三、shared_ptr的使用

1.shared_ptr的使用和讲解

shared_ptr是共享指针,如果一个共享指针拥有的资源可以同时被其他共享指针拥有,指向同一个资源的共享指针共用同一个引用计数,引用计数为几就意味着这个资源被几个共享指针拥有,当有共享指针失去对资源的拥有权时,或者有共享指针生存期到了时,那么这个资源的引用计数就减1,当引用计数为1,就说明这个资源现在只被一个共享指针拥有。当某个共享指针的生存期到了时,同时资源的引用计数为1时(即这个资源只被这一个共享指针拥有时),那么析构函数里才会执行对资源的释放操作。
(注:所有的这些都注意,前提是不能用同一个裸指针同时构造两个共享指针对象,否则会出错,代码中给出示例)
使用示例及讲解:

int main()
{
     
	//use.cout()函数可以获取现在的资源被几个shared_ptr对象拥有

	int* p = new int(10);
	//shared_ptrs_ptr1 = p;//error 不允许隐式构造
	shared_ptr<int>s_ptr1(p);//OK,显示构造
	cout << "s_ptr1的资源的首地址:" << s_ptr1.get() << "\t" << "p指向的空间首地址:" << p << endl;
	cout << "s_ptr1拥有的资源的引用计数为:" << s_ptr1.use_count() << endl;

	shared_ptr<int>s_ptr2;
	//s_ptr2 = p;//error不允许用裸指针赋值
	s_ptr2 = s_ptr1;
	cout<< "s_ptr1的资源的首地址:" << s_ptr1.get() << "\t" << "s_ptr2的资源的首地址:" << s_ptr2.get() << endl;
	cout << "s_ptr1拥有的资源的引用计数为:" << s_ptr1.use_count() << endl;

	shared_ptr<int>s_ptr3(s_ptr2);//允许拷贝构造
	cout << "s_ptr3的资源的首地址:" << s_ptr3.get() << endl;
	cout << "s_ptr1拥有的资源的引用计数为:" << s_ptr1.use_count() << endl;

	s_ptr3.reset();//s_ptr3失去对资源的拥有权,由于引用计数大于1,s_ptr3不对资源进行释放
	cout << "s_ptr3成员指针指向为:" << s_ptr3.get() << endl;
	cout << "s_ptr1拥有的资源的引用计数为:" << s_ptr1.use_count() << endl;

	int* q = new int(100);
	shared_ptr<int>s_ptr4(q);
	cout << "s_ptr1的资源的首地址:" << s_ptr1.get() << "\t" << "和s_ptr4拥有同一个资源的对象的个数:" << s_ptr4.use_count() << endl;

	s_ptr4.swap(s_ptr1);
	cout << "s_ptr1的资源的首地址:" << s_ptr1.get() << "\t" << "s_ptr4的资源的首地址:" << s_ptr4.get() << endl;
	cout << "s_ptr1拥有的资源的引用计数为:" << s_ptr1.use_count() << "\t" << "s_ptr4拥有的资源的引用计数为:" << s_ptr4.use_count() << endl;

	/*
	shared_ptrs_ptr5(q);
	cout << "s_ptr5拥有的资源的首地址:" << s_ptr5.get() << "s_ptr5拥有的资源的引用计数:" << s_ptr5.use_count() << endl;
	*/
	//上面被注释掉的代码会是程序崩溃,原因是我们用q指针构造了两个shared_ptr对象,但是这两个对象拥有的资源的引用计数为1
	//s_ptr1(和s_ptr4交换资源后,s_ptr4拥有的是q指向的资源 )和s_ptr4两个指针都指向p
	//但是它们的资源的引用计数都是1
	//所以它们俩生存期到了之后,会对自己的资源进行释放,同一个资源被释放两次,程序崩溃

	return 0;
}

运行结果:
C++智能指针的使用和仿写(auto_ptr、unique_ptr、shared_ptr、weak_ptr)(详解)_第3张图片

shared_ptr总结:
关于构造和赋值:
(1)不允许裸指针隐式构造shared_ptr对象;允许裸指针显式构造shared_ptr对象。不会修改裸指针的指向。不允许用一个裸指针构造多个shared_ptr对象,因为会造成同一个资源被多个对象拥有,资源的引用计数却少于这些对象的个数,这样会造成对一个堆空间进行重复释放,程序会崩溃。(我们说的一个资源的引用计数为几就代表被几个共享指针拥有,是排除同一个裸指针构造多个共享指针情况后的)。
(2)允许shared_ptr对象之间的赋值。比如s_ptr1 = s_ptr2;
如果s_ptr1的资源被多个共享指针拥有,那么执行完这句代码后,s_ptr1原来的资源的引用计数减1(因为s_ptr1将不再拥有这个资源),s_ptr2拥有的资源的引用计数加1(因为s_ptr1将也会拥有这个资源)。如果s_ptr1的原资源的引用计数为1,即如果只有s_ptr1一个共享指针拥有,那么原资源将会被释放,然后s_ptr2的资源的引用计数加1。(注意,两个共享指针指向同一个资源的话,那么资源的引用计数是同步对这两个指针而言的)。

关于shared_ptr的成员函数:
(1)reset()使对象失去对资源的拥有权,如果资源的引用计数为1(即只被这一个对象拥有),那么会先释放资源,再将成员指针变量置空。如果资源的引用计数大于1(即被多个对象拥有),那么会先将资源的引用计数减一,再将自己的成员指针变量置空。
(2)注意shared_ptr不含有release()函数
(3)swap()函数会将两个对象的资源交换
(4)unique()函数判断对象拥有的资源引用计数是否为1(即是否只被这一个对象拥有)

2.shared_ptr部分功能的仿写

#ifndef MSHARED_PTR_H
#define MSHARED_PTR_H
#include
using namespace std;

//注意,用裸指针构造对象时,我们并没有将资源引用计数记录到map中,
//当我们用这个对象去构造其他对象了,我们才看map有没有记录,有的话,资源引用计数加一,
//没有的话,这才将资源地址添加到map里记录。
//也就是说,拷贝构造时,如果发现资源没有被添加到map里,那么资源肯定只被实参这一个对象拥有,
//且没有用这个实参拷贝构造果其他对象。
template<typename T>
class Mshared_ptr
{
     
public:
	explicit Mshared_ptr(T* ptr = NULL)//explicit关键字限制编译器不允许隐式构造
	{
     
		_ptr = ptr;
	}

	Mshared_ptr(const Mshared_ptr& src)//拷贝构造
	{
     
		if (_count.end() == _count.find(src._ptr))//说明map里没有记录这个资源
		{
     
			_count.insert(make_pair(src._ptr, 1));//先将资源添加进去,以引用计数为1添加
		}
		_ptr = src._ptr;
		_count[_ptr]++;
	}
	Mshared_ptr& operator=(const Mshared_ptr& src)
	{
     
		if (this == &src)//自己对自己赋值,返回原对象
		{
     
			return *this;
		}
		if (unique())//如果被赋值的对象现在拥有的资源只被它一个拥有,释放资源
		{
     
			delete _ptr;
		}
		else//说明资源被多个对象拥有,引用计数--就可以了,不用释放资源
		{
     
			_count[_ptr]--;
		}

		if (_count.end() == _count.find(src._ptr))//说明map里没有将src拥有的资源记录在里面
		{
     
			_count.insert(make_pair(src._ptr, 1));//用map记录资源引用计数
		}
		_ptr = src._ptr;
		_count[_ptr]++;
		return *this;
	}

	~Mshared_ptr()
	{
     
		if (unique())//如果资源引用计数为1,释放资源
		{
     
			delete _ptr;
		}
		else//如果资源被多个共享指针拥有,那么将引用计数减一
		{
     
			_count[_ptr]--;
		}
		_ptr = NULL;
	}
	T* get()
	{
     
		return _ptr;
	}
	void reset()
	{
     
		if (unique())//如果资源只被一个共享指针拥有,释放资源
		{
     
			delete _ptr;
		}
		else//如果资源被多个共享指针拥有,引用计数减1
		{
     
			_count[_ptr]--;
		}
		_ptr = NULL;
	}
	bool unique()
	{
     
		if ((_count.end() == _count.find(_ptr)) || (_count[_ptr] == 1))//如果map里没有记录这个资源(同样代表资源只被一个对象拥有),或者引用计数为1
		{
     
			return true;
		}
		return false;
	}
	int use_count()
	{
     
		if (_count.end() == _count.find(_ptr))//如果map里没有记录这个资源,说明资源只被一个对象拥有,返回1
		{
     
			return 1;
		}
		return _count[_ptr];//否则的话,返回资源的引用计数
	}
	T& operator[](int pos)
	{
     
		return _ptr[pos];
	}
	T& operator*()
	{
     
		return *_ptr;
	}
	T* operator->()
	{
     
		return _ptr;
	}
	operator bool()
	{
     
		return _ptr != NULL;
	}
private:
	T* _ptr;
	static map<T*, int> _count;//存放引用计数,注意map不允许键值重复,所以可以用来记录一个资源的引用计数
};

#endif

四、weak_ptr的使用

1.weak_ptr的使用和讲解

看weak_ptr之前先来看一下shared_ptr存在的问题:
代码:

class B;
class A
{
     
public:
	A() {
      cout << "A构造函数" << endl; }
	~A() {
      cout << "A析构函数" << endl; }
	void fun(shared_ptr<B>& p) {
      a_p = p; }
private:
	shared_ptr<B> a_p;
};

class B 
{
     
public:
	B() {
      cout << "B构造函数" << endl; }
	~B() {
      cout << "B析构函数" << endl; }
	void fun(shared_ptr<A>& p) {
      b_p = p; }
private:
	shared_ptr<A> b_p;
};

int main()
{
     
	A* a = new A();
	B* b = new B();
	shared_ptr<A>s_p1(a);
	shared_ptr<B>s_p2(b);
	cout <<"s_p1拥有的资源的引用计数:" << s_p1.use_count() << endl;
	cout << "s_p2拥有的资源的引用计数:" << s_p2.use_count() << endl;

	a->fun(s_p2);
	b->fun(s_p1);
	cout << "s_p1拥有的资源的引用计数:" << s_p1.use_count() << endl;
	cout << "s_p2拥有的资源的引用计数:" << s_p2.use_count() << endl;

	return 0;
}

运行结果:
C++智能指针的使用和仿写(auto_ptr、unique_ptr、shared_ptr、weak_ptr)(详解)_第4张图片

图形解释:
C++智能指针的使用和仿写(auto_ptr、unique_ptr、shared_ptr、weak_ptr)(详解)_第5张图片

对象a和对象b为被共享指针拥有的资源,可以看见对象a被s_p1和对象b内的shared_ptr < A >拥有,所以对象a(资源a)的引用计数为2。同理,对象b被s_p2和对象a内的shared_ptr < B >拥有,所以对象b(资源b)的引用计数为2。当shared_ptr< A >s_p1和shared_ptr< B >s_p1的生存期到了之后,由于资源的引用计数都是2,所以资源a和资源b并不会被释放。这个原因就是因为它们内部的共享指针都指向对方。形成了一个环,使对方作为资源的时候,引用计数都加1了。
C++智能指针的使用和仿写(auto_ptr、unique_ptr、shared_ptr、weak_ptr)(详解)_第6张图片

当然,可以手动释放对象a或者对象b,但是前面三个指针都谈过,用指向堆空间的指针构造智能指针时,不要再对这个指针进行delete操作了,因为智能指针的诞生就是为了解决对资源自行管理,如果我们再自行delete堆空间,非常容易造成对一个堆空间多次释放,程序崩溃。对于上面的代码是例外,因为sared_ptr解决不了这个环的问题,我们只是测试一下手动delete,平常将资源赋给智能指针之后,一定不要自己手动delete资源。我们在这里尝试自己手动delete掉没有被释放的资源,看一下结果。(后面的weak_ptr的使用才是正常解决方案)
代码1(在主函数末尾添加delete a;):
运行结果:
C++智能指针的使用和仿写(auto_ptr、unique_ptr、shared_ptr、weak_ptr)(详解)_第7张图片
注意:程序执行错误,只不过没有崩溃而已。退出码为随机值,这个是错误码,意味着我们操作不对。
A析构函数被调用了两次,也就是a对象被析构两次(这也是为什么返回的是错误码的原因),delete a,会调用a的析构函数,a内部的shared_ptr< B >也会调用析构函数,它指向b,引用计数为1,所以shared_ptr< B >会对b进行delete,所以对象b会被释放,b内部的shared_ptr< A >会调用析构函数,指向对象a,资源a已经自己调用析构函数了,但是资源引用计数在共享指针内部,值为1,所以shared_ptr< A >的内部会进行delete a。所以a调用了两次析构函数。

代码2(在主函数末尾添加delete b;):
运行结果:
C++智能指针的使用和仿写(auto_ptr、unique_ptr、shared_ptr、weak_ptr)(详解)_第8张图片
对于代码2,分析和代码一样的。

代码3(在主函数末尾添加delete a; delete b):
运行结果:
C++智能指针的使用和仿写(auto_ptr、unique_ptr、shared_ptr、weak_ptr)(详解)_第9张图片
对于代码3,执行delete a时候会造成b被析构两次了,delete b的时候,b已经被析构过了,所以空间里也没有东西,也不会调用析构函数了。
总之,不管同一个对象被析构几次,当对同一个对象进行多次析构的时候,不管是几次析构,只要多于一次,不管程序有没有崩溃,这都是赤裸裸的错误。

这个时候就产生了weak_ptr,这个是专门为了shared_ptr服务的。弱指针只允许用shared_ptr类型的对象拷贝构造(因为weak_ptr的诞生就是为了shared_ptr服务的),弱指针内部有个指针成员变量,指向shared_ptr类型,最终也是指向了shared_ptr的资源,但是这个不会使资源的引用计数增加,换句话说,weak_ptr可以像shared_ptr一样共享资源,也和shared_ptr一样可以获取资源的引用计数,但是weaak_ptr本身不会引起资源的引用计数的变化,只有shared_ptr才会。
使用示例及讲解:

int main()
{
     
	//弱指针就是为了解决shared_ptr遗留的问题,循环引用问题,所以weak_ptr就是为了shared_ptr服务的
	//弱指针的构造函数的形参是shared_ptr类型,所以弱指针拷贝构造必须用shared_ptr对象
	int* p = new int(10);
	shared_ptr<int>s_ptr1(p);
	cout << "s_ptr1拥有的资源的引用计数:" << s_ptr1.use_count() << endl;
	//weak_ptr w_ptr1 = s_ptr1;//OK,隐式拷贝构造ye可以
	weak_ptr<int> w_ptr1(s_ptr1);
	cout << "s_ptr1拥有的资源的引用计数:" << s_ptr1.use_count() << endl;
	cout << "w_ptr1拥有的资源的引用计数:" << w_ptr1.use_count() << endl;

	weak_ptr<int>w_ptr2(s_ptr1);
	cout << "s_ptr1拥有的资源的引用计数:" << s_ptr1.use_count() << endl;
	cout << "w_ptr2拥有的资源的引用计数:" << w_ptr2.use_count() << endl;

	int* q = new int(100);
	shared_ptr<int>s_ptr2;
	weak_ptr<int>w_ptr3(w_ptr1);
	cout << "w_ptr1拥有的资源的引用计数:" << w_ptr1.use_count() << endl;
	cout << "w_ptr3拥有的资源的引用计数:" << w_ptr3.use_count() << endl;

	s_ptr2 = s_ptr1;
	cout << "s_ptr1拥有的资源的引用计数:" << s_ptr1.use_count() << endl;
	cout << "s_ptr2拥有的资源的引用计数:" << w_ptr1.use_count() << endl;
	cout << "w_ptr1拥有的资源的引用计数:" << w_ptr1.use_count() << endl;
	cout << "w_ptr2拥有的资源的引用计数:" << w_ptr2.use_count() << endl;
	cout << "w_ptr3拥有的资源的引用计数:" << w_ptr3.use_count() << endl;

	shared_ptr<int>s_ptr3 = w_ptr1.lock();//将弱智能指针转换为强智能指针
	cout << "s_ptr1拥有的资源的引用计数:" << s_ptr1.use_count() << endl;
	cout << "s_ptr2拥有的资源的引用计数:" << w_ptr1.use_count() << endl;
	cout << "w_ptr1拥有的资源的引用计数:" << w_ptr1.use_count() << endl;
	cout << "w_ptr2拥有的资源的引用计数:" << w_ptr2.use_count() << endl;
	cout << "w_ptr3拥有的资源的引用计数:" << w_ptr3.use_count() << endl;

	return 0;
}

C++智能指针的使用和仿写(auto_ptr、unique_ptr、shared_ptr、weak_ptr)(详解)_第10张图片

weak_ptr总结:
构造和赋值:
(1)为了解决shared_ptr解决不了的循环指向的问题,weak_ptr协助shared_ptr解决。即weak_ptr可以和shared_ptr之间通过强弱指针转换,拥有资源,而weak_ptr不会使资源的引用计数变化。
(2)weak_ptr是为了服务shared_ptr而诞生的,只允许用shared_ptr对其进行拷贝构造。

成员函数:
(1)reset()
(2)赋值运算符重载,允许用shared_ptr和weak_ptr赋值给weak_ptr,不会引起资源的引用计数的变化。
(3)lock()将弱指针转化为强指针(shared_ptr),被强指针接受,资源引用计数加加。前提是该弱指针内部成员指针变量指向的强指针还存在。
用weak_ptr解决shared_ptr的循环指向问题,上面问题由于对象a和对象b的引用计数都为2,导致没办法析构,让其中一个为1就好了,这样这个对象就会被释放,内部指针指向的另一个对象由于资源引用计数为1,另一个对象也会被释放。将A类或者B类中的一个shared_ptr修改为弱指针就好了。
代码1(将A类中的设置为弱指针):

class B;
class A
{
     
public:
	A() {
      cout << "A构造函数" << endl; }
	~A() {
      cout << "A析构函数" << endl; }
	void fun(shared_ptr<B>& p) {
      a_p = p; }
private:
	weak_ptr<B> a_p;//注意这里是弱指针
};

class B 
{
     
public:
	B() {
      cout << "B构造函数" << endl; }
	~B() {
      cout << "B析构函数" << endl; }
	void fun(shared_ptr<A>& p) {
      b_p = p; }
private:
	shared_ptr<A> b_p;
};

int main()
{
     
	A* a = new A();
	B* b = new B();
	shared_ptr<A>s_p1(a);
	shared_ptr<B>s_p2(b);
	cout <<"s_p1拥有的资源的引用计数:" << s_p1.use_count() << endl;
	cout << "s_p2拥有的资源的引用计数:" << s_p2.use_count() << endl;

	a->fun(s_p2);
	b->fun(s_p1);
	cout << "s_p1拥有的资源的引用计数:" << s_p1.use_count() << endl;
	cout << "s_p2拥有的资源的引用计数:" << s_p2.use_count() << endl;
	

	return 0;
}

C++智能指针的使用和仿写(auto_ptr、unique_ptr、shared_ptr、weak_ptr)(详解)_第11张图片
图形分析:
C++智能指针的使用和仿写(auto_ptr、unique_ptr、shared_ptr、weak_ptr)(详解)_第12张图片
注意weak_ptr< B >a_ptr指向shared_ptr< B >s_p2,这是因为weak_ptr内部是一个指针变量,指向的是shared_ptr类型的对象那个(在最后的仿写代码中可以看出来)。
s_p1和s_p2中,s_p2后构造的,先析构s_p2(栈中的对象,先构造的后析构,后构造的先析构),s_p2拥有资源b,资源b的引用计数为1,所以s_p2析构函数中对资源b进行释放,即delete b,b会调用析构函数析构,b对象里的b_ptr也会析构,b_ptr调用析构函数,由于b_ptr拥有资源a,资源a的引用计数为2,所以b_ptr析构函数里只是将资源a的引用计数减减,变为1;s_p1析构,拥有资源a,资源a引用计数为1,所以s_p1的析构函数中会对资源a进行释放,即delete a,所以会执行a的析构函数析构a,对象a中的a_ptr是弱指针,调用默认析构函数析构。
同理,如果是把B类中的shared_ptr指针设为弱指针的话,那么同样分析,就会调用a的析构函数,然后调用b的析构函数。下面将代码和运行结果和图形分析给出:
代码2(将类B中的shared_ptr设置为weak_ptr):

class B;
class A
{
     
public:
	A() {
      cout << "A构造函数" << endl; }
	~A() {
      cout << "A析构函数" << endl; }
	void fun(shared_ptr<B>& p) {
      a_p = p; }
private:
	shared_ptr<B> a_p;
};

class B 
{
     
public:
	B() {
      cout << "B构造函数" << endl; }
	~B() {
      cout << "B析构函数" << endl; }
	void fun(shared_ptr<A>& p) {
      b_p = p; }
private:
	weak_ptr<A> b_p;//注意这里是弱指针
};

int main()
{
     
	A* a = new A();
	B* b = new B();
	shared_ptr<A>s_p1(a);
	shared_ptr<B>s_p2(b);
	cout <<"s_p1拥有的资源的引用计数:" << s_p1.use_count() << endl;
	cout << "s_p2拥有的资源的引用计数:" << s_p2.use_count() << endl;

	a->fun(s_p2);
	b->fun(s_p1);
	cout << "s_p1拥有的资源的引用计数:" << s_p1.use_count() << endl;
	cout << "s_p2拥有的资源的引用计数:" << s_p2.use_count() << endl;
	

	return 0;
}

运行结果(注意这里就变成先析构对象a了):
C++智能指针的使用和仿写(auto_ptr、unique_ptr、shared_ptr、weak_ptr)(详解)_第13张图片
图形分析:
C++智能指针的使用和仿写(auto_ptr、unique_ptr、shared_ptr、weak_ptr)(详解)_第14张图片
和代码1分析一样,s_p1和s_p2中,s_p2后构造的,先析构s_p2(栈中的对象,先构造的后析构,后构造的先析构),s_p2拥有资源b,引用计数为2,所以资源b引用计数减减,变为1。s_p1析构,拥有资源a,资源a引用计数为1,所以s_p1析构函数中对资源a进行释放,即delete a,a会调用析构函数析构,a对象里的a_ptr也会析构,由于a_ptr指向资源b,资源b引用计数为1,所以a_ptr析构函数中会对资源进行释放,即delete b,会调用b的析构函数,对象b被析构,对象b内的弱指针b_ptr会调用默认析构函数析构。
代码3(将类A和类B中的shared_ptr都设置为weak_ptr):

class B;
class A
{
     
public:
	A() {
      cout << "A构造函数" << endl; }
	~A() {
      cout << "A析构函数" << endl; }
	void fun(shared_ptr<B>& p) {
      a_p = p; }
private:
	weak_ptr<B> a_p;//弱指针
};

class B 
{
     
public:
	B() {
      cout << "B构造函数" << endl; }
	~B() {
      cout << "B析构函数" << endl; }
	void fun(shared_ptr<A>& p) {
      b_p = p; }
private:
	weak_ptr<A> b_p;//弱指针
};

int main()
{
     
	A* a = new A();
	B* b = new B();
	shared_ptr<A>s_p1(a);
	shared_ptr<B>s_p2(b);
	cout <<"s_p1拥有的资源的引用计数:" << s_p1.use_count() << endl;
	cout << "s_p2拥有的资源的引用计数:" << s_p2.use_count() << endl;

	a->fun(s_p2);
	b->fun(s_p1);
	cout << "s_p1拥有的资源的引用计数:" << s_p1.use_count() << endl;
	cout << "s_p2拥有的资源的引用计数:" << s_p2.use_count() << endl;
	

	return 0;
}

运行结果:
C++智能指针的使用和仿写(auto_ptr、unique_ptr、shared_ptr、weak_ptr)(详解)_第15张图片
图形分析:
C++智能指针的使用和仿写(auto_ptr、unique_ptr、shared_ptr、weak_ptr)(详解)_第16张图片
一样分析,这个比上面两种分析更简单,s_p2后构造的,先析构s_p2,s_p2拥有资源b,资源b引用计数为1,所以在s_p2析构函数中会对资源进行释放,即delete b,所以会执行b的析构函数,所以对象b中的b_ptr也会析构,调用默认析构函数析构。s_p1再析构,s_p1拥有资源a,资源a引用计数为1,所以在s_p1析构函数中会对资源进行释放,即delete a,所以会执行a的析构函数,所以对象a中的a_ptr也会析构,调用默认析构函数析构。

注意:weak_ptr对象不会对资源有任何操作,也不会让资源引用计数有变化,内部是一个成员指针变量指向shared_ptr对象。weak_ptr是用来解决shared_ptr产生的环形指向问题。
注意:lock()成员函数可以将弱指针转化为强指针,即用shared_ptr接收返回值,资源引用计数加加。只有将弱指针用lock()方法转换为强指针,才能进行对资源的操作。

2.weak_ptr的部分功能仿写

#ifndef MWEAK_PTR_H
#define MWEAK_PTR_H
#include"mshared_ptr.h"
template<typename T>
class Mweak_ptr
{
     
public:
	Mweak_ptr(Mshared_ptr<T>& s_p = NULL)
	{
     
		_s_p = &s_p;
	}

	Mshared_ptr<T> lock()//将弱指针转化为强指针
	{
     
		if (_s_p->use_count() == 0)//说明指向的对象没有资源,返回默认构造函数产生的对象
		{
     
			return Mshared_ptr<T>();
		}
		return *_s_p;
	}

	void reset()//只是将weak_ptr对象的_s_p置空,不对资源有任何操作。
	{
     
		_s_p = NULL;
	}

	int use_count()
	{
     
		return _s_p->use_count();
	}
private:
	Mshared_ptr<T>* _s_p;
};

#endif

你可能感兴趣的:(C++,c++)