auto_ptr详解
auto_ptr详解
auto_ptr指针介绍
auto_ptr是这样一种指针：它是“它所指向的对象”的拥有者。这种拥有具有唯一性，即一个对象只能有一个拥有者，严禁一物二主。当auto_ptr指针被摧毁时，它所指向的对象也将被隐式销毁，即使程序中有异常发生，auto_ptr所指向的对象也将被销毁。
1、设计动机：
在函数中通常要获得一些资源，执行完动作后，然后释放所获得的资源，当程序员忘记释放所申请的到的资源，或者由于异常发生而没有正常释放资源时，这就将产生一系列的内存泄漏问题。
因此，你可能将函数写成如下形式：
void fun()
{
try
{
T *ptr = new T;
......
}catch(...)
{
delete ptr;
throw;
}
delete ptr;
}
这样使程序变得太过复杂。使用auto_ptr可以使上述程序简化为：
void fun()
{
auto_ptr<T> ptr(new T);
......
}
不再需要delete，也不再需要catch了。与上面的程序相比，这个非常简单。
auto_ptr是一个模板类，适合于任何类型，其接口行为与普通指针相似，opeator *用来提取其所指向对象的值。operator->用来指向对象中的成员。但是，他没有定义任何的算术运算（包括++）。
由于auto_ptr定义中“用一般指针构造一个auto_ptr”的构造函数被声明为explicit（拒绝隐式变换），所以一下的方式是错误的：
auto_ptr<int> ptr = new int(0); // 错
必须这样：
auto_ptr<int> ptr(new int(0)); //正确
2、auto_ptr拥有权的转移
由于auto_ptr指针唯一性，即一个对象只能有一个auto_ptr指针所指向它。因此，当auto_ptr以传值方式被作为参数传递给某函数时，这时对象的原来拥有者（实参）就放弃了对象的拥有权，把它转移到被调用函数中的参数（形参）上，如果函数不再将拥有权传递出去，由于形参的作用域仅仅为函数内部，当函数退出时，它所指向的对象将被销毁。当函数返回一个auto_ptr时，其拥有权又被转移到了调用端。
因此，应该尽量不要在参数中使用auto_ptr指针，我们也不要通过引用传递auto_ptr。
当然一个方法是我们可以通过使用常量引用来实现auto_ptr的传递，我们也可以声明一个const auto_ptr指针，这样将使auto_ptr不能转移它的拥有权。
例如：
void print(auto_ptr<int> ptr);
const auto_ptr<int> p(new int(0));
*p = 10;
print(p); //编译时发生错误
当auto_ptr被使用最为一个类成员时，由于其可能发生拥有权转移的问题，所以你必须亲自写复制构造函数和复制运算操作符。
3、auto_ptr的错误运用：
1)、auto_ptr之间不能共享一个对象。一个auto_ptr不能指向另一个auto_ptr所指向的的对象。否则，当第一个指针删除该对象时，林一个指针马上就指向了一个已经被销毁的对象，那么，如果在使用该指针，就会引发某些错误。
2)、并不存在针对array而设计的auto_ptr。auto_ptr不可以指向一个array，因为auto_ptr是通过delete而不是delete[]来释放其所拥有的资源的。
3)、auto_ptr绝非是一个通用的智能指针。并非任何适用智能型指针地方都可以适用auto_ptr指针。
4)、auto_ptr不满足STL容器对其元素的要求。因为在拷贝和赋值动作以后，原本的auto_ptr和新产生的auto_ptr并不相等，在拷贝和赋值之后，原本的auto_ptr会交出拥有权，而不是拷贝给新的auto_ptr。因此，决不要将auto_ptr作为标准容器的元素。
以下附auto_ptr部分源代码：
template <class T>
class auto_ptr
{
private:
T * ptr;
public:
typedef T element_type;
explicit auto_ptr(T* __p = 0) throw() : ptr(__p) {}
auto_ptr(auto_ptr& __a) throw() : ptr(__a.release()) {}
template <class _Tp1>
auto_ptr(auto_ptr<_Tp1>& __a) throw(): ptr(__a.release()) {}
auto_ptr& operator=(auto_ptr& __a) throw()
{
if (&__a != this)
{
delete ptr;
ptr = __a.release();
}
return *this;
}
template <class _Tp1>
auto_ptr& operator=(auto_ptr<_Tp1>& __a)throw()
{
if (__a.get() != this->get())
{
delete ptr;
ptr = __a.release();
}
return *this;
}
~auto_ptr() throw() { delete ptr; }
T& operator*() const throw() { return *ptr; }
T* operator->() const throw() { return ptr; }
T* get() const throw() { return ptr; }
T* release() throw()
{
T* __tmp = ptr;
ptr = 0;
return __tmp;
}
void reset(T* __p = 0) throw()
{
delete ptr;
ptr = __p;
}
}
auto_ptr使用入门与注意事项：
1、auto_ptr不能共享所有权(auto_ptr在被复制的时候会传输所有)。
An auto_ptr must not refer to an object that is owned by another auto_ptr (or other object).
下面的程序说明了所有权的问题：
//util/autoptr1.cpp
#include <iostream>
#include <memory>
using namespace std;
/* define output operator for auto_ptr
* - print object value or NULL
*/
template <class T>
ostream& operator<< (ostream& strm, const auto_ptr<T>& p)
{
//does p own an object ?
if (p.get() == NULL) {
strm << "NULL"; //NO: print NULL
}
else {
strm << *p; //YES: print the object
}
return strm;
}
int main()
{
auto_ptr<int> p(new int(42));
auto_ptr<int> q;
cout << "after initialization:" << endl;
cout << " p: " << p << endl;
cout << " q: " << q << endl;
q = p;
cout << "after assigning auto pointers:" << endl;
cout << " p: " << p << endl;
cout << " q: " << q << endl;
*q += 13; //change value of the object q owns
p = q;
cout << "after change and reassignment:" << endl;
cout << " p: " << p << endl;
cout << " q: " << q << endl;
}
The output of the program is as follows:
after initialization:
p: 42
q: NULL
after assigning auto pointers:
p: NULL
q: 42
after change and reassignment:
p: 55
q: NULL
2、auto_ptr不能指向数组。
3、auto_ptr不能作为容器的成员。
4、不能通过赋值操作来初始化auto_ptr
std::auto_ptr<int> p(new int(42)); //OK
std::auto_ptr<int> p = new int(42); //ERROR
这是因为auto_ptr 的构造函数被定义为了explicit
5、下面的程序说明了 const auto_ptr的行为：
const auto_ptr与 type * const ptr;相似
//util/autoptr2.cpp
#include <iostream>
#include <memory>
using namespace std;
/* define output operator for auto_ptr
* - print object value or NULL
*/
template <class T>
ostream& operator<< (ostream& strm, const auto_ptr<T>& p)
{
//does p own an object ?
if (p.get() == NULL) {
strm << "NULL"; //NO: print NULL
}
else {
strm << *p; //YES: print the object
}
return strm;
}
int main()
{
const auto_ptr<int> p(new int(42));
const auto_ptr<int> q(new int(0));
const auto_ptr<int> r;
cout << "after initialization:" << endl;
cout << " p: " << p << endl;
cout << " q: " << q << endl;
cout << " r: " << r << endl;
*q = *p;
// *r = *p; //ERROR: undefined behavior
*p = -77;
cout << "after assigning values:" << endl;
cout << " p: " << p << endl;
cout << " q: " << q << endl;
cout << " r: " << r << endl;
// q = p; //ERROR at compile time
// r = p; //ERROR at compile time
}
Here, the output of the program is as follows:
after initialization:
p: 42
q: 0
r: NULL
after assigning values:
p: -77
q: 42
r: NULL
auto_ptr 类的函数
1）默认构造函数
auto_ptr<int> pNum; // 没有指向任何对象
*pNum = 100; // 错误
2）get 函数，返回指向对象的指针
if (NULL == pNum.get()) // 指针是否为空
注意，对于处于非绑定状态的 auto_ptr 调用 get 将返回 0。不要做这样的操作：
auto_ptr<int> pNum2(pNum1.get()); // 没有转交所有权
那么 pNum1 管理的指针将被析构两次，这必然带来严重的后果。
3）reset 函数，重设需要管理的指针，首先 auto_ptr 会删除当前管理的对象，然后再设置新的对象的指针。另外：
pNum = pNum; // 不会发送任何事情，安全
pNum.reset(pNum->get()); // 不会发送任何事情，安全
4）release 函数释放所有权，返回它管理的指针，不删除指针指向的对象：
auto_ptr<int> pNum2(pNum1.release()); // 等同于下句
auto_ptr<int> pNum2(pNum1); // 等同于上句
6. 编译器的问题
vc6 下的 auto_ptr 并不是标准的，例如：
std::auto_ptr<std::string> ap1(new std::string("Pterodactry"));
std::auto_ptr<std::string> ap2(ap1);
std::cout << *ap2 << std::endl; // 正常执行
7. 被管理的类的析构函数
如果被管理的类的析构函数为私有的，那么将无法使用 auto_ptr。
最后，附上 SGI 的 auto_ptr 源码：
template <class _Tp> class auto_ptr {
private:
_Tp* _M_ptr;
public:
typedef _Tp element_type;
explicit auto_ptr(_Tp* __p = 0) __STL_NOTHROW : _M_ptr(__p) {}
auto_ptr(auto_ptr& __a) __STL_NOTHROW : _M_ptr(__a.release()) {}
#ifdef __STL_MEMBER_TEMPLATES
template <class _Tp1> auto_ptr(auto_ptr<_Tp1>& __a) __STL_NOTHROW
: _M_ptr(__a.release()) {}
#endif /* __STL_MEMBER_TEMPLATES */
auto_ptr& operator=(auto_ptr& __a) __STL_NOTHROW {
if (&__a != this) {
delete _M_ptr;
_M_ptr = __a.release();
}
return *this;
}
#ifdef __STL_MEMBER_TEMPLATES
template <class _Tp1>
auto_ptr& operator=(auto_ptr<_Tp1>& __a) __STL_NOTHROW {
if (__a.get() != this->get()) {
delete _M_ptr;
_M_ptr = __a.release();
}
return *this;
}
#endif /* __STL_MEMBER_TEMPLATES */
// Note: The C++ standard says there is supposed to be an empty throw
// specification here, but omitting it is standard conforming. Its
// presence can be detected only if _Tp::~_Tp() throws, but (17.4.3.6/2)
// this is prohibited.
~auto_ptr() { delete _M_ptr; }
_Tp& operator*() const __STL_NOTHROW {
return *_M_ptr;
}
_Tp* operator->() const __STL_NOTHROW {
return _M_ptr;
}
_Tp* get() const __STL_NOTHROW {
return _M_ptr;
}
_Tp* release() __STL_NOTHROW {
_Tp* __tmp = _M_ptr;
_M_ptr = 0;
return __tmp;
}
void reset(_Tp* __p = 0) __STL_NOTHROW {
if (__p != _M_ptr) {
delete _M_ptr;
_M_ptr = __p;
}
}
// According to the C++ standard, these conversions are required. Most
// present-day compilers, however, do not enforce that requirement---and,
// in fact, most present-day compilers do not support the language
// features that these conversions rely on.
#if defined(__SGI_STL_USE_AUTO_PTR_CONVERSIONS) && /
defined(__STL_MEMBER_TEMPLATES)
public:
auto_ptr(auto_ptr_ref<_Tp> __ref) __STL_NOTHROW
: _M_ptr(__ref._M_ptr) {}
auto_ptr& operator=(auto_ptr_ref<_Tp> __ref) __STL_NOTHROW {
if (__ref._M_ptr != this->get()) {
delete _M_ptr;
_M_ptr = __ref._M_ptr;
}
return *this;
}
template <class _Tp1> operator auto_ptr_ref<_Tp1>() __STL_NOTHROW
{ return auto_ptr_ref<_Tp1>(this->release()); }
template <class _Tp1> operator auto_ptr<_Tp1>() __STL_NOTHROW
{ return auto_ptr<_Tp1>(this->release()); }
#endif /* auto ptr conversions && member templates */
};