Classe de CAutoPtr

Article
03/04/2013

Cette classe représente un objet de pointeur intelligent.

Important

Cette classe et ses membres ne peuvent pas être utilisés dans les applications qui s'exécutent dans les fenêtres d'exécution.

template< 
typename T
>
class CAutoPtr

Paramètres

T
Le type pointeur.

Membres

Constructeurs publics

Nom	Description
CAutoPtr::CAutoPtr	Constructeur.
CAutoPtr::~CAutoPtr	Le destructeur.

Méthodes publiques

Nom	Description
CAutoPtr::Attach	Appelez cette méthode pour prendre la propriété d'un pointeur existant.
CAutoPtr::Detach	Appelez cette méthode pour libérer la propriété d'un pointeur.
CAutoPtr::Free	Appelez cette méthode pour supprimer un objet vers lequel pointe CAutoPtr.

Opérateurs publics

Nom	Description
CAutoPtr::operator T*	l'opérateur de cast.
CAutoPtr::operator =	l'opérateur d'assignation.
CAutoPtr::operator - >	L'opérateur de pointeur vers membre.

Données membres publiques

Nom	Description
CAutoPtr::m_p	La variable de membre de pointeur.

Notes

Cette classe fournit des méthodes pour créer et gérer un pointeur intelligent, qui permet de se protéger contre des fuites de mémoire en libérant automatiquement des ressources lorsqu'il se situe hors de portée.

De plus, le constructeur de copie d'CAutoPtr et l'opérateur d'assignation transfèrent la propriété du pointeur, copiant le pointeur de source au pointeur de destination et en plaçant le pointeur de source avec la valeur NULL.Il est donc impossible d'avoir deux objets chacun d' CAutoPtr qui stocke le même pointeur, et cela réduit la possibilité de supprimer le même pointeur deux fois.

CAutoPtr simplifie également la création de collections de pointeurs.Au lieu de dériver une classe de collection et de remplacer le destructeur, il est plus simple de créer une collection d'objets CAutoPtr .Lorsque la collection est désactivée, les objets d' CAutoPtr aura pour résultat de la portée et se supprimeront automatiquement.

CHeapPtr et les variantes fonctionnent de la même façon qu' CAutoPtr, sauf qu'ils allouent et la mémoire disponible à l'aide de le tas différent s'exécute au lieu du C++ nouveau et des opérateurs de supprimer .CAutoVectorPtr est semblable à CAutoPtr, la seule différence est qu'il utilise vector new[] et vector delete[] pour allouer et libérer de la mémoire.

Voir aussi CAutoPtrArray et le CAutoPtrList lorsque des tableaux ou des listes de pointeurs intelligents sont requises.

Configuration requise

Header: atlbase.h

Exemple

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

Voir aussi

Référence

Classe de CHeapPtr

Classe de CAutoVectorPtr

Autres ressources

Vue d'ensemble de la classe ATL

Partager via