转自 http://baike.baidu.com/link?url=UMhUcMPGPFPhqwGQTTuISe_pdlLpjmjP5y9_lpxhBi6ELVbkvE0JZbJjQLH-quA-PKlatXAC2othjZ2rRupc0a
auto_ptr
C++的auto_ptr所做的事情，就是动态分配对象以及当对象不再需要时自动执行清理。
它的源代码：
template <class T>
class auto_ptr {
private:
T* ap;
public:
// constructor & destructor ----------------------------------- (1)
explicit auto_ptr (T* ptr = 0) throw() : ap(ptr) { }
~auto_ptr() throw() {
delete ap;
}
// Copy & assignment --------------------------------------------(2)
auto_ptr (auto_ptr& rhs) throw() : ap(rhs.release()) { }
template <class Y>
auto_ptr(auto_ptr<Y>& rhs) throw() : ap(rhs.release()) { }
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;
}
// Dereference----------------------------------------------------(3)
T& operator*() const throw() {
return *ap;
}
T* operator->() const throw() {
return ap;
}
// Helper functions------------------------------------------------(4)
// value access
T* get() 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-----------------------------------------------(5)
template<class Y>
struct auto_ptr_ref {
Y* yp;
auto_ptr_ref(Y* rhs) : yp(rhs) { }
};
auto_ptr(auto_ptr_ref<T> rhs) throw() : ap(rhs.yp) { }
auto_ptr& operator= (auto_ptr_ref<T> rhs) throw() {
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());
auto_ptr在构造时获取对某个对象的所有权(ownership),在析构时释放该对象。我们可以这样使用auto_ptr来提高代码安全性：
int* p = new int(0);
auto_ptr<int> ap(p);
从此我们不必关心应该何时释放p， 也不用担心发生异常会有内存泄漏。
这里我们有几点要注意：
1) 因为auto_ptr析构的时候肯定会删除他所拥有的那个对象，所有我们就要注意了，一个萝卜一个坑，两个auto_ptr不能同时拥有同一个对象。像这样：
int* p = new int(0);
auto_ptr<int> ap1(p);
auto_ptr<int> ap2(p);
因为ap1与ap2都认为
指针p是归它管的，在析构时都试图删除p, 两次删除同一个对象的行为在C++标准中是未定义的。所以我们必须防止这样使用auto_ptr.
2) 考虑下面这种用法：
int* pa = new int[10];
auto_ptr<int> ap(pa);
~auto_ptr() throw()
{
if(ap) delete ap;
}
2 拷贝构造与赋值
与
引用计数型
智能指针不同的，auto_ptr要求其对“裸”指针的完全占有性。也就是说一个”裸“
指针不能同时被两个以上的auto_ptr所拥有。那么，在拷贝构造或赋值操作时，我们必须作特殊的处理来保证这个特性。auto_ptr的做法是“所有权转移”，即拷贝或赋值的源对象将失去对“裸”
指针的所有权，所以，与一般
拷贝构造函数，
赋值函数不同， auto_ptr的拷贝构造函数，
赋值函数的参数为引用而不是常引用(const reference).当然，一个auto_ptr也不能同时拥有两个以上的“裸”指针，所以，拷贝或赋值的目标对象将先释放其原来所拥有的对象。
这里的注意点是：
1) 因为一个auto_ptr被拷贝或被赋值后， 其已经失去对原对象的所有权，这个时候，对这个auto_ptr的提领(dereference)操作是不安全的。如下:
int* p = new int(0);
auto_ptr<int> ap1(p);
auto_ptr<int> ap2 = ap1;
cout << *ap1; //错误，此时ap1只剩一个null
指针在手了
这种情况较为隐蔽的情形出现在将auto_ptr作为函数参数按值传递，因为在
函数调用过程中在函数的
作用域中会产生一个局部对象来接收传入的auto_ptr(拷贝构造)，这样，传入的
实参auto_ptr就失去了其对原对象的所有权，而该对象会在函数退出时被局部auto_ptr删除。如下：
void f(auto_ptr<int> ap){cout<<*ap;}
auto_ptr<int> ap1(new int(0));
f(ap1);
cout << *ap1; //错误，经过f(ap1)
函数调用，ap1已经不再拥有任何对象了。
因为这种情况太隐蔽，太容易出错了， 所以auto_ptr作为函数参数按值传递是一定要避免的。或许大家会想到用auto_ptr的
指针或引用作为函数参数或许可以，但是仔细想想，我们并不知道在函数中对传入的auto_ptr做了什么， 如果当中某些操作使其失去了对对象的所有权， 那么这还是可能会导致致命的执行期错误。 也许，用const reference的形式来传递auto_ptr会是一个不错的选择。
2)我们可以看到
拷贝构造函数与赋值函数都提供了一个成员模板在不覆盖“正统”版本的情况下实现auto_ptr的隐式转换。如我们有以下两个类
class base{};
class derived: public base{};
那么下列代码就可以通过，实现从auto_ptr<derived>到auto_ptr<base>的隐式转换，因为derived*可以转换成base*类型
auto_ptr<base> apbase = auto_ptr<derived>(new derived);
3) 因为auto_ptr不具有值语义(value semantic), 所以auto_ptr不能被用在stl标准容器中。
所谓值语义，是指符合以下条件的类型(假设有类A)：
A a1;
A a2(a1);
A a3;
a3 = a1;
那么
a2 == a1, a3 == a1
很明显，auto_ptr不符合上述条件，而我们知道stl标准容器要用到大量的拷贝赋值操作，并且假设其操作的类型必须符合以上条件。
3 提领操作(dereference)
提领操作有两个操作， 一个是返回其所拥有的对象的引用， 另一个是则实现了通过auto_ptr调用其所拥有的对象的成员。如：
struct A
{
void f();
}
auto_ptr<A> apa(new A);
(*apa).f();
apa->f();
当然， 我们首先要确保这个
智能指针确实拥有某个对象，否则，这个操作的行为即对空指针的提领是未定义的。
4 辅助函数
1) get用来显式的返回auto_ptr所拥有的
对象指针。我们可以发现，标准库提供的auto_ptr既不提供从“裸”
指针到auto_ptr的隐式转换(
构造函数为explicit),也不提供从auto_ptr到“裸”指针的隐式转换，从使用上来讲可能不那么的灵活， 考虑到其所带来的安全性还是值得的。
2) release,用来转移所有权
3) reset，用来接收所有权，如果接收所有权的auto_ptr如果已经拥有某对象，必须先释放该对象。
5 特殊转换
这里提供一个辅助类auto_ptr_ref来做特殊的转换，按照标准的解释， 这个类及下面4个函数的作用是：使我们得以拷贝和赋值non-const auto_ptrs， 却不能拷贝和赋值const auto_ptrs. 我无法非常准确的理解这两句话的意义，但根据我们观察与试验，应该可以这样去理解：没有这些代码，我们本来就可以拷贝和赋值non-const的auto_ptr和禁止拷贝和赋值const的auto_ptr的功能， 只是无法拷贝和赋值临时的auto_ptr(右值)， 而这些辅助代码提供某些转换，使我们可以拷贝和赋值临时的auto_ptr，但并没有使const的auto_ptr也能被拷贝和赋值。如下：
auto_ptr<int> ap1 = auto_ptr<int>(new int(0));
auto_ptr<int>(new int(0))是一个临时对象，一个右值，一般的
拷贝构造函数当然能拷贝右值，因为其参数类别必须为一个const reference, 但是我们知道，auto_ptr的拷贝函数其参数类型为reference，所以，为了使这行代码能通过，我们引入auto_ptr_ref来实现从右值向
左值的转换。其过程为：
1) ap1要通过拷贝 auto_ptr<int>(new int(0))来构造自己
2) auto_ptr<int>(new int(0))作为右值与现有的两个
拷贝构造函数参数类型都无法匹配，也无法转换成该种参数类型
3) 发现辅助的
拷贝构造函数auto_ptr(auto_ptr_ref<T> rhs) throw()
4) 试图将auto_ptr<int>(new int(0))转换成auto_ptr_ref<T>
5) 发现
类型转换函数operator auto_ptr_ref<Y>() throw()， 转换成功，从而拷贝成功。
从而通过一个间接类成功的实现了拷贝构造右值（临时对象）
同时，这个辅助方法不会使const auto_ptr被拷贝， 原因是在第5步， 此
类型转换函数为non-const的，我们知道，const对象是无法调用non-const成员的， 所以转换失败。当然， 这里有一个问题要注意， 假设你把这些辅助转换的代码注释掉，该行代码还是可能成功编译，这是为什么呢？debug一下， 我们可以发现只调用了一次
构造函数，而
拷贝构造函数并没有被调用，原因在于
编译器将
代码优化掉了。这种类型优化叫做returned value optimization，它可以有效防止一些无意义的临时对象的构造。当然，前提是你的
编译器要支持returned value optimization。
关于
5 特殊转换一直无法理解。。。
扫一扫
2156
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
