剖析C++标准库智能指针(std::auto_ptr) (2) - BOOST

    2. std::auto_ptr的设计原理

      上面的一片正确用法,它们在干些什么?
            一片非法,它们犯了什么罪?
            一片什么所有权转移,它的内部机智是什么?
      哦!一头雾水?下面我们就来剖析其实现机制.
      基础知识：
              a.智能指针的关键技术：在于构造栈上对象的生命期控制
                堆上构造的对象的生命期.因为在智能指针的内部,存储
                着堆对象的指针,而且在构析函数中调用delete行为.
                大致机构如下：
                x* m_PTRx = new x(100);//#1
                template<typename T>
                auto_ptr{
                private:
                T* m_PTR;//维护指向堆对象的指针,在auto_ptr定位后
                ....     //它应该指向#1构造的对象,即拥有所有权.
                ~auto(){ delete m_PTR; }
                ....
                }
             b.所有权转移之说
               上面曾有一非法的程式片段如下：
               auto_ptr<x> m_SMPTR1(new x(100));
               auto_ptr<x> m_SMPTR2 = m_SMPTR1;
               m_SMPTR2->print();
               //输出：100.
               m_SMPTR1->print();
               //!! 非法的.
               按常理来说,m_SMPTR->print();怎么是非法的呢?
               那是因为本来,m_SMPTR1维护指向new x(100)的指针,
               可是m_SMPTR2 = m_SMPTR1;auto_ptr内部机制使得m_SMPTR1将对象的地址
               传给m_SMPTR2,而将自己的对象指针置为0.
               那么自然m_SMPTR->print();失败.
               这里程序设计者要负明显的职责的.
               那么auto_ptr为什么采取这样的策略：保证所有权的单一性.
                                               亦保证了系统安全性.
               如果多个有全权的auto_ptr维护一个对象,那么在你消除一个
               auto_ptr时,将导致多个auto_ptr的潜在危险.

       下面我们以SGI-STL的auto_ptr设计为样本(去掉了无关分析的宏),来剖析其原理.

#1 template <class _Tp> class auto_ptr {

#2 private:

#3 _Tp* _M_ptr; //定义将维护堆对象的指针

#4 public:

#5 typedef _Tp element_type; //相关类型定义

#6 explicit auto_ptr(_Tp* __p = 0) __STL_NOTHROW : _M_ptr(__p) {}

#7 auto_ptr(auto_ptr& __a) __STL_NOTHROW : _M_ptr(__a.release()) {}

#8 template <class _Tp1> auto_ptr(auto_ptr<_Tp1>& __a) __STL_NOTHROW

: _M_ptr(__a.release()) {}

//#6、#7、#8是auto_ptr构造函数的三个版本.

//#6注释：传入对象的指针,构造auto_ptr.explicit关键字:禁止隐式转换.

// 这就是ok2正确,而no5(隐式转换)错误的原因.

//#7注释：拷贝构造函数.

// 传入auto_ptr实例,构造auto_ptr. ok1、ok3使用了这个构造式.

// 它是一个很关键的构造函数,在具体情况下,我们再分析

//#8注释：auto_ptr的模板成员,可在继承对象重载的基础上,实现特殊功能.

// 举例：

// class A{ public:

// virtual void fook(){cout<<"I am programming"<<endl;

// /*..........*/ };

// class B : public A {

// virtual void fook(){ cout<<"I am working"<<endl;

// /*...........*/ };

// auto_ptr<A> m_SMPTRa(new A(33));//实质：

// auto_ptr<B> m_SMPTRb(m_SMPTRa); //基类的指针可以赋给派生类的指针

// auto_ptr<B> m_SMPTRb(new B(44));//实质：

// auto_ptr<A> m_SMPTRa(m_SMPTRb); //派生类的指针不可赋给基类的指针

// auto_ptr<A> m_SMPTRa(new B(33)); // ok!

// m_SMPTRa->fook()将调用派生类B的fook()

// m_SMPTRa->A::fook()将调用基类A的fook()

// auto_ptr<B> m_SMPTRb(new A(33)); // wrong!

#9 auto_ptr& operator=(auto_ptr& __a) __STL_NOTHROW {

#10 if (&__a != this) { delete _M_ptr; _M_ptr = __a.release(); }

#11 return *this;

#12 }

#13 template <class _Tp1>

#14 auto_ptr& operator=(auto_ptr<_Tp1>& __a) __STL_NOTHROW {

#15 if (__a.get() != this->get()) { delete _M_ptr; _M_ptr = __a.release(); }

#16 return *this;

#16 }

// #9~~#16 两个版本的指派函数.

// delete _M_ptr; 在指派前,销毁原维护的对象.

// _a.release() ; release操作,详细代码参见#20~~#23.

// 用于*this获得被指派对象,

// 且将原维护auto_ptr置空.

// no3使用了第一种指派.

// 而权限转移正是_a.release()的结果.

#17 ~auto_ptr() __STL_NOTHROW { delete _M_ptr; }

//构析函数.消除对象.注意这里对对象的要求!

#17 _Tp& operator*() const __STL_NOTHROW { return *_M_ptr; }

#18 _Tp* operator->() const __STL_NOTHROW { return _M_ptr; }

#19 _Tp* get() const __STL_NOTHROW { return _M_ptr; }

// 操作符重载.

// #17注释：提领操作(dereference),获得对象. 见ok5用法.

// #18注释：成员运算符重载,返回对象指针.

// #19注释：普通成员函数.作用同于重载->运算符

#20 _Tp* release() __STL_NOTHROW {

#21 _Tp* __tmp = _M_ptr;

#22 _M_ptr = 0;

#23 return __tmp; }

//上面已经详解

#24 void reset(_Tp* __p = 0) __STL_NOTHROW {

#25 delete _M_ptr;

#26 _M_ptr = __p; }

//传入对象指针,改变auto_ptr维护的对象

// 且迫使auto_ptr消除原来维护的对象

// 见ok3用法.

// According to the C++ standard, these conversions are required. Most

// present-day compilers, however, do not enforce that requirement---and,

// in fact, most present-day compilers do not support the language

// features that these conversions rely on.

//下面这片段用于类型转化,目前没有任何编译器支持
//具体技术细节不诉.

#ifdef __SGI_STL_USE_AUTO_PTR_CONVERSIONS

#27 private:

#28 template<class _Tp1>

#29 struct auto_ptr_ref { _Tp1* _M_ptr; auto_ptr_ref(_Tp1* __p) : _M_ptr(__p) {}

};

#30 public:

#31 auto_ptr(auto_ptr_ref<_Tp> __ref) __STL_NOTHROW

: _M_ptr(__ref._M_ptr) {}

#32 template <class _Tp1>

#33 operator auto_ptr_ref<_Tp1>() __STL_NOTHROW

#34 { return auto_ptr_ref<_Tp>(this->release()); }

#35 template <class _Tp1> operator auto_ptr<_Tp1>() __STL_NOTHROW

#36 { return auto_ptr<_Tp1>(this->release()); }

#37 #endif /* __SGI_STL_USE_AUTO_PTR_CONVERSIONS */

#38 };

      OK!就是这样了.
      正如上面原理介绍处叙说,
      你需要正视两大特性：
      1.构造栈对象的生命期控制堆上构造的对象的生命期
      2.通过release来保证auto_ptr对对象的独权.

     在我们对源码分析的基础上,重点看看：
     no系列错误在何处?
     no1.
         我们看到构析函数template<class _Tp>
                         ~auto_ptr() _STL_NOTHROW
                        { delete _M_ptr; }
         所以它不能维护数组,
         维护数组需要操作：delete[] _M_ptr;
     no2.
        先提部分vector和auto_ptr代码：
        a.提auto_ptr代码

auto_ptr(auto_ptr& __a) __STL_NOTHROW : _M_ptr(__a.release()) {}

        b.提vector代码

Part1:

void push_back(const _Tp& __x) {

if (_M_finish != _M_end_of_storage) {

construct(_M_finish, __x);

++_M_finish;

}

else

_M_insert_aux(end(), __x);

}

Part2:

template <class _T1, class _T2>

inline void construct(_T1* __p,

//++++++++++++++++++++++++++++++++

// const _T2& __value) { +

//++++++++++++++++++++++++++++++++

// new (__p) _T1(__value); +

//++++++++++++++++++++++++++++++++

}

Part3.

template <class _Tp, class _Alloc>

void

vector<_Tp, _Alloc>::_M_insert_aux

(iterator __position,

//++++++++++++++++++++++++++++++++

// const _Tp& __x) ++

//++++++++++++++++++++++++++++++++

{

if (_M_finish != _M_end_of_storage) {

construct(_M_finish, *(_M_finish - 1));

++_M_finish;

//++++++++++++++++++++++++++++++++

// _Tp __x_copy = __x; +

//++++++++++++++++++++++++++++++++

copy_backward(__position, _M_finish - 2, _M_finish - 1);

*__position = __x_copy;

}

else {

const size_type __old_size = size();

const size_type __len = __old_size != 0 ? 2 * __old_size : 1;

iterator __new_start = _M_allocate(__len);

iterator __new_finish = __new_start;

__STL_TRY {

__new_finish = uninitialized_copy

(_M_start, __position, __new_start);

construct(__new_finish, __x);

++__new_finish;

__new_finish = uninitialized_copy

(__position, _M_finish, __new_finish);

}

__STL_UNWIND((destroy(__new_start,__new_finish),

_M_deallocate(__new_start,__len)));

destroy(begin(), end());

_M_deallocate(_M_start, _M_end_of_storage - _M_start);

_M_start = __new_start;

_M_finish = __new_finish;

_M_end_of_storage = __new_start + __len;

}

       从提取的vector代码,Part1可看出,push_back的操作行为.
       兵分两路,可是再向下看,你会发现,无一例外,都
       通过const _Tp& 进行拷贝行为,那么从auto_ptr提出的片段就
       派上用场了.
       可你知道的,auto_ptr总是坚持对对象的独权.那必须修改
       原来维护的对象,而vector行为要求const _Tp&,这样自然会产生
       问题.一般编译器是可以发觉这种错误的.

       其实,STL所有的容器类都采用const _Tp&策略.

       //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      + 看了sutter和Josuttis的两篇文章中,都提及：                    +
      + STL容器不支持auto_ptr原因在于copy的对象只是获得所有权的对象, +
      + 这种对象不符合STL的要求.可是本人总感觉即时不是真正的复制对象,+
      + 但我用vector<auto_ptr<x> >的目的就在于维护对象,并不在乎      +
      + 所谓的完全对象.而且我用自己写的Smart Pointer配合STL容器工作, +
      + 很正常.那需要注意的仅仅是const问题.                          +
      +                                                              +
      //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

     no3.
        这个也是auto_ptr隐含的所有权问题引起的.
        const auto_ptr不允许修改.
        随便提及：const对象不代表对象一点不可以改变.
                  在两种const语义下,都有方法修改对象或对象内部指针维护的对象
                 或其它资源.
     no4.
        再看auto_ptr的构析函数.
        delete不可以消除栈上资源.

no5.
依赖传入对象指针的构造函数被声明为explicit,禁止隐式转换.