佛山建网站公司海外推广

---

---

---

RAII

RAII就是将资源交给一个对象管理，这个对象能进行正常的管理和释放资源。

一、auto_ptr

auto_ptr的问题是：在拷贝构造和赋值重载时，会将自己资源的管理权转移给对方。

template<class T>
class auto_ptr
{
public:auto_ptr(T* ptr):_ptr(ptr){}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}//ap3(ap1)auto_ptr(auto_ptr<T>& ap):_ptr(ap._ptr){ap._ptr = nullptr;//必须置空，否则两个指针对象管理同一块空间，会调用析构两次}operator=(auto_ptr<T>& ap){_ptr = ap._ptr;ap._ptr = nullptr;}~auto_ptr(){delete _ptr; // _ptr是指针，是内置类型，默认生成的析构函数不处理//自定义类型调用它自己的析构_ptr = nullptr;}
private:T* _ptr;
};

这个auto_ptr实际不会用，太挫了。
但面试可能要手撕，也要会。

二、unique_ptr

unique_ptr 简单粗暴地禁止了拷贝和赋值重载，那就解决了上面auto_ptr的管理权转移问题了。

template<class T>class unique_ptr{public:unique_ptr(T* ptr):_ptr(ptr){}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}unique_ptr(unique_ptr<T>& up) = delete;unique_ptr<T>& operator=(unique_ptr<T>& up) = delete;~unique_ptr(){delete _ptr; // _ptr是指针，是内置类型，默认生成的析构函数不处理//自定义类型调用它自己的析构_ptr = nullptr;}private:T* _ptr;};

所以unique_ptr就比较适用于，一个指针独占一个资源的情况。

三、shared_ptr

shared_ptr使用了引用计数器，最开始new对象时，计数器为1。
而当其他的同类型的指针对象也指向该对象时，计数器+1。
当有指针对象调用析构函数时，判断计数器是否为0，如果不为0，表明我这个对象还有其他的shared_ptr在管理，不需要delete，让计数器-1即可。
如果计数器为0，表明当前的shared_ptr是最后一个指针对象管理资源了。就delete。

shared_ptr解决了auto_ptr的管理权转移问题，也解决了unique_ptr的不让拷贝和赋值的问题。

注意的问题：

• 1.不能赋值给自己，否则计数器会++。
  还有一个问题：默认的析构函数的处理方式是delete ptr。
  如果指针管理的资源是T[]，或者是fopen，或者是malloc的呢？
  如果还使用默认的处理方式delete ptr，就会出现问题。
  资源是T[],就得用delete[] ,是fopen，就得用fclose，是malloc，就得用free。
  所以在传参的时候，就需要传处理方法过来了。（可以传对象的方法，可以传lambda，可以传包装器。
  所以就需要将析构函数，设置成一个对象/包装器，调用的就是传进来的析构方法。
• 2.实现赋值重载的时候，有很多细节。
• • 不能自己给自己赋值
• • 在把对方赋值给自己之前，需要把自己所指向的计时器减减，因为我要只向其他的计时器了。如果减减后的计时器为0，说明这块资源只有我一个指针在管理，现在我要只想其他资源，所以我要先释放我现在的资源才能去指向其他资源，否则就会出现内存泄露问题。
    

template<class T>class shared_ptr{public://1) 使用定制删除器，解决一个当new []时，需要delete []的问题//2) 还有 使用malloc时，需要free配对//3) 使用fopen，需要fclose配对template<class D>shared_ptr(T* ptr,D del):_ptr(ptr),_pcount(new int(1)),_del(del){}//然而这里有一个问题，模板D不是全局的，而是只针对这个构造函数//所以应该如何创建_del对象呢？//使用包装器//function <void(T*)> _del;//因为不管是上面三种情况的哪一种，共同点都是使用的仿函数的返回值都是void，指针类型都是T*T& operator*(){return *_ptr;}T* operator->(){return _ptr;}//sp3(sp1)shared_ptr(shared_ptr<T>& sp):_ptr(sp._ptr),_pcount(sp._pcount) //让他们的引用计数器指针指向同一个计数器{++(*_pcount);}//sp5 = sp2shared_ptr<T>& operator=(shared_ptr<T>& sp){//不能自己赋值给自己，否则引用计数器会++//这样判断是可以的，只要不同的对象指向同一个资源空间，这几个对象之间的赋值都是相当于自己给自己赋值if(_ptr == sp._ptr)  //if (_pcount == sp._pcount) //这也可以{return *this;}//赋值前，需要将之前的计数器--，如果计数器为0，就释放资源//因为我要指向其他资源了，我原来的资源的计数器当然要--if (--(*sp._pcount) == 0){_del(sp._ptr);delete sp._pcount;}_ptr = sp._ptr;_pcount = sp._pcount;++(*_pcount);return *this;}~shared_ptr(){if (--(*_pcount) == 0){_del(_ptr);delete _pcount;_pcount = nullptr;_ptr = nullptr;}}T* get() const {return _ptr;}int use_count() const {return *_pcount;}private:T* _ptr;int* _pcount;//包装器//包装器包装的_del是D类型，这个D也不知道是什么类型，//包装器可以包装仿函数，包装对象的方法等。//如果只是普通的指针析构，那就给一个缺省。function <void(T*)> _del = [](T* ptr) {delete ptr; }; //dzt::shared_ptr<int> svr(new int); //这样的方式，就是没传处理方式，那默认就是用缺省。//dzt::shared_ptr<int> svr(new int[10],[](int* ptr){delete[] ptr};//这样的传参方式，就用delete[]解决};

shared_ptr的循环引用问题

循环引用问题是两个节点的shared_ptr指针互相指向的时候，引用计数器都会+1，这就出现了互相的计数器都是2.在析构时，都变成1，此时就出现了，到底谁先析构的问题。
就一直死循环了。

不过，shared_ptr能解决日常生活99%的问题，它只有一个缺点，就是循环引用问题。

解决办法：weak_ptr，weak_ptr是专门解决循环引用这个问题的。
weak_ptr没有RAII，没有引用计数，不参与对象资源的管理和释放，只是一个简单的访问资源的操作。

四、weak_ptr

template<class T>class weak_ptr{public:weak_ptr():_ptr(nullptr){}weak_ptr(T* ptr):_ptr(ptr){}//weak_ptr必须支持一个shared_ptr构造weak_ptr的构造函数weak_ptr(const shared_ptr<T>& sp):_ptr(sp.get()){}weak_ptr<T>& operator=(const shared_ptr<T>& sp){//类外面无法直接访问类的私有成员_ptr = sp.get();return *this;}//weak只支持访问资源的操作T& operator*(){return *_ptr;}T* operator->(){return _ptr;}//weak_ptr不参与对象资源的管理和释放，所以没有析构函数private:T* _ptr;};

---

总结

本文讲述了几个智能指针的优缺点和模拟实现。