Classe CAutoPtr

Questa classe rappresenta un oggetto puntatore intelligente.

Importante

Questa classe e i relativi membri non possono essere usati nelle applicazioni eseguite in Windows Runtime.

Sintassi

template <typename T>
class CAutoPtr

Parametri

T
Tipo di puntatore.

Membri

Costruttori pubblici

Nome	Descrizione
CAutoPtr::CAutoPtr	Costruttore.
CAutoPtr::~CAutoPtr	Distruttore.

Metodi pubblici

Nome	Descrizione
CAutoPtr::Attach	Chiamare questo metodo per acquisire la proprietà di un puntatore esistente.
CAutoPtr::Detach	Chiamare questo metodo per rilasciare la proprietà di un puntatore.
CAutoPtr::Free	Chiamare questo metodo per eliminare un oggetto a cui punta un oggetto CAutoPtr.

Operatori pubblici

Nome	Descrizione
CAutoPtr::operator T*	Operatore cast.
CAutoPtr::operator =	Operatore di assegnazione .
CAutoPtr::operator ->	Operatore da puntatore a membro.

Membri dati pubblici

Nome	Descrizione
CAutoPtr::m_p	Variabile membro dati del puntatore.

Osservazioni:

Questa classe fornisce metodi per la creazione e la gestione di un puntatore intelligente. I puntatori intelligenti consentono di proteggersi dalle perdite di memoria liberando automaticamente le risorse quando non rientrano nell'ambito.

Inoltre, CAutoPtril costruttore di copia e l'operatore di assegnazione trasferisce la proprietà del puntatore, copiando il puntatore di origine nel puntatore di destinazione e impostando il puntatore di origine su NULL. Questo è il motivo per cui è impossibile avere due CAutoPtr oggetti che archiviano lo stesso puntatore e riduce la possibilità di eliminare lo stesso puntatore due volte.

CAutoPtr semplifica inoltre la creazione di raccolte di puntatori. Anziché derivare una classe di raccolta ed eseguire l'override del distruttore, è più semplice creare una raccolta di CAutoPtr oggetti. Quando la raccolta viene eliminata, gli CAutoPtr oggetti escono dall'ambito e si eliminano automaticamente.

CHeapPtre le varianti funzionano allo stesso modo di CAutoPtr, ad eccezione del fatto che allocano e liberano memoria usando funzioni heap diverse anziché gli operatori e delete C++new. CAutoVectorPtr è simile a CAutoPtr, l'unica differenza è che usa vector new[] e vector delete[] per allocare e liberare memoria.

Vedere anche CAutoPtrArray e CAutoPtrList quando sono necessarie matrici o elenchi di puntatori intelligenti.

Requisiti

Intestazione: atlbase.h

Esempio

// A simple class for demonstration purposes

class MyClass 
{
   int iA;
   int iB;
public:
   MyClass(int a, int b);
   void Test();
};

MyClass::MyClass(int a, int b)
{
   iA = a;
   iB = b;
}

void MyClass::Test()
{
   ATLASSERT(iA == iB);
}

// A simple function

void MyFunction(MyClass* c)
{
   c->Test();
}

int UseMyClass()
{
   // Create an object of MyClass.
   MyClass *pMyC = new MyClass(1, 1);

   // Create a CAutoPtr object and have it take
   // over the pMyC pointer by calling Attach.
   CAutoPtr<MyClass> apMyC;
   apMyC.Attach(pMyC);

   // The overloaded -> operator allows the 
   // CAutoPtr object to be used in place of the pointer.
   apMyC->Test();

   // Assign a second CAutoPtr, using the = operator.
   CAutoPtr<MyClass> apMyC2;
   apMyC2 = apMyC;

   // The casting operator allows the
   // object to be used in place of the pointer.
   MyFunction(pMyC);
   MyFunction(apMyC2);

   // Detach breaks the association, so after this
   // call, pMyC is controlled only by apMyC.
   apMyC2.Detach();

   // CAutoPtr destroys any object it controls when it
   // goes out of scope, so apMyC destroys the object 
   // pointed to by pMyC here.
   return 0;
}

CAutoPtr::Attach

Chiamare questo metodo per acquisire la proprietà di un puntatore esistente.

void Attach(T* p) throw();

Parametri

p
L'oggetto CAutoPtr assumerà la proprietà di questo puntatore.

Osservazioni:

Quando un CAutoPtr oggetto assume la proprietà di un puntatore, elimina automaticamente il puntatore e tutti i dati allocati quando escono dall'ambito. Se CAutoPtr::Detach viene chiamato, il programmatore ha di nuovo la responsabilità di liberare le risorse allocate.

Nelle compilazioni di debug si verificherà un errore di asserzione se il CAutoPtr::m_p membro dati punta attualmente a un valore esistente, ovvero non è uguale a NULL.

Esempio

Vedere l'esempio in CAutoPtr Panoramica.

CAutoPtr::CAutoPtr

Costruttore.

CAutoPtr() throw();
explicit CAutoPtr(T* p) throw();

template<typename TSrc>
CAutoPtr(CAutoPtr<TSrc>& p) throw();

template<>
CAutoPtr(CAutoPtr<T>& p) throw();

Parametri

p
Puntatore esistente.

TSrc
Tipo gestito da un altro CAutoPtroggetto utilizzato per inizializzare l'oggetto corrente.

Osservazioni:

L'oggetto CAutoPtr può essere creato usando un puntatore esistente, nel qual caso trasferisce la proprietà del puntatore.

Esempio

Vedere l'esempio nella CAutoPtr panoramica.

CAutoPtr::~CAutoPtr

Distruttore.

~CAutoPtr() throw();

Osservazioni:

Libera tutte le risorse allocate. Chiama CAutoPtr::Free.

CAutoPtr::Detach

Chiamare questo metodo per rilasciare la proprietà di un puntatore.

T* Detach() throw();

Valore restituito

Restituisce una copia del puntatore.

Osservazioni:

Rilascia la proprietà di un puntatore, imposta la CAutoPtr::m_p variabile membro dati su NULL e restituisce una copia del puntatore. Dopo aver chiamato Detach, spetta al programmatore liberare tutte le risorse allocate su cui l'oggetto CAutoPtr potrebbe aver assunto la responsabilità in precedenza.

Esempio

Vedere l'esempio nella CAutoPtr panoramica.

CAutoPtr::Free

Chiamare questo metodo per eliminare un oggetto a cui punta un oggetto CAutoPtr.

void Free() throw();

Osservazioni:

L'oggetto CAutoPtr a cui punta viene liberato e la CAutoPtr::m_p variabile membro dati è impostata su NULL.

CAutoPtr::m_p

Variabile membro dati del puntatore.

T* m_p;

Osservazioni:

Questa variabile membro contiene le informazioni sul puntatore.

CAutoPtr::operator =

Operatore di assegnazione .

template<>
CAutoPtr<T>& operator= (CAutoPtr<T>& p);

template<typename TSrc>
CAutoPtr<T>& operator= (CAutoPtr<TSrc>& p);

Parametri

p
Puntatore.

TSrc
Tipo di classe.

Valore restituito

Restituisce un riferimento a un oggetto CAutoPtr< T >.

Osservazioni:

L'operatore di assegnazione scollega l'oggetto CAutoPtr da qualsiasi puntatore corrente e collega il nuovo puntatore, p, al suo posto.

Esempio

Vedere l'esempio nella CAutoPtr panoramica.

CAutoPtr::operator ->

Operatore da puntatore a membro.

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

Valore restituito

Restituisce il valore della CAutoPtr::m_p variabile membro dati.

Osservazioni:

Utilizzare questo operatore per chiamare un metodo in una classe a cui punta l'oggetto CAutoPtr . Nelle compilazioni di debug si verificherà un errore di asserzione se punta CAutoPtr a NULL.

Esempio

Vedere l'esempio in CAutoPtr Panoramica.

CAutoPtr::operator T*

Operatore cast.

operator T* () const throw();

Valore restituito

Restituisce un puntatore al tipo di dati dell'oggetto definito nel modello di classe.

Esempio

Vedere l'esempio nella CAutoPtr panoramica.

Vedi anche

Classe CHeapPtr
Classe CAutoVectorPtr
Panoramica della classe