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, CAutoPtr
il 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.
CHeapPtr
e 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 CAutoPtr
oggetto 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
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per