C++编程经验:智能指针 -- 裸指针管得了的我要管,裸指针管不了的我更要管!

Posted 看,未来

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C++编程经验:智能指针 -- 裸指针管得了的我要管,裸指针管不了的我更要管!相关的知识,希望对你有一定的参考价值。

智能指针介绍

智能指针是存储指向动态分配(堆)对象指针的类。除了能够在适当的时间自动删除指向的对象外,他们的工作机制很像C++的内置指针。智能指针在面对异常的时候格外有用,因为他们能够确保正确的销毁动态分配的对象。他们也可以用于跟踪被多用户共享的动态分配对象。
事实上,智能指针能够做的还有很多事情,例如处理线程安全,提供写时复制,确保协议,并且提供远程交互服务。有能够为这些ESP (Extremely Smart Pointers)创建一般智能指针的方法,但是并没有涵盖进来。
智能指针的大部分使用是用于生存期控制,阶段控制。它们使用operator->和operator*来生成原始指针,这样智能指针看上去就像一个普通指针。


手写智能指针

先来个例子对着看,不然对着空气我也尴尬。

#include<iostream>

using namespace std;

template<class T>
class smart_ptr {
public:
	smart_ptr(T* ptr = nullptr){
		mptr = ptr;
	}

	~smart_ptr() {
		delete mptr;
	}
private:
	T* mptr;
};

int main() {

	/*
		int* p = new int;
		delete p;
		本来是这样写的吧
	*/

	smart_ptr<int> sp(new int);		//现在这样写就好了

	return 0;
}

这个栈上构造的对象一出作用域就会自动被析构掉,指针也就释放了。

既然我们现在要以这个类对象作为新的指针对象,那么就有这么一句很经典的话可以套进来了:“裸指针管得了的我要管,裸指针管不了的我更要管!”

所以这个类应该被丰富一下。

template<class T>
class smart_ptr {
public:
	smart_ptr(T* ptr = nullptr){
		mptr = ptr;
	}

	~smart_ptr() {
		delete mptr;
	}

	T& operator*() { 
		return *(this->mptr);
	}

	T* operator->() {
		return this->mptr;
	}
	
private:
	T* mptr;
};

int main() {

	smart_ptr<int> sp(new int);		//现在这样写就好了

	*sp = 20;

	cout << *sp << endl;
	return 0;
}

不带引用计数的智能指针

上面这个代码就是不带引用计数的,那么它暴露出什么问题来了呢?

int main() {

	smart_ptr<int> sp(new int);		//现在这样写就好了
	smart_ptr<int> ps(sp);

	return 0;
}

这就崩溃了。为什么呢?因为在出作用域的时候,ps先析构了,把资源释放了;而轮到sp要析构的时候,就没有资源可以析构了。

析构之后置空?有用吗?并没有。

	~smart_ptr() {
		delete mptr;
		mptr = nullptr;
	}

问题在于这是个浅拷贝。

那去写个深拷贝?有用的。把资源拷贝到另一块空间,析构的时候,你走你的,我走我的。但是,这不就违背了我们最原始的初衷了吗?裸指针能做的,智能指针都要能做,那裸指针可以这样直接的复制后管的还是一块资源,智能指针就不行了?

那,怎么办?


升级手写的智能指针

带引用计数的智能指针:shared_ptr 和 weak_ptr,可以使多个智能指针管理同一个资源,实现方式:给每一个对象资源匹配一个引用计数。

#include<iostream>

using namespace std;

template<class TT>
class Refcnt {
	//对资源进行引用计数的类

public:
	Refcnt(TT* ptr = nullptr) {
		mptr = ptr;
		if (mptr) {
			mcount = 1;
		}
	}

	void addRef() {
		mcount++;
	}

	int delRef() {
		return --mcount;
	}
private:
	TT* mptr;
	int mcount;
};


template<class T>
class smart_ptr {
public:
	smart_ptr(T* ptr = nullptr){
		mptr = ptr;
		mRefCnt = new Refcnt<T>(mptr);
	}

	~smart_ptr() {
		if (0 == mRefCnt->delRef()) {
			delete mptr;
			mptr = nullptr;
		}
	}

	T& operator*() { 
		return *(this->mptr);
	}

	T* operator->() {
		return this->mptr;
	}

	smart_ptr(const smart_ptr<T>& ptr) {
		mptr = ptr.mptr;
		mRefCnt = ptr.mRefCnt;

		if (mptr != nullptr) {
			mRefCnt->addRef();
		}
	}

	smart_ptr<T>& operator=(smart_ptr<T> &ptr) {
		if (this == &ptr) {
			return *this;
		}

		//要走之前,要先判断一下自己原先的资源有没有人接管
		if (0 == mRefCnt->delRef()) {
			delete mptr;
		}

		mptr = ptr.mptr;
		mRefCnt = ptr->mRefCnt;
		mRefCnt->addRef();

		return *this;
	}

private:
	T* mptr;	//指向资源
	Refcnt<T>* mRefCnt;	//指向引用计数
};

int main() {

	smart_ptr<int> sp(new int);		//现在这样写就好了
	smart_ptr<int> ps(sp);

	return 0;
}

智能指针的循环引用问题

强智能指针

使用引用计数的指针有:shared_ptr 和 weak_ptr,一个称为强智能指针,一个称为若智能指针。
强智能指针可以改变资源的引用计数,弱智能指针不会。

我们前面写的那个就是简化版的强智能指针。

但是呢,强智能指针有个很严重的问题,叫做循环引用,或者说“交叉引用”,这么说会不会比较明显点。

#include<iostream>
#include<memory>

using namespace std;

class B;

class A {
public:
	A() {
		cout << "A" << endl;

	}

	~A() {
		cout << "~A" << endl;
	}

	shared_ptr<B> _ptrb;
};

class B {
public:
	B() {
		cout << "B" << endl;

	}

	~B() {
		cout << "~B" << endl;
	}

	shared_ptr<A> _ptra;
};

int main() {

	shared_ptr<A> pa(new A());
	shared_ptr<B> pb(new B());

	cout << pa.use_count() << endl;
	cout << pb.use_count() << endl;

	//到这之前都很正常

	//pa->_ptrb = pb;
	//pb->_ptra = pa;

	return 0;
}
A
B
1
1
~B
~A

那我现在把那两行放出来运行呢?

int main() {

	shared_ptr<A> pa(new A());
	shared_ptr<B> pb(new B());


	//到这之前都很正常

	pa->_ptrb = pb;
	pb->_ptra = pa;

	cout << pa.use_count() << endl;
	cout << pb.use_count() << endl;

	return 0;
}
A
B
2
2

智能指针没有被正确的析构掉,那还能叫智能指针吗?


弱智能指针

从上面的实验我们得出一个结论:在使用对象的时候,使用强智能指针;在引用对象的时候,使用弱智能指针。

怎么得出的呢?总不能说强智能指针不好用了就用弱的吧,主要是弱智能指针不改变计数,但是其实就相当于是一个观察者,对对象其实没有权限的。

改一下上面的代码,把类中的强智能指针改成弱的。再运行就正常。


弱智能指针升级为强智能指针

接下来是不是就要问这个问题嘞?

类B里面去调用类A里面的一个方法,看看行不行。

	void testB() {
		_ptra->testA();
	}

很显然,是不行的。因为弱智能指针只会观察强指针。

那要用的时候怎么办呢?升级:

	void testB() {
		shared_ptr<A> ps = _ptra.lock();	//就是内个锁
		if (ps != nullptr) {	//看一下资源是否还在
			ps->testA();
		}
	}

多线程访问共享对象

在muduo库中多次使用了强弱智能指针

看一下普通指针在线程中的表现:

void handler(A* q) {

	std::this_thread::sleep_for(std::chrono::seconds(2));
	q->testA();
}

int main() {

	A* p = new A();
	thread t1(handler, p);

	delete p;

	t1.join();
	return 0;
}

这里问题就出来了,我先定义了一个线程,然后让线程休眠两秒,不过在主线程之中将这个指针给回收了,但是依然是在子线程中调用了 testA 的方法!!!

A
~A
A中的方法

再拿弱智能指针对比一下:

void handler(weak_ptr<A> q) {

	//在使用智能指针的时候,要侦测指针是否存活
	shared_ptr<A> sp = q.lock();
	if (sp != nullptr) {
		sp->testA();
	}
	else {
		cout << "A对象已被析构" << endl;
	}
}

int main() {
	//加个作用域,让智能指针出作用域就析构掉
	{
		shared_ptr<A> p(new A());
		thread t1(handler, weak_ptr<A>(p));
		std::this_thread::sleep_for(std::chrono::seconds(2));	//可以试试这行屏蔽了再运行看看
		t1.detach();
	}
}

以上是关于C++编程经验:智能指针 -- 裸指针管得了的我要管,裸指针管不了的我更要管!的主要内容,如果未能解决你的问题,请参考以下文章

c++ 中啥样的指针是裸指针,参数可以是智能指针的引用吗,求高手举例指教

C++ 智能指针性能

c++使用裸指针与智能指针返回数组详解

C++智能指针

C++智能指针讲解及模拟实现

C++ 智能指针 shared_ptr 分析