Sdílet prostřednictvím

auto_ptr – třída

  • Článek

Zabalí inteligentní ukazatel kolem prostředku, který zajistí, že se prostředek automaticky zničí, když ovládací prvek opustí blok.

Počínaje jazykem C++11 použijte unique_ptr místo auto_ptr. Další informace najdete v tématu unique_ptr třída. auto_ptr byl vyřazen v jazyce C++11 a odebrán v jazyce C++17.

Další informace o throw() zpracování výjimek a zpracování výjimek naleznete v tématu Specifikace výjimek (throw).

Syntaxe

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);
};

Parametry

right
Ze auto_ptr kterého chcete získat existující prostředek.

ptr
Zadaný ukazatel pro nahrazení uloženého ukazatele.

Poznámky

Šablona třídy popisuje inteligentní ukazatel, který se nazývá , auto_ptrk přidělenému objektu. Ukazatel musí mít hodnotu null nebo určit objekt přidělený new. Přenese auto_ptr vlastnictví, pokud je uložená hodnota přiřazena jinému objektu. (Nahradí uloženou hodnotu po přenosu ukazatelem null.) Destruktor pro auto_ptr<Type> odstranění přiděleného objektu. Zajišťuje auto_ptr<Type> , že přidělený objekt se automaticky odstraní, když ovládací prvek opustí blok, a to i prostřednictvím vyvolané výjimky. Neměli byste vytvářet dva auto_ptr<Type> objekty, které vlastní stejný objekt.

Objekt můžete předat auto_ptr<Type> hodnotou jako argument volání funkce. Nemůže auto_ptr být prvkem žádného kontejneru standardní knihovny. Pomocí kontejneru standardní knihovny C++ nemůžete spolehlivě spravovat posloupnost auto_ptr<Type> objektů.

Členové

Konstruktory

Název Popis
auto_ptr Konstruktor pro objekty typu auto_ptr.

Typedefs

Název Popis
element_type Typ je synonymem pro parametr Typešablony .

Funkce

Název Popis
get Členová funkce vrátí uložený ukazatel myptr.
release Člen nahradí uložený ukazatel myptr nulovým ukazatelem a vrátí dříve uložený ukazatel.
reset Členová funkce vyhodnotí výraz delete myptr, ale pouze v případě, že uložená hodnota myptr ukazatele se změní v důsledku volání funkce. Potom nahradí uložený ukazatel ptr.

Operátory

Název Popis
operator= Operátor přiřazení, který převádí vlastnictví z jednoho auto_ptr objektu do druhého.
operator* Operátor dereferencing pro objekty typu auto_ptr.
operator-> Operátor pro povolení přístupu členů.
operator auto_ptr<Other> Přetypuje z jednoho druhu auto_ptr na jiný druh auto_ptr.
operator auto_ptr_ref<Other> Přetypuje z objektu do objektu auto_ptr auto_ptr_ref.

auto_ptr

Konstruktor pro objekty typu 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();

Parametry

ptr
Ukazatel na objekt, který auto_ptr zapouzdřuje.

right
Objekt auto_ptr , který má být zkopírován konstruktorem.

Poznámky

První konstruktor je uložen ptr v myptruloženém ukazateli na přidělený objekt. Druhý konstruktor přenese vlastnictví ukazatele uloženého v right, uložením right. vydanou v myptr.

Třetí konstruktor se chová stejně jako druhý, s tím rozdílem, že ukládá right. ref. release v myptr, kde ref je odkaz uložen v right.

Konstruktor šablony se chová stejně jako druhý konstruktor, pokud ukazatel na Other lze implicitně převést na ukazatel na Type.

Příklad

// 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

Typ je synonymem pro parametr Typešablony .

typedef Type element  _type;

get

Členová funkce vrátí uložený ukazatel myptr.

Type *get() const throw();

Návratová hodnota

Uložený ukazatel myptr.

Příklad

// 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=

Operátor přiřazení, který převádí vlastnictví z jednoho auto_ptr objektu do druhého.

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();

Parametry

right
Objekt typu auto_ptr.

Návratová hodnota

Odkaz na objekt typu auto_ptr<Type>.

Poznámky

Přiřazení vyhodnotí výraz delete myptr, ale pouze v případě, že se uložený ukazatel myptr změní v důsledku přiřazení. Potom přenese vlastnictví ukazatele uloženého vpravo uložením práva.release v myptr. Funkce vrátí *this.

Příklad

Příklad použití operátoru člena naleznete v tématu auto_ptr.

operator*

Operátor dereferencing pro objekty typu auto_ptr.

Type& operator*() const throw();

Návratová hodnota

Odkaz na objekt typu Type , který vlastní ukazatel.

Poznámky

Operátor indirection vrátí *get. Uložený ukazatel proto nesmí být null.

Příklad

Příklad použití členské funkce naleznete v tématu auto_ptr.

operator->

Operátor pro povolení přístupu členů.

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

Návratová hodnota

Člen objektu, který auto_ptr vlastní.

Poznámky

Operátor výběru vrátí get( )výraz , aby se výraz ap->member chová stejně jako ( ap. get() )->member, kde ap je objekt třídyTypeauto_ptr<> . Uložený ukazatel proto nesmí být null a Type musí být třída, struktura nebo sjednocující typ s member členem.

Příklad

Příklad použití členské funkce naleznete v tématu auto_ptr.

operator auto_ptr<Other>

Přetypuje z jednoho druhu auto_ptr na jiný druh auto_ptr.

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

Návratová hodnota

Operátor přetypování typu vrátí hodnotu auto_ptr<Other>(*this).

Příklad

// 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>

Přetypuje z objektu do objektu auto_ptr auto_ptr_ref.

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

Návratová hodnota

Operátor přetypování typu vrátí auto_ptr_refOther<>(*this).

Příklad

// 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

Člen nahradí uložený ukazatel myptr nulovým ukazatelem a vrátí dříve uložený ukazatel.

Type *release() throw();

Návratová hodnota

Dříve uložený ukazatel.

Poznámky

Člen nahradí uložený ukazatel myptr nulovým ukazatelem a vrátí dříve uložený ukazatel.

Příklad

// 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

Členová funkce vyhodnotí výraz delete myptr, ale pouze v případě, že uložená hodnota myptr ukazatele se změní v důsledku volání funkce. Potom nahradí uložený ukazatel ptr.

void reset(Type* ptr = 0);

Parametry

ptr
Zadaný ukazatel pro nahrazení uloženého ukazatele myptr.

Příklad

// 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

Viz také

unique_ptr Class