前言：

Vue框架：从项目学Vue
OJ算法系列：神机百炼 - 算法详解
Linux操作系统：风后奇门 - linux

普通指针：

安全隐患：

其他函数异常：

• 查看下面这段存在异常的函数：

int div(){int a, b;cin >>a >>b;if(b == 0)throw invalid_argument("除0错误");return a/b;
}void func(){int *p = new int;cout<<div() <<endl;delete p;
}
int main(){try{func();}catch(const exception &e){cout<< e.what() <<endl;}return 0;
}

• 异常来源：
  如果div()函数异常，由于不设置try catch机制，申请的p指针无法被delete释放
• 处理策略：try catch

int div(){int a, b;cin >>a >>b;if(b == 0)throw invalid_argument("除0错误");return a/b;
}void func(){int *p = new int;try{cout<<div() <<endl;}catch(const exception &e){cout<< e.what() <<endl;}delete p;
}
int main(){try{func();}catch(const exception &e){cout<< e.what() <<endl;}return 0;
}

new函数异常：

• 多次为指针申请空间，之后统一释放。

  当一次申请出错时，前面所有申请的资源无法释放：

int main(){int *p1 = new int;int *p2 = new int;int *p3 = new int;delete p1;delete p2;delete p3;return 0;
}

• 处理策略：
  1. try + catch
  2. 设置初始值为nullptr，申请失败后值还为nullptr

int main(){int *p1 = nullptr;int *p2 = nullptr;int *p3 = nullptr;try{int *p1 = new int;int *p2 = new int;int *p3 = new int;}catch(...){if(p2 == nullptr)delete p1;if(p3 == nullptr){delete p1;delete p2;}}delete p1;delete p2;delete p3;return 0;
}

智能指针：

RAII原理：

• RAII：resource acquisition is initialization

  1. 利用对象生命周期控制程序资源
  2. 在对象构造时获取资源
  3. 在对象析构时释放资源
  4. 实际上将一份资源的管理职责交给了一个对象

• 好处：

  1. 不需要显式释放资源
  2. 对象所需资源在对象的生命周期内始终有效

• 实质：

  一个成员变量是模板指针的类

  模板指针指向new函数的返回指针

  资源无效后析构时释放模板指针所指资源

smart_ptr：

• 析构函数存在bug的版本：

template <class T>
class smart_ptr{private:T *ptr;public:smart_ptr(T *_ptr){ptr = _ptr;}T& operator*(){return *ptr;}T* operator->(){return ptr;}//有bug的析构函数~smart_ptr(){cout<<ptr <<" " <<*ptr <<endl;delete ptr;}
}
int main(){smart_ptr<int> sp1(new int);smart_ptr<int> sp2(new int);smart_ptr<int> sp3(new int);//析构函数bug体现：同一空间被析构两次，肯定报错int *p = new int;smart_ptr<int> sp4 = p;smart_ptr<int> sp5 = p;cout<<div() <<endl;return 0;
}

• 很明显，这一版的SmartPtr不是存在缺点，而是存在析构漏洞，根本不能使用
• 下面介绍C++98和C++11中几种防止SmartPtr()多次析构的不同设计

auto_ptr：

管理权转移：

• 出现年代：c++98
• 解决多次delete同一资源的方案：管理权转移
  每指向资源的指针多一个时
  1. 将对资源的管理权交给最新的指针
  2. 同时原来的指针都指向空
• 代码：

template <class T>
class auto_ptr{private:T *ptr;public:auto_ptr(T *_ptr){ptr = _ptr;}auto_ptr(auto_ptr<T> &ap){ptr = ap.ptr;ap.ptr = nullptr;}auto_ptr<T>& operator=(auto_ptr<T> *ap){if(this != &ap){if(ptr)delete ptr;ptr = ap.ptr;ap.ptr = nullptr;}return *this;}T& operator*(){return *ptr;}T* operator->(){return ptr;}~auto_ptr(){delete ptr;}
};

优点：

• 优点：

  直接了当的解决了双重析构的问题

缺点：

• 缺点1：

  新的auto_ptr到来会覆盖旧的auto_ptr

  对于auto_ptr使用不熟悉的同学可能出这样的错

int main(){auto_ptr<int> sp1(new int);auto_ptr<int> sp2(sp1);*sp2 = 10;cout<< *sp2 <<endl;cout<< *sp1 <<endl;return 0;
}

• 缺点2：

  管理权转移只存在于auto_ptr对象之间拷贝

  当存在两个auto_ptr对象都从一个指针初始化而来时，还是会出现双重析构问题：

int main(){int *p = new int(10);auto_ptr<int> ap1(p);auto_ptr<int> ap2(p);return 0;
}

unique_str：

• 出现年代：boost库，同期三个智能指针为scoped_ptr / shared_ptr / weak_ptr
• C++11对boost库的借鉴产物：unique_ptr / shared_ptr / weak_ptr
• 解决多次delete同一资源的方案：防拷贝
  每个指针开辟空间之后，只能有一个unique_ptr/scoped_ptr对象封装该指针

防拷贝：

• 防止拷贝函数：
  1. 法一：delete关键词
  2. 法二：私有 + 空实现（只声明不实现）
• 代码：

template <class T>
class unique_ptr{private:T *ptr;//c++11中delete关键字屏蔽函数unique_ptr(unique_ptr<T> const &) = delete;unique_ptr& operator=(unique_ptr<T> const &) = delete;//c++98中私有 + 只声明不实现unique_ptr(unique_ptr<T> const &);unique_ptr& operator=(unique_ptr<T> const &);public:unique_ptr(T *_ptr){ptr = _ptr;}~unique_ptr(){delete ptr;}void Show(){cout<<*ptr <<endl;}
};

缺点：

• 理论上每个指针都只能存在一个unique_ptr对象

• 当不采用unique_ptr对象拷贝赋值，

  而是直接使用指针初始化两个unique_ptr对象时，还是存在双重析构

int *p = new int(10);
unique_ptr<int>  uq1(p);
unique_ptr<int>  uq2(p);

shared_ptr：

• 原理：
  1. 记录有多少个对象管理着同一块资源
  2. 每个对象析构时计数器 - -
  3. 每个对象构造时计数器 ++
  4. 最后一个析构的对象负责释放资源

静态引用计数器：

代码：

• 代码：

template <class T>
class shared_ptr{private:static int refCount;T *ptr;public:shared_ptr(T *_ptr){refCount = 0;ptr = _ptr;}shared_ptr(auto_ptr &ap){refCount++;ptr = ap.ptr;}~shared_ptr(){refCount--;if(refCount == 0 && ptr){delete ptr;}}
};
int main(){shared_ptr<int> sp1(new int);shared_ptr<int> sp2(sp1);shared_ptr<int> sp3(sp1);shared_ptr<int> sp4(new int);return 0;
}

漏洞：

计数器混乱问题：

• 应该是每个资源独立使用一个自己的计数器

  如果所有资源都使用同一个引用计数器，那么会产生如下结果

• 初始化时：

  1. sp1 借助 int* 初始化时，计数器refCount == 0
  2. sp2 借助 sp1 初始化时，计数器refCount == 1
  3. sp3 借助 sp1 初始化时，计数器refCount == 2
  4. sp4 借助 int* 初始化时，计数器refCount == 0

• 析构时：

  sp1 & sp2 & sp3都对同一块内存析构，引发多重析构异常

直接指针构造问题：

• 继续不按套路出牌，直接使用指针构造两个对象：

int *p = new int(10);
shared_ptr<int> sp1(p);		//静态计数器refCount == 0
shared_ptr<int> sp2(p);		//静态计数器refCount == 0
/*析构时直接双重析构，异常
*/

• 静态引用计数器本身存储漏洞，且不能解决指针直接构造对象问题，

  下面来看看动态引用计数器能不能同时解决两个问题？

动态引用计数器：

代码：

• 代码：

template <class T>
class shared_ptr{private:T *ptr;int *refCount;			//动态引用计数器public:shared_ptr(T *_ptr){ptr = _ptr;refCount = (new int(1));	//从这步开始已经决定了智能指针只能走对象拷贝路线，不能走指针直接构造路线}shared_ptr(const shared_ptr<T> &sp){ptr = sp.ptr;refCount = sp.refCount;(*refCount)++;}shared_ptr<T>& operator=(const shared_ptr<T> &sp){if(ptr != sp.ptr){ptr = sp.ptr;refCount = sp.refCount;(*refCount)++;}}~shared_ptr(){if(--(*refCount) == 0 && ptr){delete ptr;delete refCount;			}}
};
int main(){shared_ptr<int> sp1(new int);shared_ptr<int> sp2(sp1);shared_ptr<int> sp3(sp1);shared_ptr<int> sp4(new int);return 0;
}

优点：

• 每个资源独立使用自己的计数器

  不同的资源计数器之间互不干扰

缺点：

对象赋值拷贝时的计数器错误：

• 两个指针所指不同的对象，又发生赋值拷贝时：

class shared_ptr{shared_ptr<T>& operator=(const shared_ptr<T> &sp){if(ptr != sp.ptr){ptr = sp.ptr;refCount = sp.refCount;(*refCount)++;}}
};

• 发生资源引用数只增不减，可能最终导致无法析构释放：
  
• 对策：每次对象拷贝构造时，先让原资源引用数–，再让现资源引用数++

class shared_ptr{shared_ptr<T>& operator=(const shared_ptr<T> &sp){if(ptr != sp.ptr){//原资源引用数--if(--(*refCount) == 0){delete ptr;delete refCount;}//先资源引用数++ptr = sp.ptr;refCount = sp.refCount;(*refCount)++;}}
};

多线程下的计数器安全问题：

• 当多线程同时含有对同一块资源的智能指针时，可能出现下列情况：
  1. 计数器++时少加：
     1. 主线程中智能指针被创建出来，refCount = 1;
     2. 子线程1中对主线程智能指针对象拷贝，refCount还未++完成(++分三个原子步骤)
     3. 子线程2中对主线程智能指针对象拷贝，refCount++完成
     4. 子线程1中refCount++完成
     5. 此时对同一资源的引用计数器本来应该是3，但是只有2
  2. 计数器- -时少减：
     1. 所有线程中只有两个智能指针对象时：
     2. 子线程1中使用完毕智能指针对象，开始析构，但是refCount–未完成(–分三个原子步骤)
     3. 子线程2中也使用完毕智能指针对象，开始析构，refCount- -完成
     4. 子线程2本来refCount- -之后，refCount==0，开始delete。但是此时refCount不为0
     5. 子线程1完成refCount–，资源无人delete，造成内存泄露
• 线程安全对策：
  1. 加锁
  2. 锁也要借鉴refCount的原理，使用指针完成“一人一把锁”

真·智能指针：

代码：

• 吸收动态引用计数的两大缺点之后，

  我们终于可以写出基本没有安全问题的智能指针类了：

#include <iostream>
#include <mutex>
using namespace std;
template <class T>
class SharedPtr{private:T *ptr;int *refCount;mutex *mtx;private:void AddRefCount(){mtx.lock();*refCount++;mtx.unlock();}void SubRefCount(){bool flag = 0;mtx.lock();if (--(*refCount) == 0){delete ptr;delete refCount;flag = true;}mtx.unlock();if(flag == 1)delete mtx;}public:SharedPtr(T *_ptr){ptr = _ptr;refCount = new int(0);mtx = new mutex;}//默认采用拷贝构造的对象暂无ptr/refCount/mtx SharedPtr(SharedPtr<T> &sp){ptr = sp.ptr;refCount = sp.refCount;mtx = sp.mtx;AddRefCount();}//默认采用赋值构造的对象已有ptr/refCount/mtx SharedPtr<T>& operator=(SharedPtr<T> &sp){if(ptr != sp.ptr){SubRefCount();ptr = sp.ptr;refCount = sp.refCount;mtx = sp.mtx;AddRefCount();}}~ShardPtr(){SubRefCount();}
};

优点：

1. 类的基本优点：指针所指资源不用时自动析构释放

2. 多个智能指针对象共享一块资源：

   每一块资源都独立使用一个引用计数器

   直接指针构造 / 拷贝构造 / 赋值构造 / 析构，都不会出现多重析构

3. 线程安全：不会出现引用计数器少++ / 少- -的情况

缺点：

1. 多个智能指针对象直接使用指针构造对象时，还是存在多重析构异常：

int *p = new int(10);
shared_ptr<int> sp1(p);
shared_ptr<int> sp2(p);
shared_ptr<int> sp3(p);

2. 关于拷贝构造是否要先减少原有资源引用计数器，需要单独为使用者说明：
   1. 如果拷贝构造只能使用在空白对象上，则不需要减少原有资源引用计数器
   2. 如果拷贝构造只能使用已经赋值过的对象上，则需要减少原有资源引用计数器

漏洞：循环引用

• 查看下面的链表节点智能指针，分析析构过程：

struct ListNode{int data;shared_ptr<ListNode> prev;shared_ptr<LIstNode> next;~ListNode(){cout<<"~ListNode()"<<endl;}
}int main(){shared_ptr<ListNode> node1(new ListNode);shared_ptr<ListNode> node2(new ListNode);node1->next = node2;node2->next = node1;return 0;
}

• 析构一个节点需要析构三部分

  1. 值date
  2. 前驱指针
  3. 后继指针

• 当前两块资源的引用计数器状态：
  

• 要释放node1，需要资源引用计数器==0

  node1完成refCount–后，refCount==1

  要想refCount继续–，需要释放node2的next

  要释放node2的next，需要释放node2

• 要释放node2，需要资源引用计数器==0

  node2完成refCount–后，refCount==1

  要想refCount继续–，需要释放node1的prev

  要想释放node1的prev，需要释放node1

• 发现出现了类似锁套锁的死锁情况，不过这里叫循环引用

  下面来看c++11中解决循环引用的weak_ptr<>

weak_ptr：

原理：

• 循环引用出现的根本原因：

	node1->next = node2;node2->next = node1;//各自资源引用计数器数目 +1 了

• weak_ptr避免循环引用的对策：
  1. 增加引用对象时，不会增加资源计数器
  2. 析构引用对象时，也不会发生双重析构

使用：

• 我们就不自己手动模拟实现了：#include < memory>

struct ListNode{int _data;weak_ptr<ListNode> _prev;weak_ptr<ListNode> _next;~ListNode(){cout << "~ListNode()" << endl;}
};
int main()
{shared_ptr<ListNode> node1(new ListNode);shared_ptr<ListNode> node2(new ListNode);node1->_next = node2;node2->_prev = node1;return 0;
}

定制删除器：

背景：

• 不论是功能完整的shared_ptr还是特殊场景下的weak_ptr，

  既然称为智能指针，就可以接收很多类型的指针

  但是不同类型指针所指资源释放方式不同：

  1. new开辟的空间的指针 -> delete删除
  2. new[]开辟的空间的指针 -> delete[]删除
  3. malloc开辟的空间的指针 -> free释放
  4. fopen()打开的文件的指针 -> fclose()关闭

• 所以我们在单纯为这些智能STL类传入指针的同时，也应该传入删除指针的方式，这就叫做定制删除器

删除器类型：

• 删除功能本质还是一个可调用对象：

  1. 函数名 / 函数指针
  2. 仿函数类对象
  3. lambda表达式

• 重提一下new delete 和 new[] delete[]的区别：

  1. new出来的空间全部都是存储内容，delete按照类型大小+内存开头地址删除即可
  2. new[]出来的空间开头存储的是元素个数，delete按照元素个数+类型大小+内存开头地址进行删除
  3. 本质上两组关键字看待内存空间的方式不一致，即使是一个bit的区别，造成的差异也很大
  4. 但是现在很多编译器做了优化，new[]出来的含有个数的空间，也可以被delete删除释放

模拟实现：

• 由于类内要保存传入的删除器函数及其类型，所以只能采用模板仿函数类，而不能采用函数参数：

template <class T>
class default_delete{public:void operator()(const T*ptr){cout<<"delete:"<<ptr<<endl;delete ptr;}
};
template <class T, class D = default_delete<T>>
class del_ptr{private:T *ptr;public:unique_ptr(T *_ptr){ptr = _ptr;}~unique_ptr(){if(ptr){D del;del(ptr);}}
};
struct DeleteArray{void operator()(A* ptr){cout<< "delete[] : "<<ptr <<endl;delete[] ptr;}
};
struct DeleteFile{void operator()(FILE* ptr){cout<< "fclose[] : "<<ptr <<endl;fclose(ptr);}
};
int main(){del_ptr<A> sp1(new A);	//默认删除器del_ptr<A， DeleteArray> sp2(new A[10]);del_ptr<A, DeleteFile> sp3(fopen("test.txt", "r"));
}

STL中的删除器：

• STL实现较为复杂，同时支持：
  1. 函数参数传入删除器函数
  2. 模板类内保存删除器模板仿函数类

模板传入仿函数类：

• 模板仿函数类：

struct DeleteArray{void operator()(A* ptr){cout<< "delete[] : "<<ptr <<endl;delete[] ptr;}
};
int main(){unique_ptr<A> sp1(new A);unique_ptr<A, DeleteArray> sp1(new A);return 0;
}

传参传入删除函数：

• 传参传入删除函数：

int main(){unique_ptr<A> sp1(new A[10], [](A* p){delete[] p;},);unique_ptr<A> sp2(fopen("test.txt","r"), [](FILE *p){fclose(p);});
}