由auto_ptr的实现说起。

 

源代码为你揭示一切。

c++世界很无奈的一点是，很多东西你必须得看源代码才知晓其中的秘诀。因为技巧太多了。

 

 

 template<class _Ty>
    class auto_ptr;

template<class _Ty>
struct auto_ptr_ref

{    

    // proxy reference for auto_ptr copying

    explicit auto_ptr_ref(_Ty *_Right)
        : _Ref(_Right)
        {  

              // construct from generic pointer to auto_ptr ptr
        }

    _Ty *_Ref;    // generic pointer to auto_ptr ptr
};

 

 

template<class _Ty>
class auto_ptr
{  

 // wrap an object pointer to ensure destruction
public:
    typedef auto_ptr<_Ty> _Myt;
    typedef _Ty element_type;

    explicit auto_ptr(_Ty *_Ptr = 0) _THROW0()    // 显式构造函数
        : _Myptr(_Ptr)
        {  

            // construct from object pointer
        }

    auto_ptr(_Myt& _Right) _THROW0()   // 拷贝构造函数，会导致所有权的转移
        : _Myptr(_Right.release())
        {  

            // construct by assuming pointer from _Right auto_ptr
        }

    auto_ptr(auto_ptr_ref<_Ty> _Right) _THROW0()     // 代理构造函数， 代理对象会被释放。
        {    // construct by assuming pointer from _Right auto_ptr_ref
        _Ty *_Ptr = _Right._Ref;
        _Right._Ref = 0;    // release old
        _Myptr = _Ptr;    // reset this
        }

    template<class _Other>
    operator auto_ptr<_Other>() _THROW0()   // 模板构造函数，从别的类型的auto_ptr构造，比如说从auto_ptr<int>和                 

                                                                         //  auto_ptr<const int>之间的转换
     {  

            // convert to compatible auto_ptr
         return (auto_ptr<_Other>(*this));
      }

    template<class _Other>
        operator auto_ptr_ref<_Other>() _THROW0()
        {  

              // convert to compatible auto_ptr_ref
            _Other *_Cvtptr = _Myptr;    // test implicit conversion
            auto_ptr_ref<_Other> _Ans(_Cvtptr);
           _Myptr = 0;    // pass ownership to auto_ptr_ref,此时转移了所有权
           return (_Ans);
        }

    template<class _Other>
        _Myt& operator=(auto_ptr<_Other>& _Right) _THROW0()   //赋值。会转换所有权
        {  

          // assign compatible _Right (assume pointer)
          reset(_Right.release());
          return (*this);
        }

    template<class _Other>
        auto_ptr(auto_ptr<_Other>& _Right) _THROW0()  //拷贝转换，很危险的函数。底层其实就是裸指针的c语言风格的转换
        : _Myptr(_Right.release())
        {  

          // construct by assuming pointer from _Right
        }

    _Myt& operator=(_Myt& _Right) _THROW0()    // 赋值。会导致所有权的转移
        {    // assign compatible _Right (assume pointer)
        reset(_Right.release());
        return (*this);
        }

    _Myt& operator=(auto_ptr_ref<_Ty> _Right) _THROW0()   //赋值。注意参数只是一个简单的代理类
        {    // assign compatible _Right._Ref (assume pointer)
        _Ty *_Ptr = _Right._Ref;
        _Right._Ref = 0;    // release old
        reset(_Ptr);    // set new
        return (*this);
        }

    ~auto_ptr()
        {    // destroy the object
        delete _Myptr;
        }

    _Ty& operator*() const _THROW0()  ///解引用
        {    // return designated value
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Myptr == 0)
            _DEBUG_ERROR("auto_ptr not dereferencable");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        return (*get());
        }

    _Ty *operator->() const _THROW0()    ///  ->转换
        {    // return pointer to class object
 #if _ITERATOR_DEBUG_LEVEL == 2
        if (_Myptr == 0)
            _DEBUG_ERROR("auto_ptr not dereferencable");
 #endif /* _ITERATOR_DEBUG_LEVEL == 2 */

        return (get());
        }

    _Ty *get() const _THROW0()   /     get函数
        {    // return wrapped pointer
        return (_Myptr);
        }

    _Ty *release() _THROW0()
        {    // return wrapped pointer and give up ownership
        _Ty *_Tmp = _Myptr;
        _Myptr = 0;
        return (_Tmp);
        }

     void reset(_Ty *_Ptr = 0)         所谓 reset, 其本质还是set的语义。不过呢，原来持有的对象被删除了。个人认为返回原来的

                                                        //对象也挺   好的
        {    // destroy designated object and store new pointer
        if (_Ptr != _Myptr)
            delete _Myptr;
        _Myptr = _Ptr;
        }

private:
    _Ty *_Myptr;    // the wrapped object pointer，裸指针
    };

 

以上就是VS2010的auto_ptr的实现了。个人认为，如果你自认为理解不了auto_ptr的实现，还是不要轻易使用的吧，免得惹出一堆bug，你又没法理解。

 

c++的模板语法是很头大，但没办法，模板已成为c++越来越重要的特性了。

 

vs2010已经支持shared_ptr和weak_ptr了，有了他们，你完全可以抛弃auto_ptr了。实际上在日常的应用里，我都是些更加轻量级的类来管理资源，对于局部变量来说，用一个类似于scope holder的类来管理指针的析构。对于类而言，同样的，根据设计需要，加入scope holder或者是引用计数，尽量不用auto_ptr.对于保存指针的容器，编码时尽量注意异常安全，以及内存的释放，这样可以尽最大努力来避免资源泄漏。

 

当然，如果有shared_ptr或者是weak_ptr的话，你就可以放心的使用它们了。

 

如果 你还是很讨厌手动来管理内存， 那你转而去学习java和c#。这两门语言都有GC，会自动回收内存。

 

如果有一天，c++也有了GC，会有这么一天吗？