Classe CAtlList

Questa classe fornisce metodi per la creazione e la gestione di un oggetto elenco.

Sintassi

template<typename E, class ETraits = CElementTraits<E>>
class CAtlList

Parametri

E
Tipo dell'elemento.

ETraits
Codice utilizzato per copiare o spostare elementi. Per altri dettagli, vedere Classe CElementTraits.

Membri

Typedef pubblici

Nome	Descrizione
CAtlList::INARGTYPE

Costruttori pubblici

Nome	Descrizione
CAtlList::CAtlList	Costruttore.
CAtlList::~CAtlList	Distruttore.

Metodi pubblici

Nome	Descrizione
CAtlList::AddHead	Chiamare questo metodo per aggiungere un elemento all'inizio dell'elenco.
CAtlList::AddHeadList	Chiamare questo metodo per aggiungere un elenco esistente all'inizio dell'elenco.
CAtlList::AddTail	Chiamare questo metodo per aggiungere un elemento alla fine dell'elenco.
CAtlList::AddTailList	Chiamare questo metodo per aggiungere un elenco esistente alla fine dell'elenco.
CAtlList::AssertValid	Chiamare questo metodo per verificare che l'elenco sia valido.
CAtlList::Find	Chiamare questo metodo per cercare l'elemento specificato nell'elenco.
CAtlList::FindIndex	Chiamare questo metodo per ottenere la posizione di un elemento, dato un valore di indice.
CAtlList::GetAt	Chiamare questo metodo per restituire l'elemento in una posizione specificata nell'elenco.
CAtlList::GetCount	Chiamare questo metodo per restituire il numero di oggetti nell'elenco.
CAtlList::GetHead	Chiamare questo metodo per restituire l'elemento all'inizio dell'elenco.
CAtlList::GetHeadPosition	Chiamare questo metodo per ottenere la posizione dell'intestazione dell'elenco.
CAtlList::GetNext	Chiamare questo metodo per restituire l'elemento successivo dall'elenco.
CAtlList::GetPrev	Chiamare questo metodo per restituire l'elemento precedente dall'elenco.
CAtlList::GetTail	Chiamare questo metodo per restituire l'elemento alla fine dell'elenco.
CAtlList::GetTailPosition	Chiamare questo metodo per ottenere la posizione della parte finale dell'elenco.
CAtlList::InsertAfter	Chiamare questo metodo per inserire un nuovo elemento nell'elenco dopo la posizione specificata.
CAtlList::InsertBefore	Chiamare questo metodo per inserire un nuovo elemento nell'elenco prima della posizione specificata.
CAtlList::IsEmpty	Chiamare questo metodo per determinare se l'elenco è vuoto.
CAtlList::MoveToHead	Chiamare questo metodo per spostare l'elemento specificato all'inizio dell'elenco.
CAtlList::MoveToTail	Chiamare questo metodo per spostare l'elemento specificato nella parte finale dell'elenco.
CAtlList::RemoveAll	Chiamare questo metodo per rimuovere tutti gli elementi dall'elenco.
CAtlList::RemoveAt	Chiamare questo metodo per rimuovere un singolo elemento dall'elenco.
CAtlList::RemoveHead	Chiamare questo metodo per rimuovere l'elemento all'inizio dell'elenco.
CAtlList::RemoveHeadNoReturn	Chiamare questo metodo per rimuovere l'elemento all'inizio dell'elenco senza restituire un valore.
CAtlList::RemoveTail	Chiamare questo metodo per rimuovere l'elemento alla fine dell'elenco.
CAtlList::RemoveTailNoReturn	Chiamare questo metodo per rimuovere l'elemento alla fine dell'elenco senza restituire un valore.
CAtlList::SetAt	Chiamare questo metodo per impostare il valore dell'elemento in una determinata posizione nell'elenco.
CAtlList::SwapElements	Chiamare questo metodo per scambiare gli elementi nell'elenco.

Osservazioni:

La CAtlList classe supporta elenchi ordinati di oggetti non univoci accessibili in sequenza o in base al valore. CAtlList gli elenchi si comportano come elenchi collegati doubly. Ogni elenco ha una testa e una coda e nuovi elementi (o elenchi in alcuni casi) possono essere aggiunti alla fine dell'elenco o inseriti prima o dopo elementi specifici.

La maggior parte dei CAtlList metodi usa un valore di posizione. Questo valore viene usato dai metodi per fare riferimento alla posizione di memoria effettiva in cui sono archiviati gli elementi e non deve essere calcolato o stimato direttamente. Se è necessario accedere all'nelemento nell'elenco, il metodo CAtlList::FindIndex restituirà il valore di posizione corrispondente per un determinato indice. I metodi CAtlList::GetNext e CAtlList::GetPrev possono essere usati per scorrere gli oggetti nell'elenco.

Per altre informazioni sulle classi di raccolta disponibili con ATL, vedere Classi di raccolta ATL.

Requisiti

Intestazione: atlcoll.h

CAtlList::AddHead

Chiamare questo metodo per aggiungere un elemento all'inizio dell'elenco.

POSITION AddHead();
POSITION AddHead(INARGTYPE element);

Parametri

Elemento
Nuovo elemento.

Valore restituito

Restituisce la posizione dell'elemento appena aggiunto.

Osservazioni:

Se viene usata la prima versione, viene creato un elemento vuoto usando il relativo costruttore predefinito, anziché il relativo costruttore di copia.

Esempio

// Declare a list of integers
CAtlList<int> myList;

// Add some elements, each to the head of the list.
// As each new element is added, the previous head is
// pushed down the list.
myList.AddHead(42);
myList.AddHead(49);

// Confirm the value currently at the head of the list
ATLASSERT(myList.GetHead() == 49);

// Confirm the value currently at the tail of the list
ATLASSERT(myList.GetTail() == 42);   

CAtlList::AddHeadList

Chiamare questo metodo per aggiungere un elenco esistente all'inizio dell'elenco.

void AddHeadList(const CAtlList<E, ETraits>* plNew);

Parametri

plNew
Elenco da aggiungere.

Osservazioni:

L'elenco a cui punta plNew viene inserito all'inizio dell'elenco esistente. Nelle compilazioni di debug si verificherà un errore di asserzione se plNew è uguale a NULL.

Esempio

// Define two lists of integers
CAtlList<int> myList1;
CAtlList<int> myList2;

// Fill up the first list
myList1.AddTail(1);
myList1.AddTail(2);
myList1.AddTail(3);

// Add an element to the second list
myList2.AddTail(4);

// Insert the first list into the second
myList2.AddHeadList(&myList1);

// The second list now contains:
// 1, 2, 3, 4   

CAtlList::AddTail

Chiamare questo metodo per aggiungere un elemento alla fine dell'elenco.

POSITION AddTail();
POSITION AddTail(INARGTYPE element);

Parametri

Elemento
Elemento da aggiungere.

Valore restituito

Restituisce la posizione dell'elemento appena aggiunto.

Osservazioni:

Se viene usata la prima versione, viene creato un elemento vuoto usando il relativo costruttore predefinito, anziché il relativo costruttore di copia. L'elemento viene aggiunto alla fine dell'elenco e quindi diventa la parte finale. Questo metodo può essere usato con un elenco vuoto.

Esempio

// Define the list
CAtlList<int> myList;

// Add elements to the tail
myList.AddTail(1);
myList.AddTail(2);
myList.AddTail(3);

// Confirm the current head of the list
ATLASSERT(myList.GetHead() == 1);

// Confirm the current tail of the list
ATLASSERT(myList.GetTail() == 3);   

CAtlList::AddTailList

Chiamare questo metodo per aggiungere un elenco esistente alla fine dell'elenco.

void AddTailList(const CAtlList<E, ETraits>* plNew);

Parametri

plNew
Elenco da aggiungere.

Osservazioni:

L'elenco a cui punta plNew viene inserito dopo l'ultimo elemento (se presente) nell'oggetto elenco. L'ultimo elemento nell'elenco plNew diventa quindi la coda. Nelle compilazioni di debug si verificherà un errore di asserzione se plNew è uguale a NULL.

Esempio

// Define two integer lists
CAtlList<int> myList1;
CAtlList<int> myList2;

// Fill up the first list
myList1.AddTail(1);
myList1.AddTail(2);
myList1.AddTail(3);

// Add an element to the second list
myList2.AddTail(4);

// Insert the first list into the second
myList2.AddTailList(&myList1);

// The second list now contains:
// 4, 1, 2, 3   

CAtlList::AssertValid

Chiamare questo metodo per verificare che l'elenco sia valido.

void AssertValid() const;

Osservazioni:

Nelle compilazioni di debug si verificherà un errore di asserzione se l'oggetto elenco non è valido. Per essere valido, un elenco vuoto deve avere sia la testa che la coda che puntano a NULL e un elenco che non è vuoto deve avere sia la testa che la coda che puntano agli indirizzi validi.

Esempio

// Define the list
CAtlList<int> myList;

// AssertValid only exists in debug builds
#ifdef _DEBUG
myList.AssertValid();
#endif   

CAtlList::CAtlList

Costruttore.

CAtlList(UINT nBlockSize = 10) throw();

Parametri

nBlockSize
Dimensione del blocco.

Osservazioni:

Costruttore per l'oggetto CAtlList . La dimensione del blocco è una misura della quantità di memoria allocata quando è necessario un nuovo elemento. Le dimensioni dei blocchi maggiori riducono le chiamate alle routine di allocazione della memoria, ma usano più risorse.

Esempio

// Define two lists
CAtlList<int> myList1;
CAtlList<double> myList2;   

CAtlList::~CAtlList

Distruttore.

~CAtlList() throw();

Osservazioni:

Libera tutte le risorse allocate, inclusa una chiamata a CAtlList::RemoveAll per rimuovere tutti gli elementi dall'elenco.

Nelle compilazioni di debug si verificherà un errore di asserzione se l'elenco contiene ancora alcuni elementi dopo la chiamata a RemoveAll.

CAtlList::Find

Chiamare questo metodo per cercare l'elemento specificato nell'elenco.

POSITION Find(INARGTYPE element, POSITION posStartAfter = NULL) const throw();

Parametri

Elemento
Elemento da trovare nell'elenco.

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

Valore restituito

Restituisce il valore POSITION dell'elemento, se trovato, in caso contrario restituisce NULL.

Osservazioni:

Nelle compilazioni di debug si verificherà un errore di asserzione se l'oggetto elenco non è valido o se il valore posStartAfter non è compreso nell'intervallo.

Esempio

// Define the integer list
CAtlList<int> myList;

// Populate the list
myList.AddTail(100);
myList.AddTail(200);
myList.AddTail(300);
myList.AddTail(400);

// Find the '300' element in the list,
// starting from the list head.
POSITION myPos = myList.Find(300);

// Confirm that the element was found
ATLASSERT(myList.GetAt(myPos) == 300);   

CAtlList::FindIndex

Chiamare questo metodo per ottenere la posizione di un elemento, dato un valore di indice.

POSITION FindIndex(size_t iElement) const throw();

Parametri

iElement
Indice in base zero dell'elemento elenco richiesto.

Valore restituito

Restituisce il valore POSITION corrispondente o NULL se iElement non è compreso nell'intervallo.

Osservazioni:

Questo metodo restituisce position corrispondente a un determinato valore di indice, consentendo l'accesso all'n elemento nell'elenco.

Nelle compilazioni di debug si verificherà un errore di asserzione se l'oggetto elenco non è valido.

Esempio

// Define the integer list
CAtlList<int> myList;

// Populate the list
for (int i = 0; i < 100; i++)
{
   myList.AddTail(i);
}

// Iterate through the entire list
for (size_t j = 0; j < myList.GetCount(); j++)
{
   size_t i = myList.GetAt(myList.FindIndex(j));
   ATLASSERT(i == j);
}   

CAtlList::GetAt

Chiamare questo metodo per restituire l'elemento in una posizione specificata nell'elenco.

E& GetAt(POSITION pos) throw();
const E& GetAt(POSITION pos) const throw();

Parametri

pos
Valore POSITION che specifica un particolare elemento.

Valore restituito

Riferimento a o copia dell'elemento .

Osservazioni:

Se l'elenco è const, GetAt restituisce una copia dell'elemento . In questo modo il metodo può essere usato solo sul lato destro di un'istruzione di assegnazione e protegge l'elenco dalle modifiche.

Se l'elenco non constè , GetAt restituisce un riferimento all'elemento . In questo modo il metodo può essere utilizzato su entrambi i lati di un'istruzione di assegnazione e di conseguenza consente di modificare le voci di elenco.

Nelle compilazioni di debug si verificherà un errore di asserzione se pos è uguale a NULL.

Esempio

Vedere l'esempio per CAtlList::FindIndex.

CAtlList::GetCount

Chiamare questo metodo per restituire il numero di oggetti nell'elenco.

size_t GetCount() const throw();

Valore restituito

Restituisce il numero di elementi nell'elenco.

Esempio

Vedere l'esempio per CAtlList::Find.

CAtlList::GetHead

Chiamare questo metodo per restituire l'elemento all'inizio dell'elenco.

E& GetHead() throw();
const E& GetHead() const throw();

Valore restituito

Restituisce un riferimento a o una copia dell'elemento all'inizio dell'elenco.

Osservazioni:

Se l'elenco è const, GetHead restituisce una copia dell'elemento all'inizio dell'elenco. In questo modo il metodo può essere usato solo sul lato destro di un'istruzione di assegnazione e protegge l'elenco dalle modifiche.

Se l'elenco non constè , GetHead restituisce un riferimento all'elemento all'inizio dell'elenco. In questo modo il metodo può essere utilizzato su entrambi i lati di un'istruzione di assegnazione e di conseguenza consente di modificare le voci di elenco.

Nelle compilazioni di debug si verificherà un errore di asserzione se l'intestazione dell'elenco punta a NULL.

Esempio

Vedere l'esempio per CAtlList::AddHead.

CAtlList::GetHeadPosition

Chiamare questo metodo per ottenere la posizione dell'intestazione dell'elenco.

POSITION GetHeadPosition() const throw();

Valore restituito

Restituisce il valore POSITION corrispondente all'elemento all'inizio dell'elenco.

Osservazioni:

Se l'elenco è vuoto, il valore restituito è NULL.

Esempio

// Define the integer list
CAtlList<int> myList;
int i;

// Populate the list
for (i = 0; i < 100; i++)
{
   myList.AddTail(i);
}

// Get the starting position value
POSITION myPos = myList.GetHeadPosition();

// Iterate through the entire list
i = 0;
int j;

do {
   j = myList.GetNext(myPos);
   ATLASSERT(i == j);
   i++;
} while (myPos != NULL);   

CAtlList::GetNext

Chiamare questo metodo per restituire l'elemento successivo dall'elenco.

E& GetNext(POSITION& pos) throw();
const E& GetNext(POSITION& pos) const throw();

Parametri

pos
Valore POSITION, restituito da una chiamata precedente a GetNext, CAtlList::GetHeadPosition o altro CAtlList metodo.

Valore restituito

Se l'elenco è const, GetNext restituisce una copia dell'elemento successivo dell'elenco. In questo modo il metodo può essere usato solo sul lato destro di un'istruzione di assegnazione e protegge l'elenco dalle modifiche.

Se l'elenco non constè , GetNext restituisce un riferimento all'elemento successivo dell'elenco. In questo modo il metodo può essere utilizzato su entrambi i lati di un'istruzione di assegnazione e di conseguenza consente di modificare le voci di elenco.

Osservazioni:

Il contatore POSITION, pos, viene aggiornato in modo che punti all'elemento successivo nell'elenco o NULL se non sono presenti altri elementi. Nelle compilazioni di debug si verificherà un errore di asserzione se pos è uguale a NULL.

Esempio

Vedere l'esempio per CAtlList::GetHeadPosition.

CAtlList::GetPrev

Chiamare questo metodo per restituire l'elemento precedente dall'elenco.

E& GetPrev(POSITION& pos) throw();
const E& GetPrev(POSITION& pos) const throw();

Parametri

pos
Valore POSITION, restituito da una chiamata precedente a GetPrev, CAtlList::GetTailPosition o un altro CAtlList metodo.

Valore restituito

Se l'elenco è const, GetPrev restituisce una copia di un elemento dell'elenco. In questo modo il metodo può essere usato solo sul lato destro di un'istruzione di assegnazione e protegge l'elenco dalle modifiche.

Se l'elenco non constè , GetPrev restituisce un riferimento a un elemento dell'elenco. In questo modo il metodo può essere utilizzato su entrambi i lati di un'istruzione di assegnazione e di conseguenza consente di modificare le voci di elenco.

Osservazioni:

Il contatore POSITION, pos, viene aggiornato in modo da puntare all'elemento precedente nell'elenco oppure NULL se non sono presenti altri elementi. Nelle compilazioni di debug si verificherà un errore di asserzione se pos è uguale a NULL.

Esempio

Vedere l'esempio per CAtlList::GetTailPosition.

CAtlList::GetTail

Chiamare questo metodo per restituire l'elemento alla fine dell'elenco.

E& GetTail() throw();
const E& GetTail() const throw();

Valore restituito

Restituisce un riferimento a o una copia dell'elemento nella parte finale dell'elenco.

Osservazioni:

Se l'elenco è const, GetTail restituisce una copia dell'elemento all'inizio dell'elenco. In questo modo il metodo può essere usato solo sul lato destro di un'istruzione di assegnazione e protegge l'elenco dalle modifiche.

Se l'elenco non constè , GetTail restituisce un riferimento all'elemento all'inizio dell'elenco. In questo modo il metodo può essere utilizzato su entrambi i lati di un'istruzione di assegnazione e di conseguenza consente di modificare le voci di elenco.

Nelle compilazioni di debug si verificherà un errore di asserzione se la parte finale dell'elenco punta a NULL.

Esempio

Vedere l'esempio per CAtlList::AddTail.

CAtlList::GetTailPosition

Chiamare questo metodo per ottenere la posizione della parte finale dell'elenco.

POSITION GetTailPosition() const throw();

Valore restituito

Restituisce il valore POSITION corrispondente all'elemento alla fine dell'elenco.

Osservazioni:

Se l'elenco è vuoto, il valore restituito è NULL.

Esempio

// Define the integer list
CAtlList<int> myList;
int i;

// Populate the list
for (i = 0; i < 100; i++)
{
   myList.AddHead(i);
}

// Get the starting position value
POSITION myP = myList.GetTailPosition();

// Iterate through the entire list
i = 0;
int j;

do {
   j = myList.GetPrev(myP);
   ATLASSERT(i == j);
   i++;
} while (myP != NULL);   

CAtlList::INARGTYPE

Tipo utilizzato quando un elemento viene passato come argomento di input.

typedef ETraits::INARGTYPE INARGTYPE;

CAtlList::InsertAfter

Chiamare questo metodo per inserire un nuovo elemento nell'elenco dopo la posizione specificata.

POSITION InsertAfter(POSITION pos, INARGTYPE element);

Parametri

pos
Valore POSITION dopo il quale verrà inserito il nuovo elemento.

Elemento
Elemento da inserire.

Valore restituito

Restituisce il valore POSITION del nuovo elemento.

Osservazioni:

Nelle compilazioni di debug si verificherà un errore di asserzione se l'elenco non è valido, se l'inserimento non riesce o se viene effettuato un tentativo di inserimento dell'elemento dopo la coda.

Esempio

// Define the integer list
CAtlList<int> myList;

// Populate the list
POSITION myPos = myList.AddHead(1);
myPos = myList.InsertAfter(myPos, 2);
myPos = myList.InsertAfter(myPos, 3);

// Confirm the tail value is as expected
ATLASSERT(myList.GetTail() == 3);   

CAtlList::InsertBefore

Chiamare questo metodo per inserire un nuovo elemento nell'elenco prima della posizione specificata.

POSITION InsertBefore(POSITION pos, INARGTYPE element);

Parametri

pos
Il nuovo elemento verrà inserito nell'elenco prima di questo valore POSITION.

Elemento
Elemento da inserire.

Valore restituito

Restituisce il valore POSITION del nuovo elemento.

Osservazioni:

Nelle compilazioni di debug si verificherà un errore di asserzione se l'elenco non è valido, se l'inserimento ha esito negativo o se viene effettuato un tentativo di inserimento dell'elemento prima dell'intestazione.

Esempio

// Define the integer list
CAtlList<int> myList;

// Populate the list
POSITION myPos = myList.AddHead(1);
myPos = myList.InsertBefore(myPos, 2);
myPos = myList.InsertBefore(myPos, 3);

// Confirm the head value is as expected
ATLASSERT(myList.GetHead() == 3);  

CAtlList::IsEmpty

Chiamare questo metodo per determinare se l'elenco è vuoto.

bool IsEmpty() const throw();

Valore restituito

Restituisce true se l'elenco non contiene oggetti; in caso contrario, false.

Esempio

// Define the integer list
CAtlList<int> myList;

// Populate the list
myList.AddTail(1);
myList.AddTail(2);
myList.AddTail(3);
myList.AddTail(4);

// Confirm not empty
ATLASSERT(myList.IsEmpty() == false);

// Remove the tail element
myList.RemoveTailNoReturn();

// Confirm not empty
ATLASSERT(myList.IsEmpty() == false);

// Remove the head element
myList.RemoveHeadNoReturn();

// Confirm not empty
ATLASSERT(myList.IsEmpty() == false);

// Remove all remaining elements
myList.RemoveAll();

// Confirm empty
ATLASSERT(myList.IsEmpty() == true);   

CAtlList::MoveToHead

Chiamare questo metodo per spostare l'elemento specificato all'inizio dell'elenco.

void MoveToHead(POSITION pos) throw();

Parametri

pos
Valore POSITION dell'elemento da spostare.

Osservazioni:

L'elemento specificato viene spostato dalla posizione corrente all'inizio dell'elenco. Nelle compilazioni di debug si verificherà un errore di asserzione se pos è uguale a NULL.

Esempio

// Define the integer list
CAtlList<int> myList;

// Populate the list
myList.AddTail(1);
myList.AddTail(2);
myList.AddTail(3);
myList.AddTail(4);

// Move the tail element to the head
myList.MoveToHead(myList.GetTailPosition());

// Confirm the head is as expected
ATLASSERT(myList.GetHead() == 4);

// Move the head element to the tail
myList.MoveToTail(myList.GetHeadPosition());

// Confirm the tail is as expected
ATLASSERT(myList.GetTail() == 4);   

CAtlList::MoveToTail

Chiamare questo metodo per spostare l'elemento specificato nella parte finale dell'elenco.

void MoveToTail(POSITION pos) throw();

Parametri

pos
Valore POSITION dell'elemento da spostare.

Osservazioni:

L'elemento specificato viene spostato dalla posizione corrente alla parte finale dell'elenco. Nelle compilazioni di debug si verificherà un errore di asserzione se pos è uguale a NULL.

Esempio

Vedere l'esempio per CAtlList::MoveToHead.

CAtlList::RemoveAll

Chiamare questo metodo per rimuovere tutti gli elementi dall'elenco.

void RemoveAll() throw();

Osservazioni:

Questo metodo rimuove tutti gli elementi dall'elenco e libera la memoria allocata. Nelle compilazioni di debug verrà generato un ATLASSERT se tutti gli elementi non vengono eliminati o se la struttura dell'elenco è danneggiata.

Esempio

Vedere l'esempio per CAtlList::IsEmpty.

CAtlList::RemoveAt

Chiamare questo metodo per rimuovere un singolo elemento dall'elenco.

void RemoveAt(POSITION pos) throw();

Parametri

pos
Valore POSITION dell'elemento da rimuovere.

Osservazioni:

L'elemento a cui fa riferimento pos viene rimosso e la memoria viene liberata. È accettabile usare RemoveAt per rimuovere la testa o la parte finale dell'elenco.

Nelle compilazioni di debug si verificherà un errore di asserzione se l'elenco non è valido o se la rimozione dell'elemento fa sì che l'elenco accinga alla memoria che non fa parte della struttura dell'elenco.

Esempio

// Define the integer list
CAtlList<int> myList;

// Populate the list
myList.AddTail(100);
myList.AddTail(200);
myList.AddTail(300);

// Use RemoveAt to remove elements one by one
myList.RemoveAt(myList.Find(100));
myList.RemoveAt(myList.Find(200));
myList.RemoveAt(myList.Find(300));

// Confirm all have been deleted
ATLASSERT(myList.IsEmpty() == true);   

CAtlList::RemoveHead

Chiamare questo metodo per rimuovere l'elemento all'inizio dell'elenco.

E RemoveHead();

Valore restituito

Restituisce l'elemento all'inizio dell'elenco.

Osservazioni:

L'elemento head viene eliminato dall'elenco e la memoria viene liberata. Viene restituita una copia dell'elemento. Nelle compilazioni di debug si verificherà un errore di asserzione se l'elenco è vuoto.

Esempio

// Define the integer list
CAtlList<int> myList;

// Populate the list
myList.AddTail(100);
myList.AddTail(200);
myList.AddTail(300);

// Confirm the head of the list
ATLASSERT(myList.GetHead() == 100);

// Remove the head of the list
ATLASSERT(myList.RemoveHead() == 100);

// Confirm the new head of the list
ATLASSERT(myList.GetHead() == 200);   

CAtlList::RemoveHeadNoReturn

Chiamare questo metodo per rimuovere l'elemento all'inizio dell'elenco senza restituire un valore.

void RemoveHeadNoReturn() throw();

Osservazioni:

L'elemento head viene eliminato dall'elenco e la memoria viene liberata. Nelle compilazioni di debug si verificherà un errore di asserzione se l'elenco è vuoto.

Esempio

Vedere l'esempio per CAtlList::IsEmpty.

CAtlList::RemoveTail

Chiamare questo metodo per rimuovere l'elemento alla fine dell'elenco.

E RemoveTail();

Valore restituito

Restituisce l'elemento alla fine dell'elenco.

Osservazioni:

L'elemento della parte finale viene eliminato dall'elenco e la memoria viene liberata. Viene restituita una copia dell'elemento. Nelle compilazioni di debug si verificherà un errore di asserzione se l'elenco è vuoto.

Esempio

// Define the integer list
CAtlList<int> myList;

// Populate the list
myList.AddTail(100);
myList.AddTail(200);
myList.AddTail(300);

// Confirm the tail of the list
ATLASSERT(myList.GetTail() == 300);

// Remove the tail of the list
ATLASSERT(myList.RemoveTail() == 300);

// Confirm the new tail of the list
ATLASSERT(myList.GetTail() == 200);   

CAtlList::RemoveTailNoReturn

Chiamare questo metodo per rimuovere l'elemento alla fine dell'elenco senza restituire un valore.

void RemoveTailNoReturn() throw();

Osservazioni:

L'elemento della parte finale viene eliminato dall'elenco e la memoria viene liberata. Nelle compilazioni di debug si verificherà un errore di asserzione se l'elenco è vuoto.

Esempio

Vedere l'esempio per CAtlList::IsEmpty.

CAtlList::SetAt

Chiamare questo metodo per impostare il valore dell'elemento in una determinata posizione nell'elenco.

void SetAt(POSITION pos, INARGTYPE element);

Parametri

pos
Valore POSITION corrispondente all'elemento da modificare.

Elemento
Nuovo valore dell'elemento.

Osservazioni:

Sostituisce il valore esistente con l'elemento . Nelle compilazioni di debug si verificherà un errore di asserzione se pos è uguale a NULL.

Esempio

// Define the integer list
CAtlList<int> myList;

// Populate the list
myList.AddTail(100);
myList.AddTail(200);

// Use SetAt to change the values stored in the head and
// tail of the list
myList.SetAt(myList.GetHeadPosition(), myList.GetHead() * 10);
myList.SetAt(myList.GetTailPosition(), myList.GetTail() * 10);

// Confirm the values
ATLASSERT(myList.GetHead() == 1000);
ATLASSERT(myList.GetTail() == 2000);   

CAtlList::SwapElements

Chiamare questo metodo per scambiare gli elementi nell'elenco.

void SwapElements(POSITION pos1, POSITION pos2) throw();

Parametri

pos1
Primo valore POSITION.

pos2
Secondo valore POSITION.

Osservazioni:

Scambia gli elementi in corrispondenza delle due posizioni specificate. Nelle compilazioni di debug si verificherà un errore di asserzione se uno dei due valori di posizione è uguale a NULL.

Esempio

// Define the integer list
CAtlList<int> myList;

// Populate the list
for (int i = 0; i < 100; i++)
{
   myList.AddHead(i);
}

// Order is: 99, 98, 97, 96...
ATLASSERT(myList.GetHead() == 99);
ATLASSERT(myList.GetTail() == 0);

// Perform a crude bubble sort
for (int j = 0; j < 100; j++)
{
   for(int i = 0; i < 99; i++)
   {
      if (myList.GetAt(myList.FindIndex(i)) > 
         myList.GetAt(myList.FindIndex(i+1)))
      {
         myList.SwapElements(myList.FindIndex(i), myList.FindIndex(i+1));
      }
   }
}

// Order is: 0, 1, 2, 3...
ATLASSERT(myList.GetHead() == 0);
ATLASSERT(myList.GetTail() == 99);   

Vedi anche

Classe CList
Cenni preliminari sulla classe