Classe di CAutoPtr

Articolo
03/05/2013

Questa classe rappresenta un oggetto del puntatore intelligente.

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

template< 
typename T
>
class CAutoPtr

Parametri

T
Il tipo puntatore.

Membri

Costruttori pubblici

Nome	Descrizione
CAutoPtr::CAutoPtr	Costruttore.
CAutoPtr::~CAutoPtr	Il distruttore.

Metodi pubblici

Nome	Descrizione
CAutoPtr::Attach	Chiamare questo metodo per eseguire la proprietà di un puntatore esistente.
CAutoPtr::Detach	Chiamare questo metodo per liberare la proprietà di un puntatore.
CAutoPtr::Free	Chiamare questo metodo per eliminare un oggetto fa riferimento a CAutoPtr.

Operatori pubblici

Nome	Descrizione
CAutoPtr::operator T*	l'operatore di cast.
CAutoPtr::operator =	l'operatore di assegnazione.
CAutoPtr::operator - >	L'operatore di puntatore a membro.

Membri dati pubblici

Nome	Descrizione
CAutoPtr::m_p	La variabile membro dati puntatore.

Note

Questa classe fornisce metodi per creare e gestire un puntatore intelligente, che consente di proteggere dalle perdite di memoria automaticamente liberando risorse quando esegue il fallback all'ambito.

Inoltre, il costruttore di copia di CAutoPtr e l'operatore di assegnazione contengono la proprietà del puntatore, copiando il puntatore di origine al puntatore di destinazione e impostando il puntatore di origine SU NULL.È pertanto impossibile avere due oggetti ognuno CAutoPtr che consente di archiviare lo stesso puntatore e questo riduce la possibilità di eliminare lo stesso puntatore due volte.

CAutoPtr anche semplifica la creazione di raccolte di puntatori.Anziché derivare una classe di raccolta e di eseguire l'override del distruttore, è più semplice creare una raccolta di oggetti CAutoPtr.Quando la raccolta viene eliminato, gli oggetti CAutoPtr queste variabili escono dall'ambito di validità e verranno eliminate automaticamente.

CHeapPtr e varianti funzionano come CAutoPtr, eccetto che per allocare e liberare memoria utilizzando le funzioni di heap anziché C++ new gli operatori e delete.CAutoVectorPtr è simile a CAutoPtr, l'unica differenza è che utilizza vector new[] e vector delete[] per allocare e liberare memoria.

Vedere anche CAutoPtrArray e CAutoPtrList quando le matrici o elenchi dei puntatori intelligenti necessari.

Requisiti

Header: 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;
}

Vedere anche

Riferimenti

Classe di CHeapPtr

Classe di CAutoVectorPtr

Altre risorse

I cenni preliminari sulle classi ATL

Condividi tramite