CSDN博客

img codingcoding

auto_ptr_ref和auto_ptr的关系

发表于2003/5/2 9:16:00  1616人阅读

 

auto_ptr_refauto_ptr的关系

 

这是C++新闻组上一篇文章。它很好的解释了auto_ptr_refauto_ptr的之间的关系。

你可以在google上查找 auto_ptr_ref - anyone know what it's about?”这个主题。

此文章有删节。

 

1 问:

ANSI/ISO C++标准,我有两个问题,关于  auto_ptr的帮助类auto_ptr_ref

1)这个类的意图是什么。

2) 它怎样工作。

 

2 答:

1

在最初的提议中,'auto_ptr'的语义被打破,是因为这个类型的'const'对象的情况。

最初的建议是有一个以'const&'作为参数的拷贝构造函数。,然而,这会导致一些惊人

之事。,例如:

//这仅仅是为了体现原是的意图。它不是一个标准的版本。

void f(std::auto_ptr<int> const& ap) {

std::auto_ptr<int> api(ap);

// ...

}

int main() {

std::auto_ptr<int> const ai(new int(17));

f(ai);

// oops! 'ai' 不在拥有一个指针。 再次说明,这不是标准版本的行为。

}

基本上,这样的规则破坏了一个带有'const&'的拷贝构造函数。甚至于有其他做法会带来

更坏的结果。最后,主要是法国代表团他们想要一个这样地'auto_ptr'

-没有带'autor_ptr<T const&>'作为参数地拷贝构造函数。

-允许'std::auto_ptr<T> ap(f());'这样地用法。在这里,'f()'返回一个

'std::auto_ptr<T>'.

...或者,为了c++标准,把'auto_ptr'应该从标准中被剔除得到了法国的赞成票,一些其他

国家一定程度上也有类似的想法。所以,GregBill提出了'auto_ptr_ref'的想法,这样所有的一切都变得美好了。在他们的第一次陈述中,每个人都很惊奇于这个竟然能够工作。但是它能,并且所有的一切都很好。

2) 它怎样工作?

它所做的事情是,它使的从一个临时量(例如,从一个函数返回)通过一个不带'const&'做参

数的拷贝构造函数来构造一个'auto_ptr'对象成为可能。问题是,你不能传递一个临时变量

到一个带'&'的函数(也就是说,一个非常量的引用(non-const reference))作为参数。即

使它不是一个构造函数。并且你不能通过值传递来定义一个拷贝构造函数,因为这里也需要一

个拷贝构造函数。所以,这个是怎样完成的呢?

 

窍门是通过两个用户的定义转换,也就是从'auto_ptr' 'auto_ptr_ref'再到'auto_ptr'

正常的第一反应是“但是这里只有一个用户定义的转换呀”,这是完全正确的并且也能被

'auto_ptr'所掌握。所以,这个怎样工作呢?,好,再这个处理中,两个对象被构造,也

就是说一个临时量被当作函数和一个'auto_ptr'的结果。关于临时量的类型没有什么好说

的,窍门是:从一个'auto_ptr'的返回的被放在堆栈上的临时量,它不是一个'auto_ptr'

而是一个'auto_ptr_ref'(编译器的表示是:对于用户来说这个看上去象任何其他函数返回

一个对象).这是明白无误的,因为有一个用户定义的从'auto_ptr' to 'auto_ptr_ref'

转换。现在,在堆栈上有一个'auto_ptr_ref'而不是'auto_ptr'需要被构造。这是很容易

的,因为有一个'auto_ptr'构造函数,参数是'auto_ptr_ref'类型的对象。这个就是第二

个转换,但是再这一点上用户只仅仅定义了一个转换参数。这就是它的全部。我省略了一些

关于当维护指针的所有权被转移给别人的细节,但是这个仅仅做一些薄记工作就行了。我们

感兴趣的部分是两个转换是为什么'auto_ptr_ref'要被引进的原因的。Greg Bill的实现

真是cool

 

 

//译者:

//这个程序是在http://www.c-view.org/tech/pattern/cpptips/auto_ptr_ref上的,我仅仅

//列出它。

 

#include <iostream.h>

 

class auto_ptr

{

private:

struct auto_ptr_ref { };

 

public:

auto_ptr() { cout << "auto_ptr::auto_ptr()/n"; }

auto_ptr(auto_ptr&) { cout << "auto_ptr::auto_ptr(auto_ptr&)/n"; }

operator auto_ptr_ref()

{ cout << "auto_ptr::operator auto_ptr_ref()/n"; }

auto_ptr(auto_ptr_ref) { cout <<

"auto_ptr::auto_ptr(auto_ptr_ref)/n"; }

~auto_ptr() { cout << "auto_ptr::~auto_ptr()/n"; }

};

 

 

auto_ptr function1();

auto_ptr function2();

 

 

int main()

{

auto_ptr f1=function1(); // calls function function1(), see below now

// looks for "auto_ptr::auto_ptr(const auto_ptr&)", not found

// can't use "auto_ptr::auto_ptr(auto_ptr&)"

// because return value of 'function1()' is a temporary

// so consider two-step routes now

// 1) use "auto_ptr::operator auto_ptr_ref()"

// 2) use "auto_ptr::auto_ptr(auto_ptr_ref)" to construct 'f1'

// call to "auto_ptr::~auto_ptr()" to destroy return of 'function1()'

 

cout << "after1/n";

 

auto_ptr f2=function2(); // figure this one out yourself

cout << "after2/n";

 

} // 2 calls to "auto_ptr::~auto_ptr()" to destroy 'f1' and 'f2'

 

 

auto_ptr function1() // comments assume no return value optimization

{

auto_ptr a; // call to "auto_ptr::auto_ptr()"

return a; // call to "auto_ptr::auto_ptr(auto_ptr&)"

} // call to "auto_ptr::~auto_ptr()" to destroy 'a'

 

auto_ptr function2() // figure this one out yourself, uses auto_ptr_ref

{

return auto_ptr();

}

0 0

相关博文

我的热门文章

img
取 消
img