链接:http://baike.baidu.com/view/3511189.htm?fr=aladdin 跟《C++标准程序库—自修教程与参考手册》上面的内容类似。
C++的auto_ptr所做的事情,就是动态分配对象以及当对象不再需要时自动执行清理。
使用std::auto_ptr,要#include <memory>。
它的源代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
|
template
<classT>
classauto_ptr{
private
:
T*ap;
public
:
//constructor&destructor-----------------------------------(1)
explicitauto_ptr(T*ptr=0)
throw
():ap(ptr){}
~auto_ptr()
throw
(){
deleteap;
}
//Copy&assignment--------------------------------------------(2)
auto_ptr(auto_ptr&rhs)
throw
():ap(rhs.release()){}
template
<classY>
auto_ptr(auto_ptr<Y>&rhs)
throw
():ap(rhs.release()){}
auto_ptr&operator=(auto_ptr&rhs)
throw
(){
reset(rhs.release());
return
*
this
;
}
template
<classY>
auto_ptr&operator=(auto_ptr<Y>&rhs)
throw
(){
reset(rhs.release());
return
*
this
;
}
//Dereference----------------------------------------------------(3)
T&operator*()constthrow(){
return
*ap;
}
T*operator->()constthrow(){
returnap;
}
//Helperfunctions------------------------------------------------(4)
//valueaccess
T*get()constthrow(){
returnap;
}
//releaseownership
T*release()
throw
(){
T*tmp(ap);
ap=0;
returntmp;
}
//resetvalue
voidreset(T*ptr=0)
throw
(){
if
(ap!=ptr){
deleteap;
ap=ptr;
}
}
//Specialconversions-----------------------------------------------(5)
template
<classY>
structauto_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
<classY>
operatorauto_ptr_ref<Y>()
throw
(){
returnauto_ptr_ref<Y>(release());
}
template
<classY>
operatorauto_ptr<Y>()
throw
(){
returnauto_ptr<Y>(release());
};
|
auto_ptr在构造时获取对某个对象的所有权(ownership),在析构时释放该对象。我们可以这样使用auto_ptr来提高代码安全性:
1
2
|
int
*p=newint(0);
auto_ptr<
int
>ap(p);
|
从此我们不必关心应该何时释放p,也不用担心发生异常会有内存泄漏。
这里我们有几点要注意:
1) 因为auto_ptr析构的时候肯定会删除他所拥有的那个对象,所有我们就要注意了,一个萝卜一个坑,两个auto_ptr不能同时拥有同一个对象。像这样:
1
2
3
|
int
*p=newint(0);
auto_ptr<
int
>ap1(p);
auto_ptr<
int
>ap2(p);
|
因为ap1与ap2都认为
指针p是归它管的,在析构时都试图删除p, 两次删除同一个对象的行为在C++标准中是未定义的。所以我们必须防止这样使用auto_ptr.
2) 考虑下面这种用法:
1
2
|
int
*pa=newint[10];
auto_ptr<
int
>ap(pa);
|
1
2
3
4
|
~auto_ptr()
throw
()
{
if
(ap)deleteap;
}
|
2 拷贝构造与赋值
与
引用计数型
智能指针不同的,auto_ptr要求其对“裸”指针的完全占有性。也就是说一个“裸”
指针不能同时被两个以上的auto_ptr所拥有。那么,在拷贝构造或赋值操作时,我们必须作特殊的处理来保证这个特性。auto_ptr的做法是“所有权转移”,即拷贝或赋值的源对象将失去对“裸”
指针的所有权,所以,与一般
拷贝构造函数,
赋值函数不同, auto_ptr的拷贝构造函数,
赋值函数的参数为引用而不是常引用(const reference).当然,一个auto_ptr也不能同时拥有两个以上的“裸”指针,所以,拷贝或赋值的目标对象将先释放其原来所拥有的对象。
这里的注意点是:
1) 因为一个auto_ptr被拷贝或被赋值后, 其已经失去对原对象的所有权,这个时候,对这个auto_ptr的提领(dereference)操作是不安全的。如下:
1
2
3
4
|
int
*p=newint(0);
auto_ptr<
int
>ap1(p);
auto_ptr<
int
>ap2=ap1;
cout<<*ap1;
//错误,此时ap1只剩一个null指针在手了
|
这种情况较为隐蔽的情形出现在将auto_ptr作为函数参数按值传递,因为在
函数调用过程中在函数的
作用域中会产生一个局部对象来接收传入的auto_ptr(拷贝构造),这样,传入的
实参auto_ptr就失去了其对原对象的所有权,而该对象会在函数退出时被局部auto_ptr删除。如下:
1
2
3
4
|
voidf(auto_ptr<
int
>ap){cout<<*ap;}
auto_ptr<
int
>ap1(newint(0));
f(ap1);
cout<<*ap1;
//错误,经过f(ap1)函数调用,ap1已经不再拥有任何对象了。
|
因为这种情况太隐蔽,太容易出错了, 所以auto_ptr作为函数参数按值传递是一定要避免的。或许大家会想到用auto_ptr的
指针或引用作为函数参数或许可以,但是仔细想想,我们并不知道在函数中对传入的auto_ptr做了什么, 如果当中某些操作使其失去了对对象的所有权, 那么这还是可能会导致致命的执行期错误。 也许,用const reference的形式来传递auto_ptr会是一个不错的选择。
2)我们可以看到
拷贝构造函数与赋值函数都提供了一个成员模板在不覆盖“正统”版本的情况下实现auto_ptr的隐式转换。如我们有以下两个类
1
2
|
classbase{};
classderived:publicbase{};
|
那么下列代码就可以通过,实现从auto_ptr<derived>到auto_ptr<base>的隐式转换,因为derived*可以转换成base*类型
1
|
auto_ptr<base>apbase=auto_ptr<derived>(newderived);
|
3) 因为auto_ptr不具有值语义(value semantic), 所以auto_ptr不能被用在stl标准容器中。
所谓值语义,是指符合以下条件的类型(假设有类A):
1
2
3
4
5
6
|
Aa1;
Aa2(a1);
Aa3;
a3=a1;
//那么
a2==a1,a3==a1
|
很明显,auto_ptr不符合上述条件,而我们知道stl标准容器要用到大量的拷贝赋值操作,并且假设其操作的类型必须符合以上条件。
3 提领操作(dereference)
提领操作有两个操作, 一个是返回其所拥有的对象的引用, 另一个则是实现了通过auto_ptr调用其所拥有的对象的成员。如:
1
2
3
4
5
6
7
|
structA
{
voidf();
}
auto_ptr<A>apa(newA);
(*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也能被拷贝和赋值。如下:
1
|
auto_ptr<
int
>ap1=auto_ptr<
int
>(newint(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(),转换成功。
6)调用auto_ptr(auto_ptr_ref<T>rhs)throw()完成auto_ptr_ref向auto_ptr的构造。
从而通过一个间接类成功的实现了拷贝构造右值(临时对象)
同时,这个辅助方法不会使const auto_ptr被拷贝, 原因是在第5步, 此
类型转换函数为non-const的,我们知道,const对象是无法调用non-const成员的, 所以转换失败。当然, 这里有一个问题要注意, 假设你把这些辅助转换的代码注释掉,该行代码还是可能成功编译,这是为什么呢?debug一下, 我们可以发现只调用了一次
构造函数,而
拷贝构造函数并没有被调用,原因在于
编译器将
代码优化掉了。这种类型优化叫做returned value optimization,它可以有效防止一些无意义的临时对象的构造。当然,前提是你的
编译器要支持returned value optimization。