CAutoPtr classe

Esta classe representa um objeto ponteiro inteligente.

Sintaxe

template <typename T>
class CAutoPtr

Parâmetros

T
Do tipo apontador.

Membros

Construtores públicos

Métodos públicos

Operadores públicos

Membros de dados públicos

Observações

Esta aula fornece métodos para criar e gerir um ponteiro inteligente. Os apontadores inteligentes ajudam a proteger contra fugas de memória ao libertar automaticamente recursos quando estes saem do âmbito.

Além disso, CAutoPtro construtor de cópia e o operador de atribuição transferem a propriedade do ponteiro, copiando o ponteiro fonte para o ponteiro de destino e definindo o ponteiro fonte como NULL. É por isso que é impossível ter dois CAutoPtr objetos a armazenar o mesmo ponteiro cada um, e isso reduz a possibilidade de apagar o mesmo ponteiro duas vezes.

CAutoPtr Também simplifica a criação de coleções de ponteiros. Em vez de derivar uma classe de coleção e sobrescrever o destruidor, é mais simples criar uma coleção de CAutoPtr objetos. Quando a coleção é eliminada, os CAutoPtr objetos saem do âmbito e eliminam-se automaticamente.

CHeapPtre as variantes funcionam da mesma forma que CAutoPtr, exceto que alocam e libertam memória usando funções heap diferentes em vez dos operadores C++ deletenew e operadores. CAutoVectorPtr é semelhante a CAutoPtr, sendo a única diferença que utiliza vector new[] e vector delete[] para alocar e libertar memória.

Veja também CAutoPtrArray e CAutoPtrList quando são necessários arrays ou listas de apontadores inteligentes.

Requerimentos

Cabeçalho: atlbase.h

Example

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

Chame este método para assumir a posse de um ponteiro existente.

void Attach(T* p) throw();

Parâmetros

p
O CAutoPtr objeto assumirá a posse deste ponteiro.

Observações

Quando um CAutoPtr objeto assume posse de um apontador, ele apaga automaticamente o ponteiro e quaisquer dados alocados quando este sai do âmbito. Se CAutoPtr::Detach for chamado, o programador recebe novamente a responsabilidade de libertar quaisquer recursos alocados.

Em builds de depuração, ocorrerá uma falha de asserção se o CAutoPtr::m_p membro de dados apontar para um valor existente; ou seja, não for igual a NULL.

Example

Veja o exemplo na CAutoPtr Visão Geral.

CAutoPtr::CAutoPtr

O construtor.

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

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

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

Parâmetros

p
Um ponteiro já existente.

TSrc
O tipo gerido por outro CAutoPtr, usado para inicializar o objeto atual.

Observações

O CAutoPtr objeto pode ser criado usando um ponteiro existente, caso em que transfere a propriedade do ponteiro.

Example

Veja o exemplo na CAutoPtr visão geral.

CAutoPtr::~CAutoPtr

O destruidor.

~CAutoPtr() throw();

Observações

Liberta quaisquer recursos alocados. Chamadas CAutoPtr::Free.

CAutoPtr::Detach

Chame este método para libertar a propriedade de um apontador.

T* Detach() throw();

Valor de retorno

Devolve uma cópia do ponteiro.

Observações

Liberta a propriedade de um ponteiro, define a CAutoPtr::m_p variável membro de dados para NULL e devolve uma cópia do ponteiro. Depois de chamar Detach, cabe ao programador libertar quaisquer recursos alocados sobre os quais o CAutoPtr objeto possa ter assumido responsabilidade anteriormente.

Example

Veja o exemplo na CAutoPtr visão geral.

CAutoPtr::Free

Chame este método para eliminar um objeto apontado por um CAutoPtr.

void Free() throw();

Observações

O objeto apontado pelo CAutoPtr é libertado, e a CAutoPtr::m_p variável membro de dados é definida como NULL.

CAutoPtr::m_p

A variável membro dos dados do apontador.

T* m_p;

Observações

Esta variável membro contém a informação do apontador.

CAutoPtr::operator =

O operador de atribuição.

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

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

Parâmetros

p
Um ponteiro.

TSrc
Um tipo de classe.

Valor de retorno

Devolve uma referência a um CAutoPtr< T >.

Observações

O operador de atribuição desliga o CAutoPtr objeto de qualquer ponteiro atual e anexa o novo apontador, p, no seu lugar.

Example

Veja o exemplo na CAutoPtr visão geral.

CAutoPtr::operator ->

O operador apontador para membro.

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

Valor de retorno

Devolve o valor da CAutoPtr::m_p variável membro de dados.

Observações

Use este operador para chamar um método numa classe apontada pelo CAutoPtr objeto. Em builds de depuração, ocorrerá uma falha de asserção se a CAutoPtr apontar para NULL.

Example

Veja o exemplo na CAutoPtr Visão Geral.

CAutoPtr::operator T*

O operador do elenco.

operator T* () const throw();

Valor de retorno

Devolve um ponteiro para o tipo de dado de objeto definido no template de classe.

Example

Veja o exemplo na CAutoPtr visão geral.

Consulte também

CHeapPtr Classe
CAutoVectorPtr Classe
Visão geral da classe