开发者

C++之智能指针初步及弃用auto_ptr的原因分析

目录
  • RAII
  • RAII的四个步骤
  • 裸指针存在的问题
  • 智能指针
    • 智能指针的引入
    • 四种智能指针
  • 总结

    RAII

    使用局部对象来管理资源的技术

    C++之智能指针初步及弃用auto_ptr的原因分析

    RAII的原理

    C++之智能指针初步及弃用auto_ptr的原因分析

    RAII的四个步骤

    C++之智能指针初步及弃用auto_ptr的原因分析

    裸指针存在的问题

    delete后的指针变量就变成了一个失效指针(也叫作悬空指针)。

    对于下面的代码:

    void Destroy(Object *op)
    {
    	delete op;
    	delete[] op;
    }
    
    Object *op = new Object(10);
    Object *arop = new Object[10];
    
    Destroy(op);
    Destrojavascripty(arop);
    

    因此:

    C++之智能指针初步及弃用auto_ptr的原因分析

    智能指针

    智能指针的引入

    智能指针是比原始指针更加智能的类,解决悬空指针多次删除被指向对象,以及资源泄漏问题,通常用来确保指针的寿命和其指向对象的寿命一致。

    智能指针虽然很智能,很容易被误用,智能也是有代价的。

    四种智能指针

    • auto_ptr
    • unqiue_ptr(唯一性智能指针)
    • shared_ptr(共享性智能指针)
    • weak_ptr(管理弱引用)

    其中后三个是C11支持,并且第一个已经被C11弃用。

    C98中的auto_ptr所做的事情,就是动态分配对象以及当对象不再需要时自动执行清理。

    下面我们首先来了解一下为什么要将auto_ptr移除的原因:

    因为该类型的智能指针意义不明确,使用浅拷贝方式时,两个对象拥有同一块资源:我们模仿源码的逻辑

    了解一下:比如下面的代码:

    class Object
    {
        int value;
    public:
        Object(int x = 0):value(x){cout<<"Create Object:"<<this<<endl;}
        ~Object(){cout<<"Destroy Object:"<<this<<endl;}
    
        int  & Value(){return value;}
        const int& Value() const{return value;}
    };
    
    template<class _Ty>
    class my_auto_ptr
    {
    private:
        bool _Owns;//所有权
        _Ty* _Ptr;
    public:
        my_auto_ptr(_Ty* p = NULL):_Owns(p != NULL),_Ptr(p){}
        ~my_auto_ptr()
        {
            if(_Owns)
            {
                delete _Ptr;
            }
            _Owns = false;
            _Ptr = NULL;
        }
        _Ty* get() const 
        {
            return _Ptr;
        }
        _Ty* operator->()const
        {
            return get();
        }
        _Ty & operator*()
        {
            return *get();
        }
        void reset(_Ty* p js= NULL) 
        {
           ifjavascript(_Owns)
           {
               delete _Ptr;
           }
           _Ptr = p;
        }
        _Ty * release()const//编译要通过,要么异变,要么强转成普通指针
        {
            _Ty* tmp = NULL;
            if(_Owns)
            {
                ((my_auto_ptr*)this)->_Owns = false;
                tmp = _Ptr;
                ((my_auto_ptr*)this)->_Ptr = NULL;
            }
            return tmp;
        }
        phpmy_auto_ptr(const my_auto_ptr & op):_Owns(op._Owns)
        {
            if(_Owns)
            {
                _Ptr = op._Ptr;
            }
        }
    };
    
    void fun()
    {
        my_auto_ptr<Object> pobj(new Object(10));//pobj是my_auto_ptr类型
        cout<<pobj->Value()<<endl;
        cout<<(*pobj).Value()<<endl;//(*pobj)是Object的堆区对象。*(pobj._Ptr).Value()
    }
    int main()
    {
        my_auto_ptr<Object> pobja(new Object(10));
        my_auto_ptr<Object> pobjb(pobja);
    }
    

    相关函数解释:

    C++之智能指针初步及弃用auto_ptr的原因分析

    此时程序必然会导致程序崩溃引发异常,主函数结束时对同一部分资源释放了两次,堆内存被释放两次

    C++之智能指针初步及弃用auto_ptr的原因分析

    那么我们可能会考虑,将资源转移,即修改拷贝构造如下:利用是释放函数

    my_auto_ptr(const my_auto_编程客栈ptr & op):_Owns(op._Owns),_Ptr(op.release())
        {}
    

    看似好像解决了上面的问题,实则存在隐患

    C++之智能指针初步及弃用auto_ptr的原因分析

    继续来看:下面的代码存在什么问题呢?

    void fun(my_auto_ptr<Object> apx)
    {
        int x = apx->Value();
        cout<<x<<endl;
    }
    
    int main()
    {
        my_auto_ptr<Object> pobja(new Object(10));
        
        fun(pobja);
    
        int a = pobja->Value();
        cout<<a<<endl;
    }
    

    上述代码的执行逻辑如下:

    • pobja有两个域拥有权域和指针域,拿pobja初始化形参apx时,会调动拷贝构造函数
    • apx将自己的拥有权域设为1,调动release函数,销毁了pobja对象的资源后,返回堆区对象的地址,apx接收后将自身的指针域指向原先pobja所指向的堆区对象
    • fun函数结束,apx局部对象就会被析构,此时再打印a,对象其实已经不存在了并且自身早已失去了pobja的拥有权。

    综上,此时智能指针的拷贝构造函数的两种写法:

     my_auto_ptr(const my_auto_ptr & op):_开发者_JAV培训Owns(op._Owns)
        {
            if(_Owns)
            {
                _Ptr = op._Ptr;
            }
        }
       
     my_auto_ptr(const my_auto_ptr & op):_Owns(op._Owns),_Ptr(op.release())
        {}
    
    • 第一种存在的问题:Object的资源会被两个释放两次
    • 第二种存在的问题:解决了第一种问题,但是不能解决类似于实参对象初始化形参时,实参之前自身的资源丢失的问题,找不着了,因为这种情况太过于隐蔽,容易出错,所以auto_ptr作为函数参数传递时一定要避免的。或许你想到加上引用解决上面的问题,但是仔细思考后发现,我们并不知道函数对传入的传入的auto_ptr做了什么,如果当中的某些操作使其失去了对对象的所有权,那么这还可能会导致致命的执行期错误。获取再加上const 才是个不错的选择。

    因此,C11标准之前的auto_ptr这个智能指针不被广泛使用的原因就是:在某些应用场景下,拷贝构造函数的意义不明确,同理赋值语句也是这个道理,意义同样不明确,因为C11标准之前并不存在移动赋值和移动构造的概念,还有就是之前谈到的一个对象和一组对象的问题,对于自定义类型而言,auto_ptr的析构函数仅能够析构一个对象,不能够处理一组对象的情况,这些都是尚未解决的问题。

    于是在C11中弃用,C17标准中直接移除。 

    历史渊源:

    在STL库之前,有一个功能更加强大的boost库,STL为了与其抗衡,应急制造了STL,但制作的不够完善,由此因为STL未解决auto_ptr的问题,因此STl内的容器vector和list都不想和auto_ptr建立联系。

    总结

    以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

    0

    上一篇:

    下一篇:

    精彩评论

    暂无评论...
    验证码 换一张
    取 消

    最新开发

    开发排行榜