C++编程经验（9）：智能指针 -- 裸指针管得了的我要管，裸指针管不了的我更要管！
C++编程经验（9）：智能指针 -- 裸指针管得了的我要管，裸指针管不了的我更要管！
文章目录
智能指针介绍
智能指针是存储指向动态分配（堆）对象指针的类。除了能够在适当的时间自动删除指向的对象外，他们的工作机制很像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();
}
}