auto_ptr_ref和auto_ptr的关系 .

auto_ptr_ref和auto_ptr的关系

 

这是C++新闻组上一篇文章。它很好的解释了auto_ptr_ref和auto_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'应该从标准中被剔除得到了法国的赞成票，一些其他

国家一定程度上也有类似的想法。所以，Greg和Bill提出了'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();

}