智能指针

来源：互联网发布：淘宝客服在家工作招聘编辑：程序博客网时间：2024/05/17 03:04

什么是智能指针

智能指针是C++中的重点之一，这也是在笔试面试中爱考的知识点
理清智能指针十分重要

说起智能指针最先要提的就是RAII
RAII全称Resource Acquistion Is Initialization
定义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，
在析构函数完成资源的清理，可以保证资源的正确初始化和释放。

那么什么是智能指针？为什么会有智能指针？

智能指针的引入是因为：在编程中常会有动态内存的开辟，而用完后会忘记释放；在逻辑处理时也要十分谨慎；还有野指针问题。因为一不小心就会有内存泄漏问题。内存泄漏会引发占用存储空间越来越多，最终用尽全部存储空间，整个系统崩溃。智能指针就是为了防止内存泄漏而引入的。

所谓的智能指针就是帮你管理指针，用完后自动释放。

本次提到的主要智能指针有auto_ptr/scoped_ptr/shared_ptr/weak_ptr
其中第一种智能指针是98/03C++提出
但是效果不好，于是就有其他的C++高手依次研究出其他指针，scoped_ptr，shared_ptr,scoped_array_ptr,shared_array_ptr等(这些智能指针是C++第三方库boost里的)
C++11加入了shared_ptr,unique_ptr,和weak_ptr
因为shared_ptr有循环引用的问题，weak_ptr就是为了解决循环引用而产生的

auto_ptr

第一种：管理权转移——auto_ptr 这是失败的设计，现已明确规定不能使用
这里写图片描述
sp1创建的一个空间，交给智能指针管理。sp2拷贝sp1或sp1赋值给sp2时，就将sp2指向这个空间，sp1置空。sp1就不能再访问这个空间。
模拟实现auto_ptr
代码：

template <class T>class AutoPtr{public:    AutoPtr(T* ptr)//构造函数        :_ptr(ptr)    {}    ~AutoPtr()//析构函数    {        if (_ptr)        {            delete _ptr;        }    }    AutoPtr(AutoPtr <T>& ap)//拷贝构造        :_ptr(ap._ptr)    {        ap._ptr = NULL;    }    AutoPtr<T>& operator=(AutoPtr<T>& ap)//赋值运算符重载    {        if (this != &ap)        {            delete _ptr;            _ptr = ap._ptr;            ap._ptr = NULL;        }        return *this;    }    T& operator*()//*运算符重载    {        return *_ptr;    }    T* operator->()//->运算符重载    {        return _ptr;    }protected:    T* _ptr;};

scoped_ptr

第二种：防拷贝—— scoped_ptr 就是好的设计，简单粗暴（不让拷贝）但是只适用于部分场景
注：就是把拷贝构造和赋值运算符重载只声明不定义，声明成私有或保护。
模拟实现 scoped_ptr
代码：

template <class T>class ScopedPtr{public:    ScopedPtr(T* ptr)//构造函数        :_ptr(ptr)    {}    ~ScopedPtr()//析构函数    {        delete _ptr;    }    T& operator*()//*运算符重载    {        return *_ptr;    }    T* operator->()//->运算符重载    {        return _ptr;    }protected:    ScopedPtr(const ScopedPtr<T>& sp);//拷贝构造    ScopedPtr<T>& operator=(const ScopedPtr<T>& sp);//赋值运算符重载protected:    T* _ptr;}

shared_ptr

第三种：引入引用计数—— shared_ptr用引用计数实现，功能强大，适用的场景多，但是复杂，循环引用

模拟实现 shared_ptr
代码：

template <class T>class SharedPtr{public:    SharedPtr(T* ptr)//拷贝构造        :_ptr(ptr)        , _refCount(new int(1))    {}    ~SharedPtr()//析构函数    {        if (--(*_refCount) == 0)        {            delete _ptr;            delete _refCount;        }    }    SharedPtr(const SharedPtr<T>& sp)//拷贝构造        :_ptr(sp._ptr)        , _refCount(sp._refCount)    {        ++(*_refCount);    }    SharedPtr<T>& operator=(SharedPtr<T>& sp)//赋值运算符重载    {        if (_ptr != sp->_ptr)        {            this->Release();            this->_ptr = sp._ptr;            this->_refCount = sp._refCount;            ++(*_refCount);        }        return *this;    }    T& operator*()//*运算符重载    {        return *_ptr;    }    T* operator->()//->运算符重载    {        return _ptr;    }    void Release()    {        if (--(*_refCount) == 0)        {            delete _ptr;        }        delete _refCount;        delete _ptr;    }protected:    T* _ptr;    size_t* _refCount;};

weak_ptr

第四种：为了解决shared_ptr循环引用的问题：
如：

struct ListNode{    ListNode* _next;    ListNode* _prev;    int data;};int main(){    ListNode* cur = new ListNode;    ListNode* next = new ListNode;    cur->_next = next;    next->_prev = cur;    //抛异常    delete cur;    delete next;    return 0;}

如果中途抛异常了，就会导致cur和next没有释放就会内存泄漏。
引入智能指针
如：

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

但是会循环引用
这里写图片描述
在调析构函数时，析构next和cur，refCount减到1，cur和next的空间释放时就是refCount为0，next空间释放时，就等cur的_next释放，而_next的释放依赖于cur空间的释放，cur的空间释放就是等next的_prev释放，_prev的释放依赖于next的释放，这就是循环引用。为了解决这类问题就产生了weak_ptr。
解决，可以将结构定义为：

struct ListNode{    /*shared_ptr<ListNode> _next;    shared_ptr<ListNode> _prev;*/    int data;    weak_ptr<ListNode> _next;    weak_ptr<ListNode> _prev;    ~ListNode()    {        cout << "~ListNode()" << endl;    }};

weak_ptr就是用shared_ptr构造的

class WeakPtr{        WeakPtr(SharedPtr sp)                :_ptr(sp._ptr)                {} }

定制删除器（仿函数）

对于shared_ptr还有就是定制删除器的问题
如：

class AA{public:    AA()    {        cout << "AA()" << endl;    }    ~AA()    {        cout << "~AA()" << endl;    }    int _a;};int main(){    shared_ptr<AA> sp1(new AA);    shared_ptr<AA> sp2(new AA[10]);    shared_ptr<int> sp3(new AA);    shared_ptr<int> sp4(new AA[10]);    shared_ptr<FILE> sp5(fopen("Test.txt","w"));    return 0;}

在调用shared_ptr时，如果构造一个数组就无法进行析构，这时就可以利用仿函数增加个定制删除器，用于析构数组。
打开一个文件，也就不能关闭了，同样可以用仿函数实现一个定制删除器。
如：

template <class T>struct DeleteArray{    void operator()(T* ptr)    {        delete[] ptr;    }};struct Fclose{    void operator()(FILE* fp)    {        fclose(fp);    }};class AA{public:    AA()    {        cout << "AA()" << endl;    }    ~AA()    {        cout << "~AA()" << endl;    }    int _a;};int main(){    DeleteArray<AA> da;    shared_ptr<AA> sp1(new AA);    shared_ptr<AA> sp2(new AA[10],da);    shared_ptr<int> sp3(new AA[10]);    shared_ptr<int> sp4(new AA[10]);    Fclose f;    shared_ptr<FILE> sp5(fopen("Test.txt","w"),f);    return 0;}

这样SharePtr就可以模拟实现成带定制删除器
代码：

template <class T>struct DeleteArray{    void operator()(T* ptr)    {        delete[] ptr;    }};template <class T>struct Delete{    void operator()(T* ptr)    {        delete ptr;    }};template <class T,class D = Delete<T>>class SharedPtr{public:    SharedPtr(T* ptr,D del = Delete<T>())//拷贝构造        :_ptr(ptr)        , _refCount(new int(1))        , _del(del)    {}    ~SharedPtr()//析构函数    {        if (--(*_refCount) == 0)        {            delete _ptr;            delete _refCount;        }    }    SharedPtr(const SharedPtr<T>& sp)//拷贝构造        :_ptr(sp._ptr)        , _refCount(sp._refCount)    {        ++(*_refCount);    }    SharedPtr<T>& operator=(SharedPtr<T>& sp)//赋值运算符重载    {        if (_ptr != sp->_ptr)        {            this->Release();            this->_ptr = sp._ptr;            this->_refCount = sp._refCount;            ++(*_refCount);        }        return *this;    }    T& operator*()//*运算符重载    {        return *_ptr;    }    T* operator->()//->运算符重载    {        return _ptr;    }    void Release()    {        if (--(*_refCount) == 0)        {            _del(_ptr);            delete _refCount;        }    }protected:    T* _ptr;    int* _refCount;    D _del;};class AA{public:    AA()    {        cout << "AA()" << endl;    }    ~AA()    {        cout << "~AA()" << endl;    }    int _a;};int main(){    SharedPtr<AA> sp1(new AA);    DeleteArray<AA> da;    SharedPtr<AA, DeleteArray<AA>> sp2(new AA[10], da);    return 0;}

1 0