Classe `CObList`

Articolo
10/12/2023

Supporta elenchi ordinati di puntatori non univoci CObject accessibili in sequenza o in base al valore del puntatore.

Sintassi

class CObList : public CObject

Membri

Costruttori pubblici

Nome	Descrizione
`CObList::CObList`	Costruisce un elenco vuoto per `CObject` i puntatori.

Metodi pubblici

Nome	Descrizione
`CObList::AddHead`	Aggiunge un elemento (o tutti gli elementi di un altro elenco) all'inizio dell'elenco (crea una nuova testa).
`CObList::AddTail`	Aggiunge un elemento (o tutti gli elementi di un altro elenco) alla parte finale dell'elenco (crea una nuova coda).
`CObList::Find`	Ottiene la posizione di un elemento specificato dal valore del puntatore.
`CObList::FindIndex`	Ottiene la posizione di un elemento specificato da un indice in base zero.
`CObList::GetAt`	Ottiene l'elemento in corrispondenza di una determinata posizione.
`CObList::GetCount`	Restituisce il numero di elementi nell'elenco.
`CObList::GetHead`	Restituisce l'elemento head dell'elenco (non può essere vuoto).
`CObList::GetHeadPosition`	Restituisce la posizione dell'elemento head dell'elenco.
`CObList::GetNext`	Ottiene l'elemento successivo per l'iterazione.
`CObList::GetPrev`	Ottiene l'elemento precedente per l'iterazione.
`CObList::GetSize`	Restituisce il numero di elementi nell'elenco.
`CObList::GetTail`	Restituisce l'elemento finale dell'elenco (non può essere vuoto).
`CObList::GetTailPosition`	Restituisce la posizione dell'elemento finale dell'elenco.
`CObList::InsertAfter`	Inserisce un nuovo elemento dopo una determinata posizione.
`CObList::InsertBefore`	Inserisce un nuovo elemento prima di una determinata posizione.
`CObList::IsEmpty`	Verifica la condizione di elenco vuota (nessun elemento).
`CObList::RemoveAll`	Rimuove tutti gli elementi dall'elenco.
`CObList::RemoveAt`	Rimuove un elemento da questo elenco, specificato dalla posizione.
`CObList::RemoveHead`	Rimuove l'elemento dall'inizio dell'elenco.
`CObList::RemoveTail`	Rimuove l'elemento dalla parte finale dell'elenco.
`CObList::SetAt`	Imposta l'elemento in una determinata posizione.

Osservazioni:

CObList gli elenchi si comportano come elenchi collegati doubly.

Una variabile di tipo POSITION è una chiave per l'elenco. È possibile usare una POSITION variabile sia come iteratore per attraversare un elenco in sequenza che come segnalibro per contenere una posizione. Una posizione non corrisponde tuttavia a un indice.

L'inserimento degli elementi è molto veloce all'inizio dell'elenco, alla coda e a un oggetto noto POSITION. Una ricerca sequenziale è necessaria per cercare un elemento in base al valore o all'indice. Questa ricerca può essere lenta se l'elenco è lungo.

CObList incorpora la macro IMPLEMENT_SERIAL per supportare la serializzazione e il dump dei relativi elementi. Se un elenco di CObject puntatori viene archiviato in un archivio, con un operatore di inserimento di overload o con la Serialize funzione membro, ogni CObject elemento viene serializzato a sua volta.

Se è necessario un dump di singoli CObject elementi nell'elenco, è necessario impostare la profondità del contesto di dump su 1 o versione successiva.

Quando un CObList oggetto viene eliminato o quando i relativi elementi vengono rimossi, vengono rimossi solo i CObject puntatori, non gli oggetti a cui fanno riferimento.

È possibile derivare classi personalizzate da CObList. La nuova classe di elenco, progettata per contenere puntatori a oggetti derivati da CObject, aggiunge nuovi membri dati e nuove funzioni membro. Si noti che l'elenco risultante non è strettamente indipendente dai tipi, perché consente l'inserimento di qualsiasi CObject puntatore.

Nota

Se si intende serializzare l'elenco, è necessario utilizzare la IMPLEMENT_SERIAL macro nell'implementazione della classe derivata.

Per altre informazioni sull'uso CObListdi , vedere l'articolo Raccolte.

Gerarchia di ereditarietà

CObject

CObList

Requisiti

Intestazione: afxcoll.h

`CObList::AddHead`

Aggiunge un nuovo elemento o un elenco di elementi all'inizio di questo elenco.

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

Parametri

newElement
Puntatore CObject da aggiungere a questo elenco.

pNewList
Puntatore a un altro CObList elenco. Gli elementi in pNewList verranno aggiunti a questo elenco.

Valore restituito

La prima versione restituisce il POSITION valore dell'elemento appena inserito.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::AddHead.

Classe	Funzione membro
`CPtrList`	`POSITION AddHead( void * newElement );` `void AddHead( CPtrList * pNewList );`
`CStringList`	`POSITION AddHead(const CString& newElement );` `POSITION AddHead(LPCTSTR newElement );` `void AddHead(CStringList * pNewList );`

Osservazioni:

L'elenco può essere vuoto prima dell'operazione.

Esempio

Vedere CObList::CObList per un elenco della CAge classe.

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

I risultati di questo programma sono i seguenti:

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

`CObList::AddTail`

Aggiunge un nuovo elemento o un elenco di elementi alla fine dell'elenco.

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

Parametri

newElement
Puntatore CObject da aggiungere a questo elenco.

pNewList
Puntatore a un altro CObList elenco. Gli elementi in pNewList verranno aggiunti a questo elenco.

Valore restituito

La prima versione restituisce il POSITION valore dell'elemento appena inserito.

Osservazioni:

L'elenco può essere vuoto prima dell'operazione.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::AddTail.

Classe	Funzione membro
`CPtrList`	`POSITION AddTail( void * newElement );` `void AddTail( CPtrList * pNewList );`
`CStringList`	`POSITION AddTail( const CString& newElement );` `POSITION AddTail( LPCTSTR newElement );` `void AddTail( CStringList * pNewList );`

Esempio

Vedere CObList::CObList per un elenco della CAge classe.

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

I risultati di questo programma sono i seguenti:

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

`CObList::CObList`

Costruisce un elenco di puntatori vuoto CObject .

CObList(INT_PTR nBlockSize = 10);

Parametri

nBlockSize
Granularità dell'allocazione di memoria per estendere l'elenco.

Osservazioni:

Man mano che l'elenco aumenta, la memoria viene allocata in unità di nBlockSize voci. Se un'allocazione di memoria non riesce, viene generata un'eccezione CMemoryException .

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::CObList.

Classe	Funzione membro
`CPtrList`	`CPtrList( INT_PTR nBlockSize = 10 );`
`CStringList`	`CStringList( INT_PTR nBlockSize = 10 );`

Esempio

Di seguito è riportato un elenco della CObjectclasse CAge derivata da usata in tutti gli esempi di raccolta:

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

Di seguito è riportato un esempio di utilizzo del CObList costruttore:

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

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

`CObList::Find`

Cerca nell'elenco in sequenza per trovare il primo CObject puntatore corrispondente al puntatore specificato CObject .

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

Parametri

searchValue
Puntatore all'oggetto da trovare in questo elenco.

startAfter
Posizione iniziale per la ricerca.

Valore restituito

Valore POSITION che può essere utilizzato per il recupero dell'iterazione o del puntatore a oggetti; NULL se l'oggetto non viene trovato.

Osservazioni:

Si noti che i valori del puntatore vengono confrontati, non il contenuto degli oggetti .

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::Find.

Classe	Funzione membro
`CPtrList`	`POSITION Find( void *searchValue , POSITION startAfter = NULL ) const;`
`CStringList`	`POSITION Find( LPCTSTR searchValue , POSITION startAfter = NULL ) const;`

Esempio

Vedere CObList::CObList per un elenco della CAge classe.

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`

Usa il valore di nIndex come indice nell'elenco.

POSITION FindIndex(INT_PTR nIndex) const;

Parametri

nIndex
Indice in base zero dell'elemento elenco da trovare.

Valore restituito

Valore POSITION che può essere utilizzato per il recupero dell'iterazione o del puntatore a oggetti; NULL se nIndex è troppo grande. Il framework genera un'asserzione se nIndex è negativa.

Osservazioni:

Avvia un'analisi sequenziale dall'inizio dell'elenco, fermandosi sull'n elemento.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::FindIndex.

Classe	Funzione membro
`CPtrList`	`POSITION FindIndex( INT_PTR nIndex ) const;`
`CStringList`	`POSITION FindIndex( INT_PTR nIndex ) const;`

Esempio

Vedere CObList::CObList per un elenco della CAge classe.

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`

Una variabile di tipo POSITION è una chiave per l'elenco.

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

Parametri

position
Valore POSITION restituito da una chiamata di funzione precedente GetHeadPosition o Find membro.

Valore restituito

Vedere la descrizione del valore restituito per GetHead.

Osservazioni:

Non è uguale a un indice e non è possibile operare manualmente su un POSITION valore. GetAt recupera il CObject puntatore associato a una determinata posizione.

È necessario assicurarsi che il POSITION valore rappresenti una posizione valida nell'elenco. Se non è valido, la versione debug della libreria di classi Microsoft Foundation asserisce.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::GetAt.

Classe	Funzione membro
`CPtrList`	`const void& GetAt( POSITION position ) const;` `void& GetAt( POSITION position );`
`CStringList`	`const CString& GetAt( POSITION position ) const;` `CString& GetAt( POSITION position );`

Esempio

Vedere l'esempio per FindIndex.

`CObList::GetCount`

Ottiene il numero di elementi nell'elenco.

INT_PTR GetCount() const;

Valore restituito

Valore intero contenente il conteggio degli elementi.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::GetCount.

Classe	Funzione membro
`CPtrList`	`INT_PTR GetCount( ) const;`
`CStringList`	`INT_PTR GetCount( ) const;`

Esempio

Vedere CObList::CObList per un elenco della CAge classe.

CObList list;

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

`CObList::GetHead`

Ottiene il CObject puntatore che rappresenta l'elemento head di questo elenco.

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

Valore restituito

Se l'elenco è accessibile tramite un puntatore a un const CObListoggetto , GetHead restituisce un CObject puntatore. In questo modo la funzione può essere usata solo sul lato destro di un'istruzione di assegnazione e quindi protegge l'elenco dalla modifica.

Se l'elenco è accessibile direttamente o tramite un puntatore a un CObListoggetto , GetHead restituisce un riferimento a un CObject puntatore. Ciò consente di usare la funzione su entrambi i lati di un'istruzione di assegnazione e di conseguenza consente di modificare le voci di elenco.

Osservazioni:

È necessario assicurarsi che l'elenco non sia vuoto prima di chiamare GetHead. Se l'elenco è vuoto, la versione debug della libreria di classi Microsoft Foundation asserisce. Utilizzare IsEmpty per verificare che l'elenco contenga elementi.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::GetHead.

Classe	Funzione membro
`CPtrList`	`const void& GetHead( ) const; void& GetHead( );`
`CStringList`	`const CString& GetHead( ) const; CString& GetHead( );`

Esempio

Vedere CObList::CObList per un elenco della CAge classe.

Nell'esempio seguente viene illustrato l'uso di GetHead sul lato sinistro di un'istruzione di assegnazione.

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`

Ottiene la posizione dell'elemento head dell'elenco.

POSITION GetHeadPosition() const;

Valore restituito

Valore POSITION che può essere utilizzato per il recupero dell'iterazione o del puntatore a oggetti; NULL se l'elenco è vuoto.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::GetHeadPosition.

Classe	Funzione membro
`CPtrList`	`POSITION GetHeadPosition( ) const;`
`CStringList`	`POSITION GetHeadPosition( ) const;`

Esempio

Vedere CObList::CObList per un elenco della CAge classe.

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`

Ottiene l'elemento elenco identificato da rPosition, quindi imposta rPosition sul POSITION valore della voce successiva nell'elenco.

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

Parametri

rPosition
Riferimento a un POSITION valore restituito da una precedente GetNextchiamata di funzione membro , GetHeadPositiono .

Valore restituito

Vedere la descrizione del valore restituito per GetHead.

Osservazioni:

È possibile usare GetNext in un ciclo di iterazione in avanti se si stabilisce la posizione iniziale con una chiamata a GetHeadPosition o Find.

È necessario assicurarsi che il POSITION valore rappresenti una posizione valida nell'elenco. Se non è valido, la versione debug della libreria di classi Microsoft Foundation asserisce.

Se l'elemento recuperato è l'ultimo nell'elenco, il nuovo valore di rPosition viene impostato su NULL.

È possibile rimuovere un elemento durante un'iterazione. Vedere l'esempio per RemoveAt.

Nota

A partire da MFC 8.0 la versione const di questo metodo è stata modificata in modo da restituire const CObject* anziché const CObject*&. Questa modifica è stata apportata per rendere il compilatore conforme allo standard C++.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::GetNext.

Classe	Funzione membro
`CPtrList`	`void& GetNext( POSITION&` `rPosition` `);` `const void GetNext( POSITION&` `rPosition` `) const;`
`CStringList`	`CString& GetNext( POSITION&` `rPosition` `);` `const CString& GetNext( POSITION&` `rPosition` `) const;`

Esempio

Vedere CObList::CObList per un elenco della CAge classe.

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

I risultati di questo programma sono i seguenti:

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

`CObList::GetPrev`

Ottiene l'elemento elenco identificato da rPosition, quindi imposta rPosition sul POSITION valore della voce precedente nell'elenco.

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

Parametri

rPosition
Riferimento a un POSITION valore restituito da una chiamata di funzione precedente GetPrev o di altro membro.

Valore restituito

Vedere la descrizione del valore restituito per GetHead.

Osservazioni:

È possibile usare GetPrev in un ciclo di iterazione inversa se si stabilisce la posizione iniziale con una chiamata a GetTailPosition o Find.

È necessario assicurarsi che il POSITION valore rappresenti una posizione valida nell'elenco. Se non è valido, la versione debug della libreria di classi Microsoft Foundation asserisce.

Se l'elemento recuperato è il primo nell'elenco, il nuovo valore di rPosition viene impostato su NULL.

Nota

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::GetPrev.

Classe	Funzione membro
`CPtrList`	`void& GetPrev( POSITION&` `rPosition` `);` `const void GetPrev( POSITION&` `rPosition` `) const;`
`CStringList`	`CString& GetPrev( POSITION&` `rPosition` `);` `const CString& GetPrev( POSITION&` `rPosition` `) const;`

Esempio

Vedere CObList::CObList per un elenco della CAge classe.

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
}

I risultati di questo programma sono i seguenti:

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

`CObList::GetSize`

Restituisce il numero di elementi elenco.

INT_PTR GetSize() const;

Valore restituito

Numero di elementi nell'elenco.

Osservazioni:

Chiamare questo metodo per recuperare il numero di elementi nell'elenco.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::GetSize.

Classe	Funzione membro
`CPtrList`	`INT_PTR GetSize( ) const;`
`CStringList`	`INT_PTR GetSize( ) const;`

Esempio

Vedere CObList::CObList per un elenco della CAge classe.

CObList list;

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

`CObList::GetTail`

Ottiene il CObject puntatore che rappresenta l'elemento finale dell'elenco.

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

Valore restituito

Vedere la descrizione del valore restituito per GetHead.

Osservazioni:

È necessario assicurarsi che l'elenco non sia vuoto prima di chiamare GetTail. Se l'elenco è vuoto, la versione debug della libreria di classi Microsoft Foundation asserisce. Utilizzare IsEmpty per verificare che l'elenco contenga elementi.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::GetTail.

Classe	Funzione membro
`CPtrList`	`const void& GetTail( ) const; void& GetTail( );`
`CStringList`	`const CString& GetTail( ) const; CString& GetTail( );`

Esempio

Vedere CObList::CObList per un elenco della CAge classe.

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`

Ottiene la posizione dell'elemento finale dell'elenco; NULL se l'elenco è vuoto.

POSITION GetTailPosition() const;

Valore restituito

Valore POSITION che può essere utilizzato per il recupero dell'iterazione o del puntatore a oggetti; NULL se l'elenco è vuoto.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::GetTailPosition.

Classe	Funzione membro
`CPtrList`	`POSITION GetTailPosition( ) const;`
`CStringList`	`POSITION GetTailPosition( ) const;`

Esempio

Vedere CObList::CObList per un elenco della CAge classe.

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`

Aggiunge un elemento a questo elenco dopo l'elemento nella posizione specificata.

POSITION InsertAfter(
    POSITION position,
    CObject* newElement);

Parametri

position
Valore POSITION restituito da una chiamata di funzione membro , GetPrevo Find precedenteGetNext.

newElement
Puntatore all'oggetto da aggiungere a questo elenco.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::InsertAfter.

Classe	Funzione membro
`CPtrList`	`POSITION InsertAfter( POSITION position , void * newElement );`
`CStringList`	`POSITION InsertAfter( POSITION position , const CString& newElement );` `POSITION InsertAfter( POSITION position , LPCTSTR newElement );`

Valore restituito

Valore POSITION uguale al position parametro .

Esempio

Vedere CObList::CObList per un elenco della CAge classe.

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

I risultati di questo programma sono i seguenti:

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

`CObList::InsertBefore`

Aggiunge un elemento all'elenco prima dell'elemento nella posizione specificata.

POSITION InsertBefore(
    POSITION position,
    CObject* newElement);

Parametri

position
Valore POSITION restituito da una chiamata di funzione membro , GetPrevo Find precedenteGetNext.

newElement
Puntatore all'oggetto da aggiungere a questo elenco.

Valore restituito

Valore POSITION che può essere utilizzato per il recupero dell'iterazione o del puntatore a oggetti; NULL se l'elenco è vuoto.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::InsertBefore.

Classe	Funzione membro
`CPtrList`	`POSITION InsertBefore( POSITION position , void * newElement );`
`CStringList`	`POSITION InsertBefore( POSITION position , const CString& newElement );` `POSITION InsertBefore( POSITION position , LPCTSTR newElement );`

Esempio

Vedere CObList::CObList per un elenco della CAge classe.

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

I risultati di questo programma sono i seguenti:

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 l'elenco non contiene elementi.

BOOL IsEmpty() const;

Valore restituito

Diverso da zero se l'elenco è vuoto; in caso contrario, 0.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::IsEmpty.

Classe	Funzione membro
`CPtrList`	BOOL IsEmpty( ) const;
`CStringList`	BOOL IsEmpty( ) const;

Esempio

Vedere l'esempio per RemoveAll.

`CObList::RemoveAll`

Rimuove tutti gli elementi da questo elenco e libera la memoria associata CObList .

void RemoveAll();

Osservazioni:

Se l'elenco è già vuoto, non viene generato alcun errore.

Quando si rimuovono elementi da un oggetto CObList, si rimuovono i puntatori agli oggetti dall'elenco. È responsabilità dell'utente eliminare gli oggetti stessi.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::RemoveAll.

Classe	Funzione membro
`CPtrList`	`void RemoveAll( );`
`CStringList`	`void RemoveAll( );`

Esempio

Vedere CObList::CObList per un elenco della CAge classe.

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`

Rimuove l'elemento specificato da questo elenco.

void RemoveAt(POSITION position);

Parametri

position
Posizione dell'elemento da rimuovere dall'elenco.

Osservazioni:

Quando si rimuove un elemento da un CObListoggetto , si rimuove il puntatore all'oggetto dall'elenco. È responsabilità dell'utente eliminare gli oggetti stessi.

È necessario assicurarsi che il POSITION valore rappresenti una posizione valida nell'elenco. Se non è valido, la versione debug della libreria di classi Microsoft Foundation asserisce.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::RemoveAt.

Classe	Funzione membro
`CPtrList`	`void RemoveAt( POSITION position );`
`CStringList`	`void RemoveAt( POSITION position );`

Esempio

Prestare attenzione quando si rimuove un elemento durante un'iterazione dell'elenco. Nell'esempio seguente viene illustrata una tecnica di rimozione che garantisce un valore valido POSITION per GetNext.

Vedere CObList::CObList per un elenco della CAge classe.

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

I risultati di questo programma sono i seguenti:

RemoveAt example: A CObList with 2 elements

a CAge at $4C1E 65

a CAge at $4B22 21

`CObList::RemoveHead`

Rimuove l'elemento dall'intestazione dell'elenco e ne restituisce un puntatore.

CObject* RemoveHead();

Valore restituito

Puntatore CObject precedentemente all'inizio dell'elenco.

Osservazioni:

È necessario assicurarsi che l'elenco non sia vuoto prima di chiamare RemoveHead. Se l'elenco è vuoto, la versione debug della libreria di classi Microsoft Foundation asserisce. Utilizzare IsEmpty per verificare che l'elenco contenga elementi.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::RemoveHead.

Classe	Funzione membro
`CPtrList`	`void* RemoveHead( );`
`CStringList`	`CString RemoveHead( );`

Esempio

Vedere CObList::CObList per un elenco della CAge classe.

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`

Rimuove l'elemento dalla parte finale dell'elenco e ne restituisce un puntatore.

CObject* RemoveTail();

Valore restituito

Puntatore all'oggetto che si trovava nella parte finale dell'elenco.

Osservazioni:

È necessario assicurarsi che l'elenco non sia vuoto prima di chiamare RemoveTail. Se l'elenco è vuoto, la versione debug della libreria di classi Microsoft Foundation asserisce. Utilizzare IsEmpty per verificare che l'elenco contenga elementi.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::RemoveTail.

Classe	Funzione membro
`CPtrList`	`void* RemoveTail( );`
`CStringList`	`CString RemoveTail( );`

Esempio

Vedere CObList::CObList per un elenco della CAge classe.

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`

Imposta l'elemento in una determinata posizione.

void SetAt(
    POSITION pos,
    CObject* newElement);

Parametri

pos
Oggetto POSITION dell'elemento da impostare.

newElement
Puntatore CObject da scrivere nell'elenco.

Osservazioni:

Una variabile di tipo POSITION è una chiave per l'elenco. Non è uguale a un indice e non è possibile operare manualmente su un POSITION valore. SetAt scrive il CObject puntatore nella posizione specificata nell'elenco.

È necessario assicurarsi che il POSITION valore rappresenti una posizione valida nell'elenco. Se non è valido, la versione debug della libreria di classi Microsoft Foundation asserisce.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObList::SetAt.

Classe	Funzione membro
`CPtrList`	`void SetAt( POSITION pos , const CString& newElement );`
`CStringList`	`void SetAt( POSITION pos , LPCTSTR newElement );`

Esempio

Vedere CObList::CObList per un elenco della CAge classe.

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

I risultati di questo programma sono i seguenti:

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

Vedi anche

CObject Classe
Grafico della gerarchia
CStringList Classe
CPtrList Classe

Condividi tramite

Classe CObList

Sintassi

Membri

Costruttori pubblici

Metodi pubblici

Osservazioni:

Gerarchia di ereditarietà

Requisiti

CObList::AddHead

Parametri

Valore restituito

Osservazioni:

Esempio

CObList::AddTail

Parametri

Valore restituito

Osservazioni:

Esempio

CObList::CObList

Parametri

Osservazioni:

Esempio

CObList::Find

Parametri

Valore restituito

Osservazioni:

Esempio

CObList::FindIndex

Parametri

Valore restituito

Osservazioni:

Esempio

CObList::GetAt

Parametri

Valore restituito

Osservazioni:

Esempio

CObList::GetCount

Valore restituito

Esempio

CObList::GetHead

Valore restituito

Osservazioni:

Esempio

CObList::GetHeadPosition

Valore restituito

Esempio

CObList::GetNext

Parametri

Valore restituito

Osservazioni:

Esempio

CObList::GetPrev

Parametri

Valore restituito

Osservazioni:

Esempio

CObList::GetSize

Valore restituito

Osservazioni:

Esempio

CObList::GetTail

Valore restituito

Osservazioni:

Esempio

CObList::GetTailPosition

Valore restituito

Esempio

CObList::InsertAfter

Parametri

Valore restituito

Esempio

CObList::InsertBefore

Parametri

Valore restituito

Esempio

CObList::IsEmpty

Valore restituito

Esempio

Classe `CObList`

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