`CObList` Classe

Observação

A biblioteca Microsoft Foundation Classes (MFC) continua a ser suportada. No entanto, já não estamos a adicionar funcionalidades nem a atualizar a documentação.

Suporta listas ordenadas de ponteiros não únicos CObject acessíveis sequencialmente ou pelo valor do apontador.

Sintaxe

class CObList : public CObject

Membros

Construtores Públicos

Nome	Description
`CObList::CObList`	Constrói uma lista vazia para `CObject` ponteiros.

Métodos Públicos

Nome	Description
`CObList::AddHead`	Adiciona um elemento (ou todos os elementos de outra lista) ao cabeçalho da lista (cria um novo cabeça).
`CObList::AddTail`	Adiciona um elemento (ou todos os elementos de outra lista) à cauda da lista (cria uma nova cauda).
`CObList::Find`	Obtém a posição de um elemento especificada pelo valor do apontador.
`CObList::FindIndex`	Obtém a posição de um elemento especificada por um índice baseado em zero.
`CObList::GetAt`	Obtém o elemento numa dada posição.
`CObList::GetCount`	Devolve o número de elementos nesta lista.
`CObList::GetHead`	Devolve o elemento cabeça da lista (não pode estar vazio).
`CObList::GetHeadPosition`	Devolve a posição do elemento principal da lista.
`CObList::GetNext`	Recebe o próximo elemento para iterar.
`CObList::GetPrev`	Recebe o elemento anterior para iterar.
`CObList::GetSize`	Devolve o número de elementos nesta lista.
`CObList::GetTail`	Devolve o elemento cauda da lista (não pode estar vazio).
`CObList::GetTailPosition`	Devolve a posição do elemento de cauda da lista.
`CObList::InsertAfter`	Insere um novo elemento após uma determinada posição.
`CObList::InsertBefore`	Insere um novo elemento antes de uma dada posição.
`CObList::IsEmpty`	Testa a condição de lista vazia (sem elementos).
`CObList::RemoveAll`	Remove todos os elementos desta lista.
`CObList::RemoveAt`	Remove um elemento desta lista, especificado pela posição.
`CObList::RemoveHead`	Remove o elemento do topo da lista.
`CObList::RemoveTail`	Remove o elemento da cauda da lista.
`CObList::SetAt`	Coloca o elemento numa posição dada.

Observações

CObList As listas comportam-se como listas duplamente ligadas.

Uma variável do tipo POSITION é uma chave para a lista. Podes usar uma POSITION variável tanto como iterador para percorrer uma lista sequencialmente como como marcador para manter um lugar. No entanto, uma posição não é o mesmo que um índice.

A inserção de elementos é muito rápida na cabeça da inclinação, na cauda e num conhecido POSITION. É necessária uma pesquisa sequencial para procurar um elemento por valor ou índice. Esta pesquisa pode ser lenta se a lista for longa.

CObList incorpora a IMPLEMENT_SERIAL macro para suportar a serialização e o despejo dos seus elementos. Se uma lista de CObject ponteiros for armazenada para um arquivo, seja com um operador de inserção sobrecarregado ou com a Serialize função membro, cada CObject elemento é serializado por sua vez.

Se precisares de um dump de elementos individuais CObject na lista, tens de definir a profundidade do contexto do dump para 1 ou superior.

Quando um CObList objeto é eliminado, ou quando os seus elementos são removidos, apenas os CObject ponteiros são removidos, não os objetos que referenciam.

Pode derivar as suas próprias classes a partir de CObList. A sua nova classe de lista, concebida para conter ponteiros para objetos derivados de CObject, adiciona novos membros de dados e novas funções membros. Note que a lista resultante não é estritamente segura para tipos, porque permite a inserção de qualquer CObject ponteiro.

Observação

Deve usar a IMPLEMENT_SERIAL macro na implementação da sua classe derivada se pretende serializar a lista.

Para mais informações sobre a utilização CObListde , consulte o artigo Coleções.

Hierarquia de herança

CObject

CObList

Requerimentos

Cabeçalho:afxcoll.h

`CObList::AddHead`

Adiciona um novo elemento ou lista de elementos ao início desta lista.

POSITION AddHead(CObject* newElement);
void AddHead(CObList* pNewList);

Parâmetros

newElement
O CObject indicador a ser adicionado a esta lista.

pNewList
Um apontar para outra CObList lista. Os elementos em pNewList serão adicionados a esta lista.

Valor de retorno

A primeira versão devolve o POSITION valor do elemento recém-inserido.

A tabela seguinte mostra outras funções membros semelhantes a CObList::AddHead.

Class	Função de Membro
`CPtrList`	`POSITION AddHead( void * newElement );` `void AddHead( CPtrList * pNewList );`
`CStringList`	`POSITION AddHead(const CString& newElement );` `POSITION AddHead(LPCTSTR newElement );` `void AddHead(CStringList * pNewList );`

Observações

A lista pode estar vazia antes da operação.

Example

Veja CObList::CObList uma lista da CAge turma.

CObList list;
list.AddHead(new CAge(21)); // 21 is now at head.
list.AddHead(new CAge(40)); // 40 replaces 21 at head.
#ifdef _DEBUG
afxDump.SetDepth(1);
afxDump << _T("AddHead example: ") << &list << _T("\n");
#endif

Os resultados deste programa são os seguintes:

AddHead example: A CObList with 2 elements
a CAge at $44A8 40
a CAge at $442A 21

`CObList::AddTail`

Adiciona um novo elemento ou lista de elementos à cauda desta lista.

POSITION AddTail(CObject* newElement);
void AddTail(CObList* pNewList);

Parâmetros

newElement
O CObject indicador a ser adicionado a esta lista.

pNewList
Um apontar para outra CObList lista. Os elementos em pNewList serão adicionados a esta lista.

Valor de retorno

A primeira versão devolve o POSITION valor do elemento recém-inserido.

Observações

A lista pode estar vazia antes da operação.

A tabela seguinte mostra outras funções membros semelhantes a CObList::AddTail.

Class	Função de Membro
`CPtrList`	`POSITION AddTail( void * newElement );` `void AddTail( CPtrList * pNewList );`
`CStringList`	`POSITION AddTail( const CString& newElement );` `POSITION AddTail( LPCTSTR newElement );` `void AddTail( CStringList * pNewList );`

Example

Veja CObList::CObList uma lista da CAge turma.

CObList list;
list.AddTail(new CAge(21));
list.AddTail(new CAge(40)); // List now contains (21, 40).
#ifdef _DEBUG
afxDump.SetDepth(1);
afxDump << _T("AddTail example: ") << &list << _T("\n");
#endif

Os resultados deste programa são os seguintes:

AddTail example: A CObList with 2 elements
a CAge at $444A 21
a CAge at $4526 40

`CObList::CObList`

Constrói uma lista de ponteiros vazia CObject .

CObList(INT_PTR nBlockSize = 10);

Parâmetros

nBlockSize
A granularidade da alocação de memória para estender a lista.

Observações

À medida que a lista cresce, a memória é alocada em unidades de nBlockSize entradas. Se uma alocação de memória falhar, a CMemoryException é lançado.

A tabela seguinte mostra outras funções membros semelhantes a CObList::CObList.

Class	Função de Membro
`CPtrList`	`CPtrList( INT_PTR nBlockSize = 10 );`
`CStringList`	`CStringList( INT_PTR nBlockSize = 10 );`

Example

Abaixo está uma lista da CObjectclasse CAge derivada em usada em todos os exemplos da coleção:

// Simple CObject-derived class for CObList and other examples
class CAge : public CObject
{
   DECLARE_SERIAL(CAge)
private:
   int   m_years;
public:
   CAge() { m_years = 0; }
   CAge(int age) { m_years = age; }
   CAge(const CAge& a) { m_years = a.m_years; } // Copy constructor
   void Serialize(CArchive& ar);
   void AssertValid() const;
   const CAge& operator=(const CAge& a)
   {
      m_years = a.m_years; return *this;
   }
   BOOL operator==(CAge a)
   {
      return m_years == a.m_years;
   }
#ifdef _DEBUG
   void Dump(CDumpContext& dc) const
   {
      CObject::Dump(dc);
      dc << m_years;
   }
#endif
};

Segue-se um exemplo de CObList utilização por construtores:

CObList list(20);  // List on the stack with blocksize = 20.

CObList* plist = new CObList; // List on the heap with default 
                              // blocksize.

`CObList::Find`

Pesquisa na lista sequencialmente para encontrar o primeiro CObject ponteiro que corresponde ao ponteiro especificado CObject .

POSITION Find(
    CObject* searchValue,
    POSITION startAfter = NULL) const;

Parâmetros

searchValue
O ponteiro de objeto a encontrar nesta lista.

startAfter
A posição inicial para a busca.

Valor de retorno

Um POSITION valor que pode ser usado para iteração ou recuperação de ponteiros de objeto; NULL se o objeto não for encontrado.

Observações

Note que os valores dos ponteiros são comparados, não o conteúdo dos objetos.

A tabela seguinte mostra outras funções membros semelhantes a CObList::Find.

Class	Função de Membro
`CPtrList`	`POSITION Find( void *searchValue , POSITION startAfter = NULL ) const;`
`CStringList`	`POSITION Find( LPCTSTR searchValue , POSITION startAfter = NULL ) const;`

Example

Veja CObList::CObList uma lista da CAge turma.

CObList list;
CAge* pa1;
CAge* pa2;
POSITION pos;
list.AddHead(pa1 = new CAge(21));
list.AddHead(pa2 = new CAge(40));    // List now contains (40, 21).
if ((pos = list.Find(pa1)) != NULL) // Hunt for pa1
{                                  // starting at head by default.
   ASSERT(*(CAge*)list.GetAt(pos) == CAge(21));
}

`CObList::FindIndex`

Utiliza o valor de nIndex como índice na lista.

POSITION FindIndex(INT_PTR nIndex) const;

Parâmetros

nIndex
O índice baseado em zero do elemento da lista a encontrar.

Valor de retorno

Um POSITION valor que pode ser usado para iteração ou recuperação de ponteiros de objetos; NULL se nIndex for demasiado grande. (O enquadramento gera uma afirmação se nIndex for negativo.)

Observações

Inicia uma varredura sequencial a partir do cabeça da lista, parando no n-ésimoelemento.

A tabela seguinte mostra outras funções membros semelhantes a CObList::FindIndex.

Class	Função de Membro
`CPtrList`	`POSITION FindIndex( INT_PTR nIndex ) const;`
`CStringList`	`POSITION FindIndex( INT_PTR nIndex ) const;`

Example

Veja CObList::CObList uma lista da CAge turma.

CObList list;
POSITION pos;

list.AddHead(new CAge(21));
list.AddHead(new CAge(40)); // List now contains (40, 21).
if ((pos = list.FindIndex(0)) != NULL)
{
   ASSERT(*(CAge*)list.GetAt(pos) == CAge(40));
}

`CObList::GetAt`

Uma variável do tipo POSITION é uma chave para a lista.

CObject*& GetAt(POSITION position);
const CObject*& GetAt(POSITION position) const;

Parâmetros

position
Um valor devolvido POSITION por uma chamada de função anterior GetHeadPosition ou Find membro.

Valor de retorno

Veja a descrição do valor de retorno para GetHead.

Observações

Não é o mesmo que um índice, e não podes operar num POSITION valor por ti próprio. GetAt recupera o CObject ponteiro associado a uma determinada posição.

Deve garantir que o seu POSITION valor representa uma posição válida na lista. Se for inválido, então a versão Debug da Microsoft Foundation Class Library afirma.

A tabela seguinte mostra outras funções membros semelhantes a CObList::GetAt.

Class	Função de Membro
`CPtrList`	`const void& GetAt( POSITION position ) const;` `void& GetAt( POSITION position );`
`CStringList`	`const CString& GetAt( POSITION position ) const;` `CString& GetAt( POSITION position );`

Example

Veja o exemplo para FindIndex.

`CObList::GetCount`

Obtém o número de elementos nesta lista.

INT_PTR GetCount() const;

Valor de retorno

Um valor inteiro que contém a contagem de elementos.

A tabela seguinte mostra outras funções membros semelhantes a CObList::GetCount.

Class	Função de Membro
`CPtrList`	`INT_PTR GetCount( ) const;`
`CStringList`	`INT_PTR GetCount( ) const;`

Example

Veja CObList::CObList uma lista da CAge turma.

CObList list;

list.AddHead(new CAge(21));
list.AddHead(new CAge(40)); // List now contains (40, 21).
ASSERT(list.GetCount() == 2);

`CObList::GetHead`

Obtém o CObject ponteiro que representa o elemento cabeça desta lista.

CObject*& GetHead();
const CObject*& GetHead() const;

Valor de retorno

Se a lista for acedida através de um ponteiro para um const CObList, então GetHead retorna um CObject apontador. Isto permite que a função seja usada apenas no lado direito de uma instrução de atribuição e, assim, protege a lista de modificações.

Se a lista for acedida diretamente ou através de um ponteiro para um CObList, então GetHead retorna uma referência a um CObject ponteiro. Isto permite que a função seja usada em ambos os lados de uma instrução de atribuição e, assim, permite modificar as entradas da lista.

Observações

Deve certificar-se de que a lista não está vazia antes de ligar GetHead. Se a lista estiver vazia, então a versão Debug da Microsoft Foundation Class Library afirma. Use IsEmpty para verificar se a lista contém elementos.

A tabela seguinte mostra outras funções membros semelhantes a CObList::GetHead.

Class	Função de Membro
`CPtrList`	`const void& GetHead( ) const; void& GetHead( );`
`CStringList`	`const CString& GetHead( ) const; CString& GetHead( );`

Example

Veja CObList::CObList uma lista da CAge turma.

O exemplo seguinte ilustra o uso de GetHead no lado esquerdo de uma instrução de atribuição.

const CObList* cplist;

CObList* plist = new CObList;
CAge* page1 = new CAge(21);
CAge* page2 = new CAge(30);
CAge* page3 = new CAge(40);
plist->AddHead(page1);
plist->AddHead(page2);  // List now contains (30, 21).
// The following statement REPLACES the head element.
plist->GetHead() = page3; // List now contains (40, 21).
ASSERT(*(CAge*)plist->GetHead() == CAge(40));
cplist = plist;  // cplist is a pointer to a const list.
// cplist->GetHead() = page3; // Error: can't assign a pointer to a const list
ASSERT(*(CAge*)plist->GetHead() == CAge(40)); // OK

delete page1;
delete page2;
delete page3;
delete plist; // Cleans up memory.

`CObList::GetHeadPosition`

Obtém a posição do elemento cabeça desta lista.

POSITION GetHeadPosition() const;

Valor de retorno

Um POSITION valor que pode ser usado para iteração ou recuperação de ponteiros de objetos; NULL se a lista estiver vazia.

A tabela seguinte mostra outras funções membros semelhantes a CObList::GetHeadPosition.

Class	Função de Membro
`CPtrList`	`POSITION GetHeadPosition( ) const;`
`CStringList`	`POSITION GetHeadPosition( ) const;`

Example

Veja CObList::CObList uma lista da CAge turma.

CObList list;
POSITION pos;

list.AddHead(new CAge(21));
list.AddHead(new CAge(40)); // List now contains (40, 21).
if ((pos = list.GetHeadPosition()) != NULL)
{
   ASSERT(*(CAge*)list.GetAt(pos) == CAge(40));
}

`CObList::GetNext`

Obtém o elemento da lista identificado por rPosition, e depois define rPosition para o POSITION valor da próxima entrada da lista.

CObject*& GetNext(POSITION& rPosition);
const CObject* GetNext(POSITION& rPosition) const;

Parâmetros

rPosition
Uma referência a um POSITION valor devolvido por uma chamada de função anterior GetNext, GetHeadPosition, ou outro membro.

Valor de retorno

Veja a descrição do valor de retorno para GetHead.

Observações

Pode usar GetNext num ciclo de iteração para frente se estabelecer a posição inicial com uma chamada para GetHeadPosition ou Find.

Deve garantir que o seu POSITION valor representa uma posição válida na lista. Se for inválido, então a versão Debug da Microsoft Foundation Class Library afirma.

Se o elemento recuperado for o último na lista, então o novo valor de rPosition é definido como NULL.

É possível remover um elemento durante uma iteração. Veja o exemplo para RemoveAt.

Observação

Desde o MFC 8.0, a versão const deste método mudou para return const CObject* em vez de const CObject*&. Esta alteração foi feita para alinhar o compilador com o padrão C++.

A tabela seguinte mostra outras funções membros semelhantes a CObList::GetNext.

Class	Função de Membro
`CPtrList`	`void& GetNext( POSITION&` `rPosition` `);` `const void GetNext( POSITION&` `rPosition` `) const;`
`CStringList`	`CString& GetNext( POSITION&` `rPosition` `);` `const CString& GetNext( POSITION&` `rPosition` `) const;`

Example

Veja CObList::CObList uma lista da CAge turma.

CObList list;
POSITION pos;
list.AddHead(new CAge(21));
list.AddHead(new CAge(40)); // List now contains (40, 21).
// Iterate through the list in head-to-tail order.
#ifdef _DEBUG
for (pos = list.GetHeadPosition(); pos != NULL;)
{
   afxDump << list.GetNext(pos) << _T("\n");
}
#endif

Os resultados deste programa são os seguintes:

a CAge at $479C 40
a CAge at $46C0 21

`CObList::GetPrev`

Obtém o elemento da lista identificado por rPosition, e depois define rPosition para o POSITION valor da entrada anterior na lista.

CObject*& GetPrev(POSITION& rPosition);
const CObject* GetPrev(POSITION& rPosition) const;

Parâmetros

rPosition
Uma referência a um POSITION valor devolvido por uma chamada de função anterior GetPrev ou de outro membro.

Valor de retorno

Veja a descrição do valor de retorno para GetHead.

Observações

Podes usar GetPrev num loop de iteração inversa se estabeleceres a posição inicial com uma chamada para GetTailPosition ou Find.

Deve garantir que o seu POSITION valor representa uma posição válida na lista. Se for inválido, então a versão Debug da Microsoft Foundation Class Library afirma.

Se o elemento recuperado for o primeiro da lista, então o novo valor de rPosition é definido para NULL.

Observação

Desde o MFC 8.0, a versão const deste método mudou para return const CObject* em vez de const CObject*&. Esta alteração foi feita para alinhar o compilador com o padrão C++.

A tabela seguinte mostra outras funções membros semelhantes a CObList::GetPrev.

Class	Função de Membro
`CPtrList`	`void& GetPrev( POSITION&` `rPosition` `);` `const void GetPrev( POSITION&` `rPosition` `) const;`
`CStringList`	`CString& GetPrev( POSITION&` `rPosition` `);` `const CString& GetPrev( POSITION&` `rPosition` `) const;`

Example

Veja CObList::CObList uma lista da CAge turma.

CObList list;
POSITION pos;

list.AddHead(new CAge(21));
list.AddHead(new CAge(40)); // List now contains (40, 21).
// Iterate through the list in tail-to-head order.
for (pos = list.GetTailPosition(); pos != NULL;)
{
#ifdef _DEBUG
   afxDump << list.GetPrev(pos) << _T("\n");
#endif
}

Os resultados deste programa são os seguintes:

a CAge at $421C 21
a CAge at $421C 40

`CObList::GetSize`

Devolve o número de elementos da lista.

INT_PTR GetSize() const;

Valor de retorno

O número de itens na lista.

Observações

Chame este método para recuperar o número de elementos na lista.

A tabela seguinte mostra outras funções membros semelhantes a CObList::GetSize.

Class	Função de Membro
`CPtrList`	`INT_PTR GetSize( ) const;`
`CStringList`	`INT_PTR GetSize( ) const;`

Example

Veja CObList::CObList uma lista da CAge turma.

CObList list;

list.AddHead(new CAge(21));
list.AddHead(new CAge(40)); // List now contains (40, 21).
ASSERT(list.GetSize() == 2);

`CObList::GetTail`

Obtém o CObject ponteiro que representa o elemento cauda desta lista.

CObject*& GetTail();
const CObject*& GetTail() const;

Valor de retorno

Veja a descrição do valor de retorno para GetHead.

Observações

Deve certificar-se de que a lista não está vazia antes de ligar GetTail. Se a lista estiver vazia, então a versão Debug da Microsoft Foundation Class Library afirma. Use IsEmpty para verificar se a lista contém elementos.

A tabela seguinte mostra outras funções membros semelhantes a CObList::GetTail.

Class	Função de Membro
`CPtrList`	`const void& GetTail( ) const; void& GetTail( );`
`CStringList`	`const CString& GetTail( ) const; CString& GetTail( );`

Example

Veja CObList::CObList uma lista da CAge turma.

CObList list;

list.AddHead(new CAge(21));
list.AddHead(new CAge(40)); // List now contains (40, 21).
ASSERT(*(CAge*)list.GetTail() == CAge(21));

`CObList::GetTailPosition`

Obtém a posição do elemento de cauda desta lista; NULL Se a lista estiver vazia.

POSITION GetTailPosition() const;

Valor de retorno

Um POSITION valor que pode ser usado para iteração ou recuperação de ponteiros de objetos; NULL se a lista estiver vazia.

A tabela seguinte mostra outras funções membros semelhantes a CObList::GetTailPosition.

Class	Função de Membro
`CPtrList`	`POSITION GetTailPosition( ) const;`
`CStringList`	`POSITION GetTailPosition( ) const;`

Example

Veja CObList::CObList uma lista da CAge turma.

CObList list;
POSITION pos;

list.AddHead(new CAge(21));
list.AddHead(new CAge(40)); // List now contains (40, 21).
if ((pos = list.GetTailPosition()) != NULL)
{
    ASSERT(*(CAge*) list.GetAt(pos) == CAge(21));
}

`CObList::InsertAfter`

Adiciona um elemento a esta lista após o elemento na posição especificada.

POSITION InsertAfter(
    POSITION position,
    CObject* newElement);

Parâmetros

position
Um POSITION valor devolvido por uma chamada anterior GetNextde , GetPrev, ou Find de função membro.

newElement
O ponteiro de objeto a ser adicionado a esta lista.

A tabela seguinte mostra outras funções membros semelhantes a CObList::InsertAfter.

Class	Função de Membro
`CPtrList`	`POSITION InsertAfter( POSITION position , void * newElement );`
`CStringList`	`POSITION InsertAfter( POSITION position , const CString& newElement );` `POSITION InsertAfter( POSITION position , LPCTSTR newElement );`

Valor de retorno

Um POSITION valor que é igual ao position parâmetro.

Example

Veja CObList::CObList uma lista da CAge turma.

CObList list;
POSITION pos1, pos2;
list.AddHead(new CAge(21));
list.AddHead(new CAge(40)); // List now contains (40, 21).
if ((pos1 = list.GetHeadPosition()) != NULL)
{
    pos2 = list.InsertAfter(pos1, new CAge(65));
}
#ifdef _DEBUG
   afxDump.SetDepth(1);
   afxDump << _T("InsertAfter example: ") << &list << _T("\n");
#endif

Os resultados deste programa são os seguintes:

InsertAfter example: A CObList with 3 elements
a CAge at $4A44 40
a CAge at $4A64 65
a CAge at $4968 21

`CObList::InsertBefore`

Adiciona um elemento a esta lista antes do elemento na posição especificada.

POSITION InsertBefore(
    POSITION position,
    CObject* newElement);

Parâmetros

position
Um POSITION valor devolvido por uma chamada anterior GetNextde , GetPrev, ou Find de função membro.

newElement
O ponteiro de objeto a ser adicionado a esta lista.

Valor de retorno

Um POSITION valor que pode ser usado para iteração ou recuperação de ponteiros de objetos; NULL se a lista estiver vazia.

A tabela seguinte mostra outras funções membros semelhantes a CObList::InsertBefore.

Class	Função de Membro
`CPtrList`	`POSITION InsertBefore( POSITION position , void * newElement );`
`CStringList`	`POSITION InsertBefore( POSITION position , const CString& newElement );` `POSITION InsertBefore( POSITION position , LPCTSTR newElement );`

Example

Veja CObList::CObList uma lista da CAge turma.

CObList list;
POSITION pos1, pos2;
list.AddHead(new CAge(21));
list.AddHead(new CAge(40)); // List now contains (40, 21).
if ((pos1 = list.GetTailPosition()) != NULL)
{
    pos2 = list.InsertBefore(pos1, new CAge(65));
}
#ifdef _DEBUG
   afxDump.SetDepth(1);
   afxDump << _T("InsertBefore example: ") << &list << _T("\n");
#endif

Os resultados deste programa são os seguintes:

InsertBefore example: A CObList with 3 elements
a CAge at $4AE2 40
a CAge at $4B02 65
a CAge at $49E6 21

`CObList::IsEmpty`

Indica se esta lista não contém elementos.

BOOL IsEmpty() const;

Valor de retorno

Diferente de zero se esta lista estiver vazia; caso contrário, 0.

A tabela seguinte mostra outras funções membros semelhantes a CObList::IsEmpty.

Class	Função de Membro
`CPtrList`	BOOL IsEmpty( ) const;
`CStringList`	BOOL IsEmpty( ) const;

Example

Veja o exemplo para RemoveAll.

`CObList::RemoveAll`

Remove todos os elementos desta lista e liberta a memória associada CObList .

void RemoveAll();

Observações

Não é gerado erro se a lista já estiver vazia.

Quando removes elementos de um CObList, removes os ponteiros de objeto da lista. É tua responsabilidade apagar os próprios objetos.

A tabela seguinte mostra outras funções membros semelhantes a CObList::RemoveAll.

Class	Função de Membro
`CPtrList`	`void RemoveAll( );`
`CStringList`	`void RemoveAll( );`

Example

Veja CObList::CObList uma lista da CAge turma.

CObList list;
CAge* pa1;
CAge* pa2;
ASSERT(list.IsEmpty()); // Yes it is.
list.AddHead(pa1 = new CAge(21));
list.AddHead(pa2 = new CAge(40)); // List now contains (40, 21).
ASSERT(!list.IsEmpty()); // No it isn't.
list.RemoveAll(); // CAges aren't destroyed.
ASSERT(list.IsEmpty()); // Yes it is.
delete pa1;     // Now delete the CAge objects.
delete pa2;

`CObList::RemoveAt`

Remove o elemento especificado desta lista.

void RemoveAt(POSITION position);

Parâmetros

position
A posição do elemento a ser removido da lista.

Observações

Quando remove um elemento de um CObList, remove o ponteiro de objeto da lista. É tua responsabilidade apagar os próprios objetos.

Deve garantir que o seu POSITION valor representa uma posição válida na lista. Se for inválido, então a versão Debug da Microsoft Foundation Class Library afirma.

A tabela seguinte mostra outras funções membros semelhantes a CObList::RemoveAt.

Class	Função de Membro
`CPtrList`	`void RemoveAt( POSITION position );`
`CStringList`	`void RemoveAt( POSITION position );`

Example

Tenha cuidado ao remover um elemento durante uma iteração de lista. O exemplo seguinte mostra uma técnica de remoção que garante um valor válido POSITION para GetNext.

Veja CObList::CObList uma lista da CAge turma.

CObList list;
POSITION pos1, pos2;
CObject* pa;

list.AddHead(new CAge(21));
list.AddHead(new CAge(40));
list.AddHead(new CAge(65)); // List now contains (65 40, 21).
for (pos1 = list.GetHeadPosition(); (pos2 = pos1) != NULL;)
{
   if (*(CAge*)list.GetNext(pos1) == CAge(40))
   {
      pa = list.GetAt(pos2); // Save the old pointer for
                             //deletion.
      list.RemoveAt(pos2);
      delete pa; // Deletion avoids memory leak.
   }
}
#ifdef _DEBUG
afxDump.SetDepth(1);
afxDump << _T("RemoveAt example: ") << &list << _T("\n");
#endif

Os resultados deste programa são os seguintes:

RemoveAt example: A CObList with 2 elements

a CAge at $4C1E 65

a CAge at $4B22 21

`CObList::RemoveHead`

Remove o elemento do cabeçalho da lista e devolve um ponteiro para ele.

CObject* RemoveHead();

Valor de retorno

O CObject ponteiro anteriormente no topo da lista.

Observações

Deve certificar-se de que a lista não está vazia antes de ligar RemoveHead. Se a lista estiver vazia, então a versão Debug da Microsoft Foundation Class Library afirma. Use IsEmpty para verificar se a lista contém elementos.

A tabela seguinte mostra outras funções membros semelhantes a CObList::RemoveHead.

Class	Função de Membro
`CPtrList`	`void* RemoveHead( );`
`CStringList`	`CString RemoveHead( );`

Example

Veja CObList::CObList uma lista da CAge turma.

CObList list;
CAge* pa1;
CAge* pa2;

list.AddHead(pa1 = new CAge(21));
list.AddHead(pa2 = new CAge(40)); // List now contains (40, 21).
ASSERT(*(CAge*)list.RemoveHead() == CAge(40));  // Old head
ASSERT(*(CAge*)list.GetHead() == CAge(21));  // New head
delete pa1;
delete pa2;

`CObList::RemoveTail`

Remove o elemento da cauda da lista e devolve um ponteiro para ele.

CObject* RemoveTail();

Valor de retorno

Um apontador para o objeto que estava no final da lista.

Observações

Deve certificar-se de que a lista não está vazia antes de ligar RemoveTail. Se a lista estiver vazia, então a versão Debug da Microsoft Foundation Class Library afirma. Use IsEmpty para verificar se a lista contém elementos.

A tabela seguinte mostra outras funções membros semelhantes a CObList::RemoveTail.

Class	Função de Membro
`CPtrList`	`void* RemoveTail( );`
`CStringList`	`CString RemoveTail( );`

Example

Veja CObList::CObList uma lista da CAge turma.

CObList list;
CAge* pa1;
CAge* pa2;

list.AddHead(pa1 = new CAge(21));
list.AddHead(pa2 = new CAge(40)); // List now contains (40, 21).
ASSERT(*(CAge*)list.RemoveTail() == CAge(21));  // Old tail
ASSERT(*(CAge*)list.GetTail() == CAge(40));  // New tail
delete pa1;
delete pa2; // Clean up memory.

`CObList::SetAt`

Coloca o elemento numa posição dada.

void SetAt(
    POSITION pos,
    CObject* newElement);

Parâmetros

pos
O POSITION do elemento a definir.

newElement
O CObject ponteiro a ser escrito para a lista.

Observações

Uma variável do tipo POSITION é uma chave para a lista. Não é o mesmo que um índice, e não podes operar num POSITION valor por ti próprio. SetAt escreve o CObject ponteiro para a posição especificada na lista.

Deve garantir que o seu POSITION valor representa uma posição válida na lista. Se for inválido, então a versão Debug da Microsoft Foundation Class Library afirma.

A tabela seguinte mostra outras funções membros semelhantes a CObList::SetAt.

Class	Função de Membro
`CPtrList`	`void SetAt( POSITION pos , const CString& newElement );`
`CStringList`	`void SetAt( POSITION pos , LPCTSTR newElement );`

Example

Veja CObList::CObList uma lista da CAge turma.

CObList list;
CObject* pa;
POSITION pos;

list.AddHead(new CAge(21));
list.AddHead(new CAge(40)); // List now contains (40, 21).
if ((pos = list.GetTailPosition()) != NULL)
{
   pa = list.GetAt(pos); // Save the old pointer for 
                         //deletion.
   list.SetAt(pos, new CAge(65));  // Replace the tail 
                                     //element.
   delete pa;  // Deletion avoids memory leak.
}
#ifdef _DEBUG
afxDump.SetDepth(1);
afxDump << _T("SetAt example: ") << &list << _T("\n");
#endif

Os resultados deste programa são os seguintes:

SetAt example: A CObList with 2 elements
a CAge at $4D98 40
a CAge at $4DB8 65

Consulte também

CObject Classe
Gráfico de Hierarquia
CStringList Classe
CPtrList Classe

Comentários

Esta página foi útil?

Last updated on 2026-02-23

Partilhar via

CObList Classe

Sintaxe

Membros

Construtores Públicos

Métodos Públicos

Observações

Hierarquia de herança

Requerimentos

CObList::AddHead

Parâmetros

Valor de retorno

Observações

Example

CObList::AddTail

Parâmetros

Valor de retorno

Observações

Example

CObList::CObList

Parâmetros

Observações

Example

CObList::Find

Parâmetros

Valor de retorno

Observações

Example

CObList::FindIndex

Parâmetros

Valor de retorno

Observações

Example

CObList::GetAt

Parâmetros

Valor de retorno

Observações

Example

CObList::GetCount

Valor de retorno

Example

CObList::GetHead

Valor de retorno

Observações

Example

CObList::GetHeadPosition

Valor de retorno

Example

CObList::GetNext

Parâmetros

Valor de retorno

Observações

Example

CObList::GetPrev

Parâmetros

Valor de retorno

Observações

Example

CObList::GetSize

Valor de retorno

Observações

Example

CObList::GetTail

Valor de retorno

Observações

Example

CObList::GetTailPosition

Valor de retorno

Example

CObList::InsertAfter

Parâmetros

Valor de retorno

Example

CObList::InsertBefore

Parâmetros

Valor de retorno

Example

CObList::IsEmpty

Valor de retorno

Example

`CObList` Classe

`CObList::AddHead`

`CObList::AddTail`

`CObList::CObList`

`CObList::Find`

`CObList::FindIndex`

`CObList::GetAt`

`CObList::GetCount`

`CObList::GetHead`

`CObList::GetHeadPosition`

`CObList::GetNext`

`CObList::GetPrev`

`CObList::GetSize`

`CObList::GetTail`

`CObList::GetTailPosition`

`CObList::InsertAfter`

`CObList::InsertBefore`

`CObList::IsEmpty`

`CObList::RemoveAll`

`CObList::RemoveAt`

`CObList::RemoveHead`

`CObList::RemoveTail`

`CObList::SetAt`