auto_ptr_ref 的目的是什么？

jianshen77 2003-10-10 05:30:21

看了auto_ptr的源代码，不理解auto_ptr_ref这个类的目的是
什么呢？体现了什么样的设计思路？

...全文

403 17 打赏收藏转发到动态举报

写回复

用AI写文章

17 条回复

切换为时间正序

请发表友善的回复…

发表回复

xueweizhong 2003-10-18

打赏
举报

8.5/14:
如果Target不是引用，且
Target 是Source或者是Source的基类，
那么
Target target=source的初始化过程语义
和Target target(source)一样的。

这将导致不考虑最后一个转换导致的转换：
即Target的构造函数导致的转换将不做考虑。

这样说有些抽象，举个例子来说就是：

struct Source {};

struct Middle
{
Middle(Source){}
};

1 当Target和Source没有关系时：
struct Target
{
Target(Middle);
};

Target target = Source();
// Source->Middle->Target
// 两个自定义转换-->编译器报错。

2 当Target是Source时
Target target = Source();
// Source->Middle->Source
// 只考虑第一个转换，压缩第二个转换
// compile ok

3 当Target是Source的基类时
情况和2类似。

其他一个相关内容是：
当构造函数是explicit时，copy-init将被禁止。
换句话说就是：隐式转换也被禁止。

xueweizhong 2003-10-18

打赏
举报

C++中有两种初始化：
direct-initialization
copy -initialization

其中copy-init转化为隐式转换Source->Target的定义：

//Source source;
Target target = source;

关键是隐式转换中规定：
1：一个隐式转换中不能出现两个用户定义转换。
^^^
我们这里
#1 : rvalue-auto_ptr -> auto_ptr_ref
#2 : auto_ptr_ref -> auto_ptr
都是用户定义转换。
那么这里需要的转换
rvalue-auto_ptr --> auto_ptr_ref
需要两个用户定义转换#1和#2，这和上面的规定
是冲突的。
那么为什么编译器又允许这个转换呢？
在C++STD较为复杂的8.5节中描述了一个例外情形，
使这个规则出现了一些例外的情况。

下帖续。

jianshen77 2003-10-17

打赏
举报

up 一下了！

jianshen77 2003-10-15

打赏
举报

我觉的吴桐解释的不是很清楚，准确吧！
翻译的那篇倒是很好的！
是不是可以这样简单的理解：
auto_ptr<Y>需要一个non_const引用参数，
于是这样的语法是错误的：
void foo(int& i){}；
foo(int(9))//错误
所以需要一个auto_ptr_ref作为中间隐式转换，
最后用auto_ptr_ref构造auto_ptr

jianshen77 2003-10-14

打赏
举报

xueweizhong(薛卫忠) 的下篇呢？

Meyer 2003-10-14

打赏
举报

auto_ptr_ref和auto_ptr的关系
http://www.csdn.net/develop/Read_Article.asp?Id=18221

auto_ptr_ref的奇妙（上）
http://www.csdn.net/develop/Read_Article.asp?Id=19077

auto_ptr_ref的奇妙（下）
http://www.csdn.net/develop/Read_Article.asp?Id=19082

cuistar 2003-10-13

打赏
举报

学习，说说吧~~~

Wolf0403 2003-10-13

打赏
举报

就是就是啊，老薛（^_^）仔细说说

youngphoneix 2003-10-13

打赏
举报

我通常都是在检测内存是否分配才用到auto_ptr，
而且数组还不行。

jianshen77 2003-10-13

打赏
举报

我原来也想是xueweizhong(薛卫忠)说的那个情况，
可是，在代码里面
template<class _Tp1> auto_ptr(const auto_ptr<_Tp1>& __r)
template<class _Tp1> auto_ptr(auto_ptr<_Tp1>& __r)
都定义了，并且没有用到auto_ptr_ref
operator = 也没有用到啊

xueweizhong 2003-10-13

打赏
举报

# if OBSOLETE // def _STLP_MSVC
^^^^^^^^
template<class _Tp1> auto_ptr(const auto_ptr<_Tp1>& __r) {
this->__set((_Tp1*)const_cast<auto_ptr<_Tp1> >(__r).release());
}
template<class _Tp1> auto_ptr<_Tp>& operator=(const auto_ptr<_Tp1>& __r) {
reset((_Tp1*)const_cast<auto_ptr<_Tp1> >(__r).release());
return *this;
}

看了这个宏处理后就知道只有在旧版本才有
auto_ptr(auto_ptr const&)
这样的拷贝构造，
而在其他情况下皆为
auto_ptr(auto_ptr&)

所以关于这两个拷贝构造共存的现象是不存在的：
auto_ptr(auto_ptr const&)
auto_ptr(auto_ptr&)

后贴再讲为什么需要auto_ptr_ref。

jianshen77 2003-10-13

打赏
举报

好像是sgid里的丫。我贴一下：
/*
* Copyright (c) 1997-1999
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/

#ifndef _STLP_AUTO_PTR_H
# define _STLP_AUTO_PTR_H

_STLP_BEGIN_NAMESPACE
// implementation primitive
class __ptr_base {
public:
void* _M_p;
void __set(const void* __p) { _M_p = __CONST_CAST(void*,__p); }
void __set(void* __p) { _M_p = __p; }
};

template <class _Tp> class auto_ptr_ref {
public:
__ptr_base& _M_r;
_Tp* const _M_p;

auto_ptr_ref(__ptr_base& __r, _Tp* __p) : _M_r(__r), _M_p(__p) { }

_Tp* release() const { _M_r.__set((void*)0); return _M_p; }

};

template<class _Tp> struct auto_ptr : public __ptr_base {

typedef _Tp element_type;
typedef auto_ptr<_Tp> _Self;

_Tp* release() {
_Tp* __px = this->get();
this->_M_p = 0;
return __px;
}

void reset(_Tp* __px=0) {
_Tp* __pt = this->get();
if (__px != __pt)
delete __pt;
this->__set(__px);
}

_Tp* get() const { return __REINTERPRET_CAST(_Tp*,__CONST_CAST(void*,_M_p)); }

# if !defined (_STLP_NO_ARROW_OPERATOR)
_Tp* operator->() const { return get(); }
# endif
_Tp& operator*() const { return *get(); }

auto_ptr() { this->_M_p = 0; }

explicit auto_ptr(_Tp* __px) { this->__set(__px); }

#if defined (_STLP_MEMBER_TEMPLATES)
# if OBSOLETE // def _STLP_MSVC
template<class _Tp1> auto_ptr(const auto_ptr<_Tp1>& __r) {
this->__set((_Tp1*)const_cast<auto_ptr<_Tp1> >(__r).release());
}
template<class _Tp1> auto_ptr<_Tp>& operator=(const auto_ptr<_Tp1>& __r) {
reset((_Tp1*)const_cast<auto_ptr<_Tp1> >(__r).release());
return *this;
}
# else
# if !defined (_STLP_NO_TEMPLATE_CONVERSIONS)
template<class _Tp1> auto_ptr(auto_ptr<_Tp1>& __r) {
this->__set((_Tp1*)__r.release());
}
# endif
template<class _Tp1> auto_ptr<_Tp>& operator=(auto_ptr<_Tp1>& __r) {
reset((_Tp1*)__r.release());
return *this;
}
# endif
#endif /* _STLP_MEMBER_TEMPLATES */

#ifdef OBSOLETE // def _STLP_MSVC
auto_ptr(const _Self& __r) { this->__set(const_cast<_Self&>(__r).release()); }

_Self& operator=(const _Self& __r) {
reset(const_cast<_Self&>(__r).release());
return *this;
}
#else
auto_ptr(_Self& __r) { this->__set(__r.release()); }

_Self& operator=(_Self& __r) {
reset(__r.release());
return *this;
}
#endif

~auto_ptr() { /* boris : reset(0) might be better */ delete this->get(); }

auto_ptr(auto_ptr_ref<_Tp> __r) {
this->__set(__r.release());
}

_Self& operator=(auto_ptr_ref<_Tp> __r) {
reset(__r.release());
return *this;
}

# if defined(_STLP_MEMBER_TEMPLATES) && !defined(_STLP_NO_TEMPLATE_CONVERSIONS)
template<class _Tp1> operator auto_ptr_ref<_Tp1>() {
return auto_ptr_ref<_Tp1>(*this, this->get());
}
template<class _Tp1> operator auto_ptr<_Tp1>() {
return auto_ptr<_Tp1>(release());
}
# else
operator auto_ptr_ref<_Tp>()
{ return auto_ptr_ref<_Tp>(*this, this->get()); }
# endif

};
_STLP_END_NAMESPACE

#endif /* _STLP_AUTO_PTR_H */

// Local Variables:
// mode:C++
// End:

xueweizhong 2003-10-13

打赏
举报

>to jianshen77(jianshen)
你用的是哪个编译器的哪个版本的auto_ptr:
template<class _Tp1> auto_ptr(const auto_ptr<_Tp1>& __r)
^^^^^^^^^^^^^^^^^^^^^
template<class _Tp1> auto_ptr(auto_ptr<_Tp1>& __r)
^^^^^^^^^^^^^^^
这两个构造函数都有？

如果都有的话，就很神奇了。

搞清楚这个问题先。请jianshen先回答一下。多谢。

Wolf0403 2003-10-11

打赏
举报

template<class _Ty>
struct auto_ptr_ref
{ // proxy reference for auto_ptr copying
auto_ptr_ref(auto_ptr<_Ty>& _Right)
: _Ref(_Right)
{ // construct from compatible auto_ptr
}

auto_ptr<_Ty>& _Ref; // reference to constructor argument
};

VC71 MEMORY 头文件里面来的，proxy reference for auto_ptr copying

Andy84920 2003-10-11

打赏
举报

这个是在什么书上介绍的?

还是库文件 ?

没看过哩!

xueweizhong 2003-10-10

打赏
举报

auto_ptr的拷贝构造函数是这个样子：
auto_ptr(auto_ptr& source);
（因为拷贝操作将改变source的内容：source失去对
指针的拥有权限）

因为non-const引用不能绑定到右值，
所以没有从rvalue auto_ptr到 auto_ptr的转换，
此时需要一个中间代理：auto_ptr_ref来完成：
rvalue auto_ptr --> auto_ptr_ref
--> auto_ptr的转换。

这里的事情有些复杂化，标准的不同部分解释会
有些不同，建议不要再细揪了。

cgsw12345 2003-10-10