C++之智能指针初步及弃用auto_ptr的原因是什么

本篇内容介绍了“c++之智能指针初步及弃用auto_ptr的原因是什么”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

RaiI

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

RAII的四个步骤

裸指针存在的问题

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

对于下面的代码：

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

因此：

智能指针

智能指针的引入

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

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

四种智能指针

• 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 = NULL)     {       if(_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;    }    my_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);}

相关函数解释：

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

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

my_auto_ptr(const my_auto_ptr & op):_Owns(op._Owns),_Ptr(op.release())    {}

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

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

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):_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建立联系。

“C++之智能指针初步及弃用auto_ptr的原因是什么”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注编程网网站，小编将为大家输出更多高质量的实用文章！