Condividi tramite

Classe auto_ptr

  • Articolo

Esegue il wrapping di un puntatore di tipo smart intorno a una risorsa, in modo da assicurare che la risorsa venga eliminata definitivamente in modo automatico quando il controllo lascia un blocco.

A partire da C++11, usare unique_ptr anziché auto_ptr. Per altre informazioni, vedere unique_ptr Classe. auto_ptr è stato deprecato in C++11 e rimosso in C++17.

Per altre informazioni su throw() e sulla gestione delle eccezioni, vedere Specifiche di eccezioni (generazione).

Sintassi

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

Parametri

right
auto_ptr da cui ottenere una risorsa esistente.

ptr
Puntatore specificato per sostituire il puntatore archiviato.

Osservazioni:

Il modello di classe descrive un puntatore intelligente, denominato auto_ptr, a un oggetto allocato. Il puntatore deve essere Null o deve designare un oggetto allocato da new. auto_ptr trasferisce la proprietà se il valore archiviato viene assegnato a un altro oggetto. Sostituisce il valore archiviato dopo un trasferimento con un puntatore Null. Distruttore per auto_ptr<Type> l'eliminazione dell'oggetto allocato. auto_ptr<Type> assicura che un oggetto allocato venga eliminato automaticamente quando il controllo lascia un blocco, anche tramite un'eccezione generata. Non è consigliabile costruire due auto_ptr<Type> oggetti che possiedono lo stesso oggetto.

È possibile passare un oggetto auto_ptr<Type> in base al valore come argomento per una chiamata di funzione. Un auto_ptr oggetto non può essere un elemento di un contenitore libreria standard. Non è possibile gestire in modo affidabile una sequenza di auto_ptr<Type> oggetti con un contenitore della libreria standard C++.

Membri

Costruttori

Nome Descrizione
auto_ptr Costruttore per oggetti di tipo auto_ptr.

Typedef

Nome Descrizione
element_type Il tipo è un sinonimo del parametro di modello Type.

Funzioni

Nome Descrizione
get La funzione membro restituisce il puntatore myptr archiviato.
release Il membro sostituisce il puntatore archiviato myptr con un puntatore Null e restituisce il puntatore archiviato in precedenza.
reset La funzione membro valuta l'espressione delete myptr, ma solo se il valore del puntatore archiviato myptr cambia in seguito a una chiamata di funzione. Sostituisce quindi il puntatore archiviato con ptr.

Operatori

Nome Descrizione
operator= Operatore di assegnazione che trasferisce la proprietà da un oggetto auto_ptr a un altro.
operator* Operatore di dereferenziazione per oggetti di tipo auto_ptr.
operator-> Operatore per consentire l'accesso ai membri.
operator auto_ptr<Other> Esegue il cast da un tipo di auto_ptr a un altro tipo di auto_ptr.
operator auto_ptr_ref<Other> Esegue il cast da un auto_ptr a un auto_ptr_ref.

auto_ptr

Costruttore per oggetti di tipo 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();

Parametri

ptr
Il puntatore all'oggetto incapsulato da auto_ptr.

right
L'oggetto auto_ptr che deve essere copiato dal costruttore.

Osservazioni:

Il primo costruttore archivia ptr in myptr, il puntatore archiviato all'oggetto allocato. Il secondo costruttore trasferisce la proprietà del puntatore archiviato in right, archiviando right. versione in myptr.

Il terzo costruttore si comporta come il secondo, ad eccezione del fatto che archivia right. ref. release in myptr, dove ref è il riferimento archiviato in right.

Il costruttore del modello si comporta come il secondo costruttore, se un puntatore a Other può essere convertito in modo implicito in un puntatore a Type.

Esempio

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

Il tipo è un sinonimo del parametro di modello Type.

typedef Type element  _type;

get

La funzione membro restituisce il puntatore myptr archiviato.

Type *get() const throw();

Valore restituito

Puntatore myptrarchiviato.

Esempio

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

Operatore di assegnazione che trasferisce la proprietà da un oggetto auto_ptr a un altro.

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

Parametri

right
Oggetto di tipo auto_ptr.

Valore restituito

Riferimento a un oggetto di tipo auto_ptr<Type>.

Osservazioni:

L'assegnazione valuta l'espressione delete myptr, ma solo se il puntatore myptr archiviato cambia in seguito all'assegnazione. Trasferisce quindi la proprietà del puntatore archiviato a destra, archiviando il diritto.release in myptr. La funzione restituisce *this.

Esempio

Per un esempio dell'uso dell'operatore membro, vedere auto_ptr.

operator*

Operatore di dereferenziazione per oggetti di tipo auto_ptr.

Type& operator*() const throw();

Valore restituito

Riferimento a un oggetto di tipo Type proprietario del puntatore.

Osservazioni:

L'operatore di riferimento indiretto restituisce *get. Di conseguenza, il puntatore archiviato non deve essere null.

Esempio

Per un esempio di come usare la funzione membro, vedere auto_ptr.

operator->

Operatore per consentire l'accesso ai membri.

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

Valore restituito

Membro dell'oggetto proprietario auto_ptr .

Osservazioni:

L'operatore di selezione restituisce get( ), in modo che l'espressione ap>member si comporti come ( ap. get() )->, dove ap è un oggetto della classe auto_ptr<Type>.member Di conseguenza, il puntatore archiviato non deve essere Null e Type deve essere una classe, uno struct o un tipo di unione con un member membro.

Esempio

Per un esempio di come usare la funzione membro, vedere auto_ptr.

operator auto_ptr<Other>

Esegue il cast da un tipo di auto_ptr a un altro tipo di auto_ptr.

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

Valore restituito

L'operatore cast del tipo restituisce auto_ptr<Other>(*this).

Esempio

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

Esegue il cast da un auto_ptr a un auto_ptr_ref.

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

Valore restituito

L'operatore cast del tipo restituisce auto_ptr_refOther<>(*this).

Esempio

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

Il membro sostituisce il puntatore archiviato myptr con un puntatore Null e restituisce il puntatore archiviato in precedenza.

Type *release() throw();

Valore restituito

Il puntatore archiviato in precedenza.

Osservazioni:

Il membro sostituisce il puntatore archiviato myptr con un puntatore Null e restituisce il puntatore archiviato in precedenza.

Esempio

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

La funzione membro valuta l'espressione delete myptr, ma solo se il valore myptr del puntatore archiviato cambia in seguito a una chiamata di funzione. Sostituisce quindi il puntatore archiviato con ptr.

void reset(Type* ptr = 0);

Parametri

ptr
Puntatore specificato per sostituire il puntatore myptrarchiviato.

Esempio

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

Vedi anche

unique_ptr Class