Classe de CAutoPtr

Artigo
02/25/2013

Esta classe representa um objeto inteligente do ponteiro.

Importante
Essa classe e seus membros não podem ser usados em aplicativos executados em tempo de execução do windows.

template< 
typename T
>
class CAutoPtr

Parâmetros

T
O tipo ponteiro.

Membros

Construtores public

Nome	Descrição
CAutoPtr::CAutoPtr	o construtor.
CAutoPtr::~CAutoPtr	O destrutor.

Métodos públicos

Nome	Descrição
CAutoPtr::Attach	Chamar esse método para executar a propriedade de um ponteiro existente.
CAutoPtr::Detach	Chamar este método para liberar a propriedade de um ponteiro.
CAutoPtr::Free	Chamar esse método para excluir um objeto apontado pela CAutoPtr.

Operadores públicos

Nome	Descrição
CAutoPtr::operator T*	o operador cast.
CAutoPtr::operator =	o operador de atribuição.
CAutoPtr::operator - >	O operador de ponteiro-à- membro.

Membros públicos de dados

Nome	Descrição
CAutoPtr::m_p	A variável de membro de dados do ponteiro.

Comentários

Essa classe fornece métodos para criar e gerenciar um ponteiro inteligente, que ajuda a proteger contra vazamentos de memória automaticamente liberando recursos quando ele está fora do escopo.

Além de isso, o construtor de impressão CAutoPtr e o operador de atribuição transferem a propriedade de ponteiro, copiando o ponteiro da fonte para o ponteiro de destino e definindo o ponteiro de origem PARA ANULAR.Portanto é impossível ter dois objetos cada um de CAutoPtr que armazena o mesmo ponteiro, e isso reduz a possibilidade de excluir o mesmo ponteiro duas vezes.

CAutoPtr também simplifica a criação das coleções de ponteiros.Em vez de derivar uma classe de coleção e substituir o destrutor, é mais simples fazer uma coleção de objetos de CAutoPtr .Quando a coleção é excluída, os objetos de CAutoPtr sairão de escopo e excluir-se-9&z automaticamente.

CHeapPtr e variantes funcionam da mesma forma como CAutoPtr, exceto que aloca e libera memória usando funções diferentes de heap C++ em vez de new e os operadores de delete .CAutoVectorPtr é semelhante a CAutoPtr, a única diferença é que usa vector new[] e vector delete[] para atribuir e liberar memória.

Consulte também CAutoPtrArray e CAutoPtrList quando as matrizes ou listas de ponteiros inteligentes são necessárias.

Requisitos

Cabeçalho: atlbase.h

Exemplo

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

Consulte também

Referência

Classe de CHeapPtr

Classe de CAutoVectorPtr

Outros recursos

Visão geral da classe de ATL

Partilhar via