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 atlas edizione Standard RT 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
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per