Classe CAutoPtr

Cette classe représente un objet pointeur intelligent.

Important

Cette classe et ses membres ne peuvent pas être utilisés dans les applications qui s’exécutent dans Windows Runtime.

Syntaxe

template <typename T>
class CAutoPtr

Paramètres

T
Type de pointeur.

Membres

Constructeurs publics

Nom	Description
CAutoPtr::CAutoPtr	Constructeur .
CAutoPtr::~CAutoPtr	Destructeur.

Méthodes publiques

Nom	Description
CAutoPtr::Attach	Appelez cette méthode pour prendre possession 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 pointé par un CAutoPtr.

Opérateurs publics

Nom	Description
CAutoPtr::operator T*	Opérateur de cast.
CAutoPtr::operator =	Opérateur d’assignation .
CAutoPtr::operator ->	Opérateur pointeur à membre.

Membres de données publiques

Nom	Description
CAutoPtr::m_p	Variable membre de données du pointeur.

Notes

Cette classe fournit des méthodes pour créer et gérer un pointeur intelligent. Les pointeurs intelligents aident à se protéger contre les fuites de mémoire en libérant automatiquement les ressources lorsqu’elles tombent hors de portée.

De plus, CAutoPtrle constructeur de copie et l’opérateur d’affectation transfèrent la propriété du pointeur, en copiant le pointeur source vers le pointeur de destination et en définissant le pointeur source sur NULL. C’est pourquoi il est impossible d’avoir deux CAutoPtr objets qui stockent chacun le même pointeur, ce qui 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 supprimée, les CAutoPtr objets sortent de l’étendue et se suppriment automatiquement.

CHeapPtret les variantes fonctionnent de la même façon que CAutoPtr, sauf qu’elles allouent et libèrent de la mémoire à l’aide de différentes fonctions de tas au lieu des opérateurs et delete C++new. CAutoVectorPtr est similaire à CAutoPtr, la seule différence étant qu’elle utilise le vecteur nouveau[] et la suppression de vecteur[] pour allouer et libérer de la mémoire.

Consultez également et CAutoPtrArrayCAutoPtrList quand des tableaux ou des listes de pointeurs intelligents sont nécessaires.

Spécifications

En-tête : 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;
}

CAutoPtr::Attach

Appelez cette méthode pour prendre possession d’un pointeur existant.

void Attach(T* p) throw();

Paramètres

p
L’objet CAutoPtr prend possession de ce pointeur.

Notes

Lorsqu’un CAutoPtr objet prend possession d’un pointeur, il supprime automatiquement le pointeur et toutes les données allouées lorsqu’il sort de l’étendue. S’il CAutoPtr::Detach est appelé, le programmeur est de nouveau chargé de libérer les ressources allouées.

Dans les builds de débogage, une défaillance d’assertion se produit si le CAutoPtr::m_p membre de données pointe actuellement vers une valeur existante ; autrement dit, elle n’est pas égale à NULL.

Exemple

Consultez l’exemple dans la vue d’ensembleCAutoPtr.

CAutoPtr::CAutoPtr

Constructeur .

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

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

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

Paramètres

p
Pointeur existant.

TSrc
Type géré par un autre CAutoPtr, utilisé pour initialiser l’objet actuel.

Notes

L’objet CAutoPtr peut être créé à l’aide d’un pointeur existant, auquel cas il transfère la propriété du pointeur.

Exemple

Consultez l’exemple dans la vue d’ensembleCAutoPtr.

CAutoPtr::~CAutoPtr

Destructeur.

~CAutoPtr() throw();

Notes

Libère toutes les ressources allouées. Appelle CAutoPtr::Free.

CAutoPtr::Detach

Appelez cette méthode pour libérer la propriété d’un pointeur.

T* Detach() throw();

Valeur retournée

Retourne une copie du pointeur.

Notes

Libère la propriété d’un pointeur, définit la CAutoPtr::m_p variable membre de données sur NULL et retourne une copie du pointeur. Après l’appel Detach, il incombe au programmeur de libérer toutes les ressources allouées sur lesquelles l’objet peut avoir précédemment assumé la CAutoPtr responsabilité.

Exemple

Consultez l’exemple dans la vue d’ensembleCAutoPtr.

CAutoPtr::Free

Appelez cette méthode pour supprimer un objet pointé par un CAutoPtr.

void Free() throw();

Notes

L’objet pointé par l’objet CAutoPtr est libéré et la CAutoPtr::m_p variable membre de données a la valeur NULL.

CAutoPtr::m_p

Variable membre de données du pointeur.

T* m_p;

Notes

Cette variable membre contient les informations de pointeur.

CAutoPtr::operator =

Opérateur d’assignation .

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

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

Paramètres

p
Pointeur.

TSrc
Type de classe.

Valeur retournée

Retourne une référence à un CAutoPtr< T >.

Notes

L’opérateur d’affectation détache l’objet CAutoPtr de n’importe quel pointeur actuel et attache le nouveau pointeur, pà sa place.

Exemple

Consultez l’exemple dans la vue d’ensembleCAutoPtr.

CAutoPtr::operator ->

Opérateur pointeur à membre.

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

Valeur retournée

Retourne la valeur de la CAutoPtr::m_p variable membre de données.

Notes

Utilisez cet opérateur pour appeler une méthode dans une classe pointée par l’objet CAutoPtr . Dans les builds de débogage, une défaillance d’assertion se produit si les CAutoPtr points ont la valeur NULL.

Exemple

Consultez l’exemple dans la vue d’ensembleCAutoPtr.

CAutoPtr::operator T*

Opérateur de cast.

operator T* () const throw();

Valeur retournée

Retourne un pointeur vers le type de données d’objet défini dans le modèle de classe.

Exemple

Consultez l’exemple dans la vue d’ensembleCAutoPtr.

Voir aussi

CHeapPtr, classe
CAutoVectorPtr, classe
Vue d’ensemble de la classe