Classe CList

Supporta elenchi ordinati di oggetti non univoci accessibili in sequenza o in base al valore.

Sintassi

template<class TYPE, class ARG_TYPE = const TYPE&>
class CList : public CObject

Membri

Costruttori pubblici

Nome	Descrizione
CList::CList	Costruisce un elenco ordinato vuoto.

Metodi pubblici

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

Parametri

TYPE
Tipo di oggetto archiviato nell'elenco.

ARG_TYPE
Tipo utilizzato per fare riferimento agli oggetti archiviati nell'elenco. Può essere un riferimento.

Osservazioni:

CList gli elenchi si comportano come elenchi collegati doubly.

Una variabile di tipo POSITION è una chiave per l'elenco. È possibile usare una POSITION variabile come iteratore per attraversare un elenco in sequenza e come segnalibro per contenere una posizione. Una posizione non è tuttavia uguale 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.

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

Alcune funzioni membro di questa classe chiamano funzioni helper globali che devono essere personalizzate per la maggior parte degli usi della CList classe . Vedere Collection Class Helpers (Helper classi di raccolta) nella sezione "Macro e globals".

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

Esempio

// CList is a template class that takes two template arguments.
// The first argument is type stored internally by the list, the
// second argument is the type used in the arguments for the
// CList methods.

// This code defines a list of ints.
CList<int, int> myIntList;

// This code defines a list of CStrings
CList<CString, CString &> myStringList;

// This code defines a list of MYTYPEs,
// NOTE: MYTYPE could be any struct, class or type definition
CList<MYTYPE, MYTYPE &> myTypeList;

Gerarchia di ereditarietà

CObject

CList

Requisiti

Intestazione: afxtempl.h

CList::AddHead

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

POSITION AddHead(ARG_TYPE newElement);
void AddHead(CList* pNewList);

Parametri

ARG_TYPE
Parametro del modello che specifica il tipo di elemento dell'elenco (può essere un riferimento).

newElement
Nuovo elemento.

pNewList
Puntatore a un altro CList 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.

Esempio

// Declarations of the variables used in the example
CList<CString, CString &> myList;
CList<CString, CString &> myList2;

// There are two versions of CList::AddHead: one adds a single
// element to the front of the list, the second adds another list
// to the front.

// This adds the string "ABC" to the front of myList.
// myList is a list of CStrings (ie defined as CList<CString,CString&>).
myList.AddHead(CString(_T("ABC")));

// This adds the elements of myList2 to the front of myList.
myList.AddHead(&myList2);

CList::AddTail

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

POSITION AddTail(ARG_TYPE newElement);
void AddTail(CList* pNewList);

Parametri

ARG_TYPE
Parametro del modello che specifica il tipo di elemento dell'elenco (può essere un riferimento).

newElement
Elemento da aggiungere all'elenco.

pNewList
Puntatore a un altro CList 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.

Esempio

// Define myList and myList2.
CList<CString, CString &> myList;
CList<CString, CString &> myList2;

// Add elements to the end of myList and myList2.
myList.AddTail(CString(_T("A")));
myList.AddTail(CString(_T("B")));
myList2.AddTail(CString(_T("C")));
myList2.AddTail(CString(_T("D")));

// There are two versions of CList::AddTail: one adds a single
// element to the end of the list, the second adds another list
// to the end.

// This adds the string "ABC" to the end of myList.
// myList is a list of CStrings (ie defined as CList<CString,CString&>).
myList.AddTail(CString(_T("ABC")));
ASSERT(CString(_T("ABC")) == myList.GetTail());

// This adds the elements of myList2 to the end of myList.
myList.AddTail(&myList2);

CList::CList

Costruisce un elenco ordinato vuoto.

CList(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.

Esempio

// This code defines myList as a list of strings
// such that memory gets allocated in chunks of
// 16 strings.
CList<CString, CString &> myList(16);

// This code defines myList2 as a list of ints
// such that memory gets allocated in chunks of
// 128 ints.
CList<int, int> myList2(128);

CList::Find

Cerca nell'elenco in sequenza per trovare il primo elemento corrispondente all'oggetto specificato searchValue.

POSITION Find(
    ARG_TYPE searchValue,
    POSITION startAfter = NULL) const;

Parametri

ARG_TYPE
Parametro del modello che specifica il tipo di elemento dell'elenco (può essere un riferimento).

searchValue
Valore da trovare nell'elenco.

startAfter
Posizione iniziale per la ricerca. Se non viene specificato alcun valore, la ricerca inizia con l'elemento head.

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.

Esempio

// Define myList.
CList<CString, CString &> myList;

// Add three elements to the list.
myList.AddHead(CString(_T("XYZ")));
myList.AddHead(CString(_T("ABC")));
myList.AddHead(CString(_T("123")));

// Find a specific element.
POSITION pos = myList.Find(CString(_T("XYZ")));
ASSERT(CString(_T("XYZ")) == myList.GetAt(pos));

CList::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 è negativo o troppo grande.

Osservazioni:

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

Esempio

// Define myList.
CList<CString, CString &> myList;

// Add three elements to the list.
myList.AddTail(CString(_T("XYZ")));
myList.AddTail(CString(_T("ABC")));
myList.AddTail(CString(_T("123")));

// Verify the first element (index 0).
ASSERT(CString(_T("XYZ")) == myList.GetAt(myList.FindIndex(0)));

// Verify the third element (index 2).
ASSERT(CString(_T("123")) == myList.GetAt(myList.FindIndex(2)));

CList::GetAt

Ottiene l'elemento list in una determinata posizione.

TYPE& GetAt(POSITION position);
const TYPE& GetAt(POSITION position) const;

Parametri

TYPE
Parametro modello che specifica il tipo di oggetto nell'elenco.

position
Posizione nell'elenco dell'elemento da ottenere.

Valore restituito

Vedere la descrizione del valore restituito per GetHead.

Osservazioni:

GetAt restituisce l'elemento (o un riferimento all'elemento) associato a una determinata posizione. Non è uguale a un indice e non è possibile operare manualmente su un POSITION valore. Una variabile di tipo POSITION è una chiave per l'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.

Esempio

Vedere l'esempio per CList::GetHeadPosition.

CList::GetCount

Ottiene il numero di elementi nell'elenco.

INT_PTR GetCount() const;

Valore restituito

Valore intero contenente il conteggio degli elementi.

Osservazioni:

La chiamata a questo metodo genererà lo stesso risultato del CList::GetSize metodo .

Esempio

Vedere l'esempio per CList::RemoveHead.

CList::GetHead

Ottiene l'elemento head (o un riferimento all'elemento head) di questo elenco.

const TYPE& GetHead() const;

TYPE& GetHead();

Parametri

TYPE
Parametro modello che specifica il tipo di oggetto nell'elenco.

Valore restituito

Se l'elenco è const, GetHead restituisce una copia dell'elemento all'inizio dell'elenco. In questo modo la funzione può essere usata solo sul lato destro di un'istruzione di assegnazione e protegge l'elenco dalla modifica.

Se l'elenco non constè , GetHead restituisce un riferimento all'elemento all'inizio dell'elenco. 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.

Esempio

// Define myList.
CList<CString, CString &> myList;

// Add an element to the front of the list.
myList.AddHead(CString(_T("ABC")));

// Verify the element was added to the front of the list.
ASSERT(CString(_T("ABC")) == myList.GetHead());

CList::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.

Esempio

// Define myList.
CList<CString, CString &> myList;

// Add an element to the front of the list.
myList.AddHead(CString(_T("ABC")));

// Verify the element at the head position
// is the one added.
POSITION pos = myList.GetHeadPosition();
ASSERT(CString(_T("ABC")) == myList.GetAt(pos));

CList::GetNext

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

TYPE& GetNext(POSITION& rPosition);
const TYPE& GetNext(POSITION& rPosition) const;

Parametri

TYPE
Parametro del modello che specifica il tipo degli elementi nell'elenco.

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

Valore restituito

Se l'elenco è const, GetNext restituisce una copia di un elemento dell'elenco. In questo modo la funzione può essere usata solo sul lato destro di un'istruzione di assegnazione e protegge l'elenco dalla modifica.

Se l'elenco non constè , GetNext restituisce un riferimento a un elemento dell'elenco. 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:

È 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.

Esempio

// Define myList.
// Define myList.
CList<CString, CString &> myList;

// Add two elements to the list.
myList.AddHead(CString(_T("ABC")));
myList.AddHead(CString(_T("123")));

// Dump the list elements to the debug window.
POSITION pos = myList.GetHeadPosition();
for (int i = 0; i < myList.GetCount(); i++)
{
   TRACE(_T("%s\r\n"), (LPCTSTR)myList.GetNext(pos));
}

CList::GetPrev

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

TYPE& GetPrev(POSITION& rPosition);
const TYPE& GetPrev(POSITION& rPosition) const;

Parametri

TYPE
Parametro del modello che specifica il tipo degli elementi nell'elenco.

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

Valore restituito

Se l'elenco è const, GetPrev restituisce una copia dell'elemento all'inizio dell'elenco. In questo modo la funzione può essere usata solo sul lato destro di un'istruzione di assegnazione e protegge l'elenco dalla modifica.

Se l'elenco non constè , GetPrev restituisce un riferimento a un elemento dell'elenco. 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:

È 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.

Esempio

// Define myList.
CList<CString,CString&> myList;

// Add two elements to the list.
myList.AddHead(CString(_T("ABC")));
myList.AddHead(CString(_T("123")));

// Dump the list elements to the debug window,
// in reverse order.
POSITION pos = myList.GetTailPosition();
for (int i = 0; i < myList.GetCount(); i++)
{
   TRACE(_T("%s\r\n"), (LPCTSTR)myList.GetPrev(pos));
}

CList::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. La chiamata a questo metodo genererà lo stesso risultato del CList::GetCount metodo .

Esempio

// Define myList.
CList<CString, CString &> myList;

// Add two elements to the list.
myList.AddHead(CString(_T("ABC")));
myList.AddHead(CString(_T("123")));

// Remove the head element and verify the list.
// NOTE: once the head is removed, the number of
// elements in the list will be one.
CString strHead = myList.RemoveHead();
ASSERT((CString(_T("123")) == strHead) && (myList.GetSize() == 1) &&
       (CString(_T("ABC")) == myList.GetHead()));

CList::GetTail

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

TYPE& GetTail();
const TYPE& GetTail() const;

Parametri

TYPE
Parametro modello che specifica il tipo di elementi nell'elenco.

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.

Esempio

// Define myList.
CList<CString, CString &> myList;

// Add an element to the end of the list.
myList.AddTail(CString(_T("ABC")));

// Verify the element was added to the end of the list.
ASSERT(CString(_T("ABC")) == myList.GetTail());

CList::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.

Esempio

// Define myList.
CList<CString,CString&> myList;

// Add an element to the end of the list.
myList.AddTail(CString(_T("ABC")));

// Verify the element at the end position
// is the one added.
POSITION pos = myList.GetTailPosition();
ASSERT(CString(_T("ABC")) == myList.GetAt(pos));      

CList::InsertAfter

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

POSITION InsertAfter(POSITION position, ARG_TYPE newElement);

Parametri

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

ARG_TYPE
Parametro modello che specifica il tipo dell'elemento elenco.

newElement
Elemento da aggiungere all'elenco.

Valore restituito

Valore POSITION che può essere utilizzato per l'iterazione o il recupero dell'elemento elenco.

Esempio

// Define myList.
CList<CString, CString &> myList;

// Add three elements to the list.
POSITION pos = myList.AddHead(CString(_T("XYZ")));
pos = myList.InsertAfter(pos, CString(_T("ABC")));
pos = myList.InsertAfter(pos, CString(_T("123")));

// Verify the tail element is what's expected.
ASSERT(CString(_T("123")) == myList.GetTail());

CList::InsertBefore

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

POSITION InsertBefore(POSITION position, ARG_TYPE newElement);

Parametri

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

ARG_TYPE
Parametro del modello che specifica il tipo di elemento dell'elenco (può essere un riferimento).

newElement
Elemento da aggiungere all'elenco.

Valore restituito

Valore POSITION che può essere utilizzato per l'iterazione o il recupero dell'elemento elenco.

Osservazioni:

Se position è NULL, l'elemento viene inserito all'inizio dell'elenco.

Esempio

// Define myList.
CList<CString, CString &> myList;

// Add three elements to the list.
POSITION pos = myList.AddHead(CString(_T("XYZ")));
pos = myList.InsertBefore(pos, CString(_T("ABC")));
pos = myList.InsertBefore(pos, CString(_T("123")));

// Verify the head element is what's expected.
ASSERT(CString(_T("123")) == myList.GetHead());

CList::IsEmpty

Indica se l'elenco non contiene elementi.

BOOL IsEmpty() const;

Valore restituito

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

Esempio

// Define myList.
CList<CString, CString &> myList;

// Add three elements to the list.
myList.AddTail(CString(_T("XYZ")));
myList.AddTail(CString(_T("ABC")));
myList.AddTail(CString(_T("123")));

// Remove the head element until the list is empty.
CString str;
while (!myList.IsEmpty())
{
   str = myList.RemoveHead();
   TRACE(_T("%s\r\n"), (LPCTSTR)str);
}

CList::RemoveAll

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

void RemoveAll();

Osservazioni:

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

Esempio

// Define myList.
CList<CString, CString&> myList;

// Add three elements to the list.
myList.AddTail(CString(_T("XYZ")));
myList.AddTail(CString(_T("ABC")));
myList.AddTail(CString(_T("123")));

// Remove all of the elements in the list.
myList.RemoveAll();

// Verify the list is empty.
ASSERT(myList.IsEmpty());

CList::RemoveAt

Rimuove l'elemento specificato da questo elenco.

void RemoveAt(POSITION position);

Parametri

position
Posizione dell'elemento da rimuovere dall'elenco.

Osservazioni:

È 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.

Esempio

// Define myList.
CList<CString, CString&> myList;

// Add three elements to the list.
myList.AddTail(CString(_T("XYZ")));
myList.AddTail(CString(_T("ABC")));
myList.AddTail(CString(_T("123")));

// Remove CString("ABC") from the list.
myList.RemoveAt(myList.FindIndex(1));

// Verify CString("ABC") is not in the list.
ASSERT(myList.Find(CString(_T("ABC"))) == NULL);

CList::RemoveHead

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

TYPE RemoveHead();

Parametri

TYPE
Parametro modello che specifica il tipo di elementi nell'elenco.

Valore restituito

Elemento 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.

Esempio

// Define myList.
CList<CString, CString&> myList;

// Add two elements to the list.
myList.AddHead(CString(_T("ABC")));
myList.AddHead(CString(_T("123")));

// Remove the head element and verify the list.
// NOTE: once the head is removed, the number of
// elements in the list will be one.
CString strHead = myList.RemoveHead();
ASSERT((CString(_T("123")) == strHead) && (myList.GetCount() == 1) &&
(CString(_T("ABC")) == myList.GetHead()));

CList::RemoveTail

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

TYPE RemoveTail();

Parametri

TYPE
Parametro modello che specifica il tipo di elementi nell'elenco.

Valore restituito

Elemento alla fine 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.

Esempio

// Define myList.
CList<CString, CString &> myList;

// Add two elements to the list.
myList.AddTail(CString(_T("ABC")));
myList.AddTail(CString(_T("123")));

// Remove the tail element and verify the list.
// NOTE: once the tail is removed, the number of
// elements in the list will be one.
CString strTail = myList.RemoveTail();
ASSERT((CString(_T("123")) == strTail) && (myList.GetCount() == 1) &&
       (CString(_T("ABC")) == myList.GetTail()));

CList::SetAt

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

void SetAt(POSITION pos, ARG_TYPE newElement);

Parametri

pos
Oggetto POSITION dell'elemento da impostare.

ARG_TYPE
Parametro del modello che specifica il tipo di elemento dell'elenco (può essere un riferimento).

newElement
Elemento da aggiungere all'elenco.

Osservazioni:

Non è uguale a un indice e non è possibile operare manualmente su un POSITION valore. SetAt scrive l'elemento 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.

Esempio

// Define myList.
CList<CString, CString &> myList;

// Add three elements to the list.
myList.AddTail(CString(_T("XYZ")));
myList.AddTail(CString(_T("ABC")));
myList.AddTail(CString(_T("123")));

// Replace CString("ABC") with CString("CBA")
POSITION pos = myList.Find(CString(_T("ABC")));
myList.SetAt(pos, CString(_T("CBA")));

// Verify CString("ABC") is not in the list.
ASSERT(myList.Find(CString(_T("ABC"))) == NULL);

Vedi anche

Esempio MFC COLLECT
CObject Classe
Grafico della gerarchia
CMap Classe
CArray Classe