auto_ptr 类

在资源周围包装智能指针，确保在块失去控制权时自动销毁该资源。

从 C++11 开始，使用 unique_ptr 而不是 auto_ptr。 有关详细信息，请参阅 unique_ptr 类。 auto_ptr 在 C++11 中已弃用，并且已在 C++17 中移除。

有关 throw() 和异常处理的详细信息，请参阅异常规范（引发）。

语法

class auto_ptr {
    typedef Type element_type;
    explicit auto_ptr(Type* ptr = 0) throw();
    auto_ptr(auto_ptr<Type>& right) throw()
        ;
    template <class Other>
    operator auto_ptr<Other>() throw();
    template <class Other>
    auto_ptr<Type>& operator=(auto_ptr<Other>& right) throw();
    template <class Other>
    auto_ptr(auto_ptr<Other>& right);
    auto_ptr<Type>& operator=(auto_ptr<Type>& right);
    ~auto_ptr();
    Type& operator*() const throw();
    Type * operator->()const throw();
    Type *get() const throw();
    Type *release()throw();
    void reset(Type* ptr = 0);
};

参数

right
可从中获取现有资源的 auto_ptr。

ptr
指定用于替换存储的指针 的指针。

备注

此类模板描述指向已分配对象的智能指针（名为 auto_ptr）。 指针必须为 Null 或指定 new 所分配的对象。 如果 auto_ptr 的存储值已分配给其他对象，则它将转移所有权。 （它在与空指针进行转移后替换存储值。）auto_ptr<Type> 的析构函数将删除已分配的对象。 auto_ptr<Type> 可确保在块失去控制权时（甚至在已引发异常的情况下）自动删除已分配的对象。 不应构造两个拥有相同对象的 auto_ptr<Type> 对象。

可以将 auto_ptr<Type> 对象作为函数调用的参数按值传递。 auto_ptr 不能是任何标准库容器的元素。 你无法使用 C++ 标准库容器可靠地管理一系列 auto_ptr<Type> 对象。

成员

构造函数

名称	描述
auto_ptr	auto_ptr 类型的对象的构造函数。

Typedef

名称	描述
element_type	该类型是模板参数 Type 的同义词。

函数

名称	描述
get	该成员函数将返回存储的指针 myptr。
release	该成员将存储的指针 myptr 替换为 Null 指针，并返回以前存储的指针。
reset	此成员函数对表达式 delete myptr 进行求值，但仅在存储的指针值 myptr 因函数调用而更改时进行。 然后它将存储的指针替换为 ptr。

运算符

名称	描述
operator=	一个赋值运算符，用于将所有权从一个 auto_ptr 对象转移到到其他对象。
operator*	auto_ptr 类型的对象的取消引用运算符。
operator->	允许成员访问的运算符。
operator auto_ptr<Other>	将某种 auto_ptr 强制转换为另一种 auto_ptr。
operator auto_ptr_ref<Other>	将 auto_ptr 强制转换为 auto_ptr_ref。

auto_ptr

auto_ptr 类型的对象的构造函数。

explicit auto_ptr(Type* ptr  = 0) throw();

auto_ptr(auto_ptr<Type>& right) throw();

auto_ptr(auto _ptr_ref<Type> right) throw();

template <class Other>
auto _ptr(auto _ptr<Other>& right) throw();

参数

ptr
指向 auto_ptr 封装的对象的指针。

right
由构造函数复制的 auto_ptr 对象。

备注

第一个构造函数将 ptr 存储在 myptr，存储的指针指向已分配的对象。 第二个构造函数通过存储 right 转移 right 中存储的指针的所有权。 在 myptr 中发布。

第三个构造函数的行为与第二个相同，只不过它存储 right。 ref。 myptr 中的 release，其中 ref 是存储在 right 中的引用。

如果指向 Other 的指针可以隐式转换为指向 Type 的指针，则模板构造函数的行为与第二个构造函数相同。

示例

// auto_ptr_auto_ptr.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>

using namespace std;

class Int
{
public:
   Int(int i)
   {
      cout << "Constructing " << ( void* )this  << endl;
      x = i;
      bIsConstructed = true;
   };
   ~Int( )
   {
      cout << "Destructing " << ( void* )this << endl;
      bIsConstructed = false;
   };
   Int &operator++( )
   {
      x++;
      return *this;
   };
   int x;
private:
   bool bIsConstructed;
};

void function ( auto_ptr<Int> &pi )
{
   ++( *pi );
   auto_ptr<Int> pi2( pi );
   ++( *pi2 );
   pi = pi2;
}

int main( )
{
   auto_ptr<Int> pi ( new Int( 5 ) );
   cout << pi->x << endl;
   function( pi );
   cout << pi->x << endl;
}

Constructing 00311AF8
5
7
Destructing 00311AF8

element_type

该类型是模板参数 Type 的同义词。

typedef Type element  _type;

get

该成员函数将返回存储的指针 myptr。

Type *get() const throw();

返回值

存储的指针 myptr。

示例

// auto_ptr_get.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>
using namespace std;

class Int
{
public:
   Int(int i)
   {
      x = i;
      cout << "Constructing " << ( void* )this  << " Value: " << x << endl;
   };
   ~Int( )
   {
      cout << "Destructing " << ( void* )this << " Value: " << x << endl;
   };

   int x;

};

int main( )
{
   auto_ptr<Int> pi ( new Int( 5 ) );
   pi.reset( new Int( 6 ) );
   Int* pi2 = pi.get ( );
   Int* pi3 = pi.release ( );
   if (pi2 == pi3)
      cout << "pi2 == pi3" << endl;
   delete pi3;
}

Constructing 00311AF8 Value: 5
Constructing 00311B88 Value: 6
Destructing 00311AF8 Value: 5
pi2 == pi3
Destructing 00311B88 Value: 6

operator=

一个赋值运算符，用于将所有权从一个 auto_ptr 对象转移到到其他对象。

template <class Other>
    auto_ptr<Type>& operator=(auto_ptr<Other>& right) throw();
auto_ptr<Type>& operator=(auto_ptr<Type>& right) throw();
auto_ptr<Type>& operator=(auto_ptr_ref<Type> right) throw();

参数

right
一个 auto_ptr 类型的对象。

返回值

对类型为 auto_ptr<Type> 的对象的引用。

备注

赋值将对表达式 delete myptr 进行求值，但只有在存储的指针 myptr 因赋值而发生更改时才进行。 然后，它通过存储 right 来转移存储在 right 中的指针的所有权。myptr 中的 release。 该函数返回 *this。

示例

有关成员运算符的用法示例，请参阅 auto_ptr。

operator*

auto_ptr 类型的对象的取消引用运算符。

Type& operator*() const throw();

返回值

对指针所拥有的类型 Type 的对象的引用。

注解

间接运算符返回 *get。 因此，存储的指针不能为空。

示例

有关如何使用成员函数的示例，请参阅 auto_ptr。

operator->

允许成员访问的运算符。

Type * operator->() const throw();

返回值

auto_ptr 拥有的对象的成员。

备注

选择运算符返回 get( )，这样表达式 ap->member 的行为与 ( ap 相同。 get() )->member，其中 ap 是 auto_ptr<Type> 类的对象。 因此，存储的指针不能为空，并且 Type 必须是具有 member 成员的类、结构或联合类型。

示例

有关如何使用成员函数的示例，请参阅 auto_ptr。

operator auto_ptr<Other>

将某种 auto_ptr 强制转换为另一种 auto_ptr。

template <class Other>
operator auto _ptr<Other>() throw();

返回值

类型强制转换运算符返回 auto_ptr<Other>(*this)。

示例

// auto_ptr_op_auto_ptr.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>

using namespace std;
int main()
{
   auto_ptr<int> pi ( new int( 5 ) );
   auto_ptr<const int> pc = ( auto_ptr<const int> )pi;
}

operator auto_ptr_ref<Other>

将 auto_ptr 强制转换为 auto_ptr_ref。

template <class Other>
operator auto _ptr  _ref<Other>() throw();

返回值

类型强制转换运算符返回 auto_ptr_ref<Other>(*this)。

示例

// auto_ptr_op_auto_ptr_ref.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>

using namespace std;

class C {
public:
    C(int _i) : m_i(_i) {
    }
    ~C() {
        cout << "~C:  " << m_i << "\n";
    }
    C &operator =(const int &x) {
        m_i = x;
        return *this;
    }
    int m_i;
};
void f(auto_ptr<C> arg) {
};
int main()
{
    const auto_ptr<C> ciap(new C(1));
    auto_ptr<C> iap(new C(2));

    // Error: this implies transfer of ownership of iap's pointer
    // f(ciap);
    f(iap); // compiles, but gives up ownership of pointer

            // here, iap owns a destroyed pointer so the following is bad:
            // *iap = 5; // BOOM

    cout << "main exiting\n";
}

~C:  2
main exiting
~C:  1

release

该成员将存储的指针 myptr 替换为 Null 指针，并返回以前存储的指针。

Type *release() throw();

返回值

以前存储的指针。

备注

该成员将存储的指针 myptr 替换为 Null 指针，并返回以前存储的指针。

示例

// auto_ptr_release.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>
using namespace std;

class Int
{
public:
    Int(int i)
    {
        x = i;
        cout << "Constructing " << (void*)this << " Value: " << x << endl;
    };
    ~Int() {
        cout << "Destructing " << (void*)this << " Value: " << x << endl;
    };

    int x;

};

int main()
{
    auto_ptr<Int> pi(new Int(5));
    pi.reset(new Int(6));
    Int* pi2 = pi.get();
    Int* pi3 = pi.release();
    if (pi2 == pi3)
        cout << "pi2 == pi3" << endl;
    delete pi3;
}

Constructing 00311AF8 Value: 5
Constructing 00311B88 Value: 6
Destructing 00311AF8 Value: 5
pi2 == pi3
Destructing 00311B88 Value: 6

reset

此成员函数对表达式 delete myptr 进行求值，但只有在存储的指针值 myptr 因函数调用而发生更改时才进行。 然后它将存储的指针替换为 ptr。

void reset(Type* ptr = 0);

参数

ptr
指定用于替换存储的指针 myptr 的指针。

示例

// auto_ptr_reset.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>

using namespace std;

class Int
{
public:
    Int(int i)
    {
        x = i;
        cout << "Constructing " << (void*)this << " Value: " << x << endl;
    };
    ~Int()
    {
        cout << "Destructing " << (void*)this << " Value: " << x << endl;
    };

    int x;
};

int main()
{
    auto_ptr<Int> pi(new Int(5));
    pi.reset(new Int(6));
    Int* pi2 = pi.get();
    Int* pi3 = pi.release();
    if (pi2 == pi3)
        cout << "pi2 == pi3" << endl;
    delete pi3;
}

Constructing 00311AF8 Value: 5
Constructing 00311B88 Value: 6
Destructing 00311AF8 Value: 5
pi2 == pi3
Destructing 00311B88 Value: 6

请参阅

unique_ptr Class