auto_ptr_ref的奇妙(下)

原创 2003年06月17日 11:04:00
 

auto_ptr_ref的奇妙(下)

在我们前面谈到的auto_ptr,它的复制操作的参数类型恰好是非常量引用。所以对于下面的情况它就不能正确处理。<?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />

auto_ptr<int> ap1 = auto_ptr<int>(new int(8));//等号右边的是一个临时右值

auto_ptr<int> fun()//一个生成auto_ptr<int>source函数

{return auto_ptr<int>(new int(8))}

auto_ptr<int> ap2 ( fun() );//调用fun()生成的auto_ptr<int>是右值

而这种情况不但合法,也是很常见的,我们不能拒绝这种用法,怎么办?天才的C++库设计者已经为我们想到了这一点,auto_ptr_ref的引入就是为了解决这个问题。仔细观察最下面的auto_ptr实现代码,我们会看到这样几行:

    /* special conversions with auxiliary type to enable copies and assignments */
        auto_ptr(auto_ptr_ref<T> rhs) throw()
         : ap(rhs.yp) {
        }
        auto_ptr& operator= (auto_ptr_ref<T> rhs) throw() { 
 // new
             reset(rhs.yp);
             return *this;
        }

template<class Y>
        operator auto_ptr_ref<Y>() throw() {
            return auto_ptr_ref<Y>(release());

        }

这就是关键所在了。对于一个auto_ptr右值,不可能为它调用正常的赋值运算符函数和复制构造函数,举个例子说明,对于语句

auto_ptr<int> ap1 = auto_ptr<int>(new int(8));

首先生成临时对象右值auto_ptr<int>(new int(8)),然后使用转型函数模板

template<class Y> operator auto_ptr_ref<Y>() throw()

{ return auto_ptr_ref<Y>(release());}

auto_ptr<int>(new int(8)),首先调用成员函数release(),然后由获取的原始指针生成另外一个临时对象右值auto_ptr_ref<int>(一个指向动态存储区中8的指针)。这个时候我们再看一个构造函数

        auto_ptr(auto_ptr_ref<T> rhs) throw()
         : ap(rhs.yp) {

        }

它的参数类型不是引用,采用的是传值(by value),所以可以接受右值,这时候,调用auto_ptr_ref<int>默认生成的复制构造函数(copy constructor),用上面最后得到的那个auto_ptr_ref<int>临时对象右值作为引数,生成了rhs,接着auto_ptr_ref<int>临时对象右值自动析构结束生命,后面的ap(rhs.yp)完成最后的工作。

我们的整个探险过程就结束了。最好参考《The C++ Standard Library》中讲解auto_ptr使用的章节一起阅读。这样auto_ptr的使用和所有设计原理对我们就不再神秘了。

附录:auto_ptr的实现代码,来自Nicolai M. Josuttis

/* class auto_ptr
 * - improved standard conforming implementation
 */
namespace
 std {
    // auxiliary type to enable copies and assignments (now global)
    template<class Y>
    struct auto_ptr_ref {
        Y* yp;
        auto_ptr_ref (Y* rhs)
         : yp(rhs) {
        }
    };

    template<class T>
    class auto_ptr {
      private:
        T* ap;    // refers to the actual owned object (if any)
      public:
        typedef T element_type;

        // constructor
        explicit auto_ptr (T* ptr = 0) throw()
         : ap(ptr) {
        }

        // copy constructors (with implicit conversion)
        // - note: nonconstant parameter
        auto_ptr (auto_ptr& rhs) throw()
         : ap(rhs.release()) {
        }
        template<class Y>
        auto_ptr (auto_ptr<Y>& rhs) throw()
         : ap(rhs.release()) {
        }
        
        // assignments (with implicit conversion)
        // - note: nonconstant parameter
        auto_ptr& operator= (auto_ptr& rhs) throw() {
            reset(rhs.release());
            return *this;
        }
        template<class Y>
        auto_ptr& operator= (auto_ptr<Y>& rhs) throw() {
            reset(rhs.release());
            return *this;
        }
        
        // destructor
        ~auto_ptr() throw() {
            delete ap;
        }

        // value access
        T* get() const throw() {
            return ap;
        }
        T& operator*() const throw() {
            return *ap;
        }
        T* operator->() const throw() {
            return ap;
        }

        // release ownership
        T* release() throw() {
            T* tmp(ap);
            ap = 0;
            return tmp;
        }

        // reset value
        void reset (T* ptr=0) throw() {
            if (ap != ptr) {
                delete ap;
                ap = ptr;
            }
        }

        /* special conversions with auxiliary type to enable copies and assignments
         */
        auto_ptr(auto_ptr_ref<T> rhs) throw()
         : ap(rhs.yp) {
        }
        auto_ptr& operator= (auto_ptr_ref<T> rhs) throw() {  // new
             reset(rhs.yp);
             return *this;
        }
        template<class Y>
        operator auto_ptr_ref<Y>() throw() {
            return auto_ptr_ref<Y>(release());
        }
        template<class Y>
        operator auto_ptr<Y>() throw() {
            return auto_ptr<Y>(release());
        }
    };
}

吴桐写于2003.6.16

最近修改2003.6.16

auto_ptr_ref的奇妙(上)

  auto_ptr_ref的奇妙(上)auto_ptr是目前C++标准中唯一的一个智能指针(smart pointer),主要是用来自动管理指针所指向的内存资源。资源管理是程序设计中非常重要的一部分...
  • wtong
  • wtong
  • 2003年06月17日 11:01
  • 1739

auto_ptr_ref的奇妙

auto_ptr是目前C++标准中唯一的一个智能指针(smart pointer),主要是用来自动管理指针所指向的内存资源。资源管理是程序设计中非常重要的一部分。资源(resource)是计算机中很宽...
  • BuleRiver
  • BuleRiver
  • 2009年05月03日 21:32
  • 1209

奇妙的网络世界

虽然每天基本大多数时间都是online的,有时候查查资料,有时候和朋友聊聊之类的。毕竟选择了这个专业,基本上大多数时间都是坐在电脑面前的,而网络的魅力就在于让你觉得“有时候会食之无味,但又弃之可惜”。...
  • zweily
  • zweily
  • 2004年11月27日 20:38
  • 978

蓝桥杯历届-奇妙的数字

蓝桥杯历届-奇妙的数字奇妙的数字小明发现了一个奇妙的数字。它的平方和立方正好把0~9的10个数字每个用且只用了一次。 你能猜出这个数字是多少吗?请填写该数字,不要填写任何多余的内容。#include...
  • ACM_TH
  • ACM_TH
  • 2016年03月08日 16:48
  • 1417

2015年蓝桥杯省赛A组C/C++:奇妙的数字

A组第三题: 奇妙的数字小明发现了一个奇妙的数字。它的平方和立方正好把0~9的10个数字每个用且只用了一次。 你能猜出这个数字是多少吗?请填写该数字,不要填写任何多余的内容。分析: 1.变量x2...
  • OREO_GO
  • OREO_GO
  • 2016年03月28日 23:57
  • 1013

蓝桥杯 奇妙的数字(java题解)

题目:奇妙的数字小明发现了一个奇妙的数字。它的平方和立方正好把0~9的10个数字每个用且只用了一次。 你能猜出这个数字是多少吗?请填写该数字,不要填写任何多余的内容。代码:import java....
  • qq_15370821
  • qq_15370821
  • 2016年08月16日 11:09
  • 614

2016届蓝桥杯省赛A组奇妙的数字

奇妙的数字 小明发现了一个奇妙的数字。它的平方和立方正好把0~9的10个数字每个用且只用了一次。 你能猜出这个数字是多少吗?请填写该数字,不要填写任何多余的内容。因为40的平方加立方为9位数 50...
  • love_QJP
  • love_QJP
  • 2017年02月04日 19:42
  • 559

蓝桥杯—奇妙的数字(小明发现了一个奇妙的数字)

题目要求: 小明发现了一个奇妙的数字。它的平方和立方正好把0~9的10个数字每个用且只用了一次。 你能猜出这个数字是多少吗?...
  • rl529014
  • rl529014
  • 2016年02月28日 16:09
  • 4126

第六届蓝桥杯 软件类省赛真题 第六题:奇妙的数字

奇妙的数字 小明发现了一个奇妙的数字。它的平方和立方正好把0~9的10个数字每个用且只用了一次。 你能猜出这个数字是多少吗? 请填写该数字,不要填写任何多余的内容。 cla...
  • qq_30258957
  • qq_30258957
  • 2016年03月11日 17:18
  • 1286

奇妙的等式

1. 基础版,1.1 时钟;
  • lanchunhui
  • lanchunhui
  • 2016年08月28日 14:30
  • 313
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:auto_ptr_ref的奇妙(下)
举报原因:
原因补充:

(最多只允许输入30个字)