起: 

C++98标准加入auto_ptr,即智能指针,C++11加入shared_ptr和weak_ptr两种智能指针,先从auto_ptr的定义学习一下auto_ptr的用法。

template<class _Ty>
class auto_ptr
{ // wrap an object pointer to ensure destruction
public:
//定义_Myt类型,作用域局限于类中,便于书写和理解
typedef auto_ptr<_Ty> _Myt;
typedef _Ty element_type;
//显式调用构造函数,对类型进行检查并构造一个_Ty类型的指针
//未定义默认构造函数 
explicit auto_ptr(_Ty *_Ptr = 0) _THROW0()
: _Myptr(_Ptr)
{ // construct from object pointer
}
//定义了复制构造函数,稍微有些奇特的复制构造函数,构造了this以后,_Right就会变成一个_Myt类型的NULL指针,这点须谨记,具体参见release的定义。
//上面即所有权转移,同一个指针在多个auto_ptr对象之间只会存在一份所有权,可以避免析构的重复delete错误。
auto_ptr(_Myt& _Right) _THROW0()
: _Myptr(_Right.release())
{ // construct by assuming pointer from _Right auto_ptr
}
//通过auto_ptr_ref结构体来构造智能指针,所有权转移
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()
{ // 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);
}
//赋值操作符=的重载函数之一:独占新指针的所有权并delete当前拥有的指针
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()
: _Myptr(_Right.release())
{ // construct by assuming pointer from _Right
}
//赋值操作符=的重载之一:独占新指针的所有权并delete当前拥有的指针
_Myt& operator=(_Myt& _Right) _THROW0()
{ // assign compatible _Right (assume pointer)
reset(_Right.release());
return (*this);
}
//赋值操作符=的重载之一:独占新指针的所有权并delete当前拥有的指针
_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);
}
//析构删除当前指向的资源,用的delete而非delete [],所以只能用来删除单个抽象数据对象,不能删除数组,需要关注,指向的对象应该是用new构造出来的,而不是new []构造的。
~auto_ptr() _NOEXCEPT
{ // 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());
}
//重载操作符->,内部调用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()
{ // return wrapped pointer
return (_Myptr);
}
//将this指针指向NULL,并返回指向资源的指针
_Ty *release() _THROW0()
{ // return wrapped pointer and give up ownership
_Ty *_Tmp = _Myptr;
_Myptr = 0;
return (_Tmp);
}
//delete已拥有的指针并获取新的指针所有权,reset使用时候要注意这一点
void reset(_Ty *_Ptr = 0)
{ // destroy designated object and store new pointer
if (_Ptr != _Myptr)
delete _Myptr;
_Myptr = _Ptr;
}
private:
_Ty *_Myptr; // the wrapped object pointer
};
学习小结:
1. 每一个auto_ptr都是一个ADT对象,auto_ptr应当被定义成局部或临时变量,以便自动析构拥有的指针。
2. auto_ptr中很重要的一个理念就是所有权转移,所有权转移就是auto_ptr会接管赋给他们的指针的所有权,以后这个指针有且仅有一个auto_ptr拥有。复制构造和赋值操作都会接管指针的所有权。
3. 从整个设计理念看,get()和release()提供了某些灵活性的同时破坏了概念的一致性,使用不当会导致某些错误,所有权不再由唯一的auto_ptr具有,要少用这两个接口。
4. auto_ptr适用于管理new出来的指针,不适用new[]出来的指针,也不要用auto_ptr指向静态分配对象的指针。
5. auto_ptr不满足STL容器的基本要求,因为auto_ptr的复制操作是所有权的转移,而不是所有权的拷贝,不要试图用容器来容纳auto_ptr,也不适用sort等内部会对元素进行拷贝的函数。
6. auto_ptr提供的接口列表:显式构造函数、复制构造函数的各个重载版本、赋值操作符的各个重载版本、操作符*、操作符->、release()、get()、reset()。

 后记:

学习boost,认为boost中的一种与auto_ptr极其类似的智能指针scoped_ptr的设计是不错的,auto_ptr的所有权可以转移,同一时间只有一个auto_ptr可以管理指针,但还是具有一定的危险性,而scoped_ptr把拷贝构造函数和赋值函数全都私有化,保证了指针的绝对安全,从概念上保持了完整性,大多数时候是一种更好的选择。

【C++深入浅出】智能指针之auto_ptr学习的更多相关文章

  1. [3] 智能指针std::auto_ptr

    [1]std::auto_ptr 对于编译器来说,智能指针实质是一个栈对象,而并非指针类型. 智能指针通过构造函数获取堆内存的管理所有权,而在其生命期结束时,再通过析构函数释放由它所管理的堆内存. 所 ...

  2. 智能指针之 auto_ptr

    C++的auto_ptr所做的事情,就是动态分配对象以及当对象不再需要时自动执行清理,该智能指针在C++11中已经被弃用,转而由unique_ptr替代, 那这次使用和实现,就具体讲一下auto_pt ...

  3. 智能指针之auto_ptr和scoped_ptr

    部分参考地址https://blog.csdn.net/yanglingwell/article/details/56011576 auto_ptr是c++标准库里的智能指针,但是具有以下几个明显的缺 ...

  4. C++ 智能指针 std::auto_ptr 分析

    背景介绍: RAll机制 定义一个类来封装资源的分配和释放,在构造函数中完成资源的分配和初始化,在析构函数中完成资源的清理,从而保证资源的正确初始化和清理 ps:智能指针就是RAll机制的一种应用,智 ...

  5. 智能指针shared_ptr使用学习

    当需要shared_ptr实现向上向下转换时,可以使用 dynamic_pointer_cast 来进行转换 下面是例子: #include <memory> using namespac ...

  6. 智能指针shared_ptr, auto_ptr, scoped_ptr, weak_ptr总结

    看这里: http://blog.csdn.net/lollipop_jin/article/details/8499530 shared_ptr可以多线程同时读,但是涉及到写,需要加锁. share ...

  7. auto_ptr,shared_ptr 智能指针的使用

    Q: 那个auto_ptr是什么东东啊?为什么没有auto_array?A: 哦,auto_ptr是一个很简单的资源封装类,是在<memory>头文件中定义的.它使用“资源分配即初始化”技 ...

  8. 深入学习c++--智能指针(一) shared_ptr

    1. 几种智能指针 1. auto_ptr: c++11中推荐不使用他 2. shared_ptr: 每添加一次引用 就+1,减少一次引用,就-1:做到指针进行共享 3. unique_ptr: 一个 ...

  9. C++ 智能指针Auto_PTR 分析

    C++的动态内存的分配与释放是个挺折磨人的事情,尤其异常分支复杂时(比如一堆try catch中,各catch里需要做delete 掉相关的堆上分配的内存),极有可能产生内存泄露的情况.C++中提供了 ...

随机推荐

  1. 面试大总结之二:Java搞定面试中的二叉树题目

    package BinaryTreeSummary; import java.util.ArrayList; import java.util.Iterator; import java.util.L ...

  2. 218. The Skyline Problem

    题目: A city's skyline is the outer contour of the silhouette formed by all the buildings in that city ...

  3. RGB颜色查询对照表

    RGB颜色查询对照表     RGB颜色对照表   #FFFFFF2015-02-05   #FFFFF0   #FFFFE0   #FFFF00   #FFFAFA   #FFFAF0   #FFF ...

  4. Java对象相关元素的初始化过程

    1.类的成员变量.构造函数.成员方法的初始化过程 当一个类使用new关键字来创建新的对象的时候,比如Person per = new Person();JVM根据Person()寻找匹配的类,然后找到 ...

  5. ObfuscationAttribute模糊处理

    在Reflection的强大和Reflector的盛行下,.NET产品的内部实现越来越透明,在恶意用户和Cracker面前,基本上已是砧板上的肉,被切到什么程度只能祈祷遇到的都是钝刀子:于是一批批的混 ...

  6. Apache HTTP Server多个拒绝服务漏洞

    漏洞版本: Apache Group Apache HTTP Server < 2.4.9 漏洞描述: BUGTRAQ ID: 66303 CVE ID: CVE-2013-6438,CVE-2 ...

  7. 各种好用的工具之一 ---- PNGGauntlet

    1.PNGGauntlet实际上是一个图形前端,压缩图像的过程中使用的是PNGOUT, OptiPNG, 和DeflOpt这三款软件. 软件官网:http://pnggauntlet.com/ 可自行 ...

  8. String中intern的方法

    首先查看官方API那个的解释: ——————————————————————————————————————— intern public String intern() 返回字符串对象的规范化表示形 ...

  9. JAVA分布式事务原理及应用

    JTA(Java Transaction API)允许应用程序执行分布式事务处理--在两个或多个网络计算机资源上访问并且更新数据.JDBC驱动程序的JTA支持极大地增强了数据访问能力. 本文的目的是要 ...

  10. 【原创】 Shuffling

    在机器学习领域中,经常会听到“shuffling"这个术语.那么,shuffling到底是什么意思呢. 通常,shuffling指的是在SGD怎样依赖训练数据输入顺序的算法中,将训练数据随机 ...