La classe `CObList`

Article
10/12/2023

Prend en charge les listes ordonnées de pointeurs non uniques CObject accessibles séquentiellement ou par valeur de pointeur.

Syntaxe

class CObList : public CObject

Membres

Constructeurs publics

Nom	Description
`CObList::CObList`	Construit une liste vide pour `CObject` les pointeurs.

Méthodes publiques

Nom	Description
`CObList::AddHead`	Ajoute un élément (ou tous les éléments d’une autre liste) à la tête de la liste (fait un nouveau chef).
`CObList::AddTail`	Ajoute un élément (ou tous les éléments d’une autre liste) à la fin de la liste (fait une nouvelle queue).
`CObList::Find`	Obtient la position d’un élément spécifié par la valeur du pointeur.
`CObList::FindIndex`	Obtient la position d’un élément spécifié par un index de base zéro.
`CObList::GetAt`	Obtient l’élément à une position donnée.
`CObList::GetCount`	Retourne le nombre d’éléments de cette liste.
`CObList::GetHead`	Renvoie l’élément principal de la liste (ne peut pas être vide).
`CObList::GetHeadPosition`	Retourne la position de l’élément principal de la liste.
`CObList::GetNext`	Obtient l’élément suivant pour itérer.
`CObList::GetPrev`	Obtient l’élément précédent pour l’itération.
`CObList::GetSize`	Retourne le nombre d’éléments de cette liste.
`CObList::GetTail`	Retourne l’élément tail de la liste (ne peut pas être vide).
`CObList::GetTailPosition`	Retourne la position de l’élément de fin de la liste.
`CObList::InsertAfter`	Insère un nouvel élément après une position donnée.
`CObList::InsertBefore`	Insère un nouvel élément avant une position donnée.
`CObList::IsEmpty`	Teste la condition de liste vide (aucun élément).
`CObList::RemoveAll`	Supprime tous les éléments de cette liste.
`CObList::RemoveAt`	Supprime un élément de cette liste, spécifié par position.
`CObList::RemoveHead`	Supprime l’élément de la tête de la liste.
`CObList::RemoveTail`	Supprime l’élément de la fin de la liste.
`CObList::SetAt`	Définit l’élément à une position donnée.

Notes

CObList les listes se comportent comme des listes doublement liées.

Une variable de type POSITION est une clé pour la liste. Vous pouvez utiliser une POSITION variable à la fois comme itérateur pour parcourir une liste de manière séquentielle et comme signet pour contenir un emplacement. Toutefois, une position n’est pas la même qu’un index.

L’insertion d’élément est très rapide à la tête de la liste, à la queue et à un connu POSITION. Une recherche séquentielle est nécessaire pour rechercher un élément par valeur ou index. Cette recherche peut être lente si la liste est longue.

CObList incorpore la macro IMPLEMENT_SERIAL pour prendre en charge la sérialisation et le vidage de ses éléments. Si une liste de CObject pointeurs est stockée dans une archive, avec un opérateur d’insertion surchargé ou avec la Serialize fonction membre, chaque CObject élément est sérialisé à son tour.

Si vous avez besoin d’un vidage d’éléments individuels CObject dans la liste, vous devez définir la profondeur du contexte de vidage sur 1 ou supérieur.

Lorsqu’un CObList objet est supprimé ou lorsque ses éléments sont supprimés, seuls les CObject pointeurs sont supprimés, et non les objets qu’ils référencent.

Vous pouvez dériver vos propres classes de CObList. Votre nouvelle classe de liste, conçue pour contenir des pointeurs vers des objets dérivés, ajoute de CObjectnouveaux membres de données et de nouvelles fonctions membres. Notez que la liste résultante n’est pas strictement sécurisée, car elle autorise l’insertion d’un CObject pointeur.

Remarque

Vous devez utiliser la IMPLEMENT_SERIAL macro dans l’implémentation de votre classe dérivée si vous envisagez de sérialiser la liste.

Pour plus d’informations sur l’utilisation CObList, consultez l’article Collections.

Hiérarchie d'héritage

CObject

CObList

Spécifications

En-têteafxcoll.h:

`CObList::AddHead`

Ajoute un nouvel élément ou une liste d’éléments à la tête de cette liste.

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

Paramètres

newElement
Pointeur CObject à ajouter à cette liste.

pNewList
Pointeur vers une autre CObList liste. Les éléments inclus pNewList seront ajoutés à cette liste.

Valeur de retour

La première version retourne la POSITION valeur de l’élément nouvellement inséré.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::AddHead.

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

Notes

La liste peut être vide avant l’opération.

Exemple

Consultez CObList::CObList la liste de la 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

Les résultats de ce programme sont les suivants :

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

`CObList::AddTail`

Ajoute un nouvel élément ou une liste d’éléments à la fin de cette liste.

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

Paramètres

newElement
Pointeur CObject à ajouter à cette liste.

pNewList
Pointeur vers une autre CObList liste. Les éléments inclus pNewList seront ajoutés à cette liste.

Valeur de retour

La première version retourne la POSITION valeur de l’élément nouvellement inséré.

Notes

La liste peut être vide avant l’opération.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::AddTail.

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

Exemple

Consultez CObList::CObList la liste de la 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

Les résultats de ce programme sont les suivants :

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

`CObList::CObList`

Construit une liste de pointeurs vide CObject .

CObList(INT_PTR nBlockSize = 10);

Paramètres

nBlockSize
Granularité d’allocation de mémoire pour étendre la liste.

Notes

À mesure que la liste augmente, la mémoire est allouée en unités d’entrées nBlockSize . Si une allocation de mémoire échoue, une CMemoryException valeur est levée.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::CObList.

Classe	Fonction membre
`CPtrList`	`CPtrList( INT_PTR nBlockSize = 10 );`
`CStringList`	`CStringList( INT_PTR nBlockSize = 10 );`

Exemple

Vous trouverez ci-dessous une liste de la CObjectclasse CAge dérivée utilisée dans tous les exemples de collection :

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

Voici un exemple d’utilisation du CObList constructeur :

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

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

`CObList::Find`

Recherche séquentiellement la liste pour rechercher le premier CObject pointeur correspondant au pointeur spécifié CObject .

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

Paramètres

searchValue
Pointeur d’objet à trouver dans cette liste.

startAfter
Position de début de la recherche.

Valeur de retour

Valeur POSITION qui peut être utilisée pour l’itération ou la récupération du pointeur d’objet ; NULL si l’objet est introuvable.

Notes

Notez que les valeurs de pointeur sont comparées, et non le contenu des objets.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::Find.

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

Exemple

Consultez CObList::CObList la liste de la 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`

Utilise la valeur d’un nIndex index dans la liste.

POSITION FindIndex(INT_PTR nIndex) const;

Paramètres

nIndex
Index de base zéro de l’élément de liste à trouver.

Valeur de retour

Valeur POSITION qui peut être utilisée pour l’itération ou la récupération du pointeur d’objet ; NULL si nIndex elle est trop volumineuse. (L’infrastructure génère une assertion si nIndex elle est négative.)

Notes

Il démarre une analyse séquentielle à partir de la tête de la liste, en s’arrêtant sur le nièmeélément.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::FindIndex.

Classe	Fonction membre
`CPtrList`	`POSITION FindIndex( INT_PTR nIndex ) const;`
`CStringList`	`POSITION FindIndex( INT_PTR nIndex ) const;`

Exemple

Consultez CObList::CObList la liste de la 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`

Une variable de type POSITION est une clé pour la liste.

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

Paramètres

position
Valeur POSITION retournée par un appel de fonction membre ou Find précédentGetHeadPosition.

Valeur de retour

Consultez la description de la valeur de retour pour GetHead.

Notes

Ce n’est pas le même qu’un index, et vous ne pouvez pas fonctionner sur une POSITION valeur vous-même. GetAt récupère le CObject pointeur associé à une position donnée.

Vous devez vous assurer que votre POSITION valeur représente une position valide dans la liste. S’il n’est pas valide, la version de débogage de la bibliothèque de classes Microsoft Foundation affirme.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::GetAt.

Classe	Fonction membre
`CPtrList`	`const void& GetAt( POSITION position ) const;` `void& GetAt( POSITION position );`
`CStringList`	`const CString& GetAt( POSITION position ) const;` `CString& GetAt( POSITION position );`

Exemple

Consultez l’exemple pour FindIndex.

`CObList::GetCount`

Obtient le nombre d’éléments de cette liste.

INT_PTR GetCount() const;

Valeur de retour

Valeur entière contenant le nombre d’éléments.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::GetCount.

Classe	Fonction membre
`CPtrList`	`INT_PTR GetCount( ) const;`
`CStringList`	`INT_PTR GetCount( ) const;`

Exemple

Consultez CObList::CObList la liste de la 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`

Obtient le CObject pointeur qui représente l’élément principal de cette liste.

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

Valeur de retour

Si la liste est accessible via un pointeur vers un const CObList, retourne GetHead un CObject pointeur. Cela permet à la fonction d’être utilisée uniquement sur le côté droit d’une instruction d’affectation et protège ainsi la liste contre la modification.

Si la liste est accessible directement ou par le biais d’un pointeur vers un CObList, GetHead retourne une référence à un CObject pointeur. Cela permet à la fonction d’être utilisée sur l’un ou l’autre côté d’une instruction d’affectation et permet ainsi aux entrées de liste d’être modifiées.

Notes

Vous devez vous assurer que la liste n’est pas vide avant d’appeler GetHead. Si la liste est vide, la version de débogage de la bibliothèque de classes Microsoft Foundation affirme. Permet IsEmpty de vérifier que la liste contient des éléments.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::GetHead.

Classe	Fonction membre
`CPtrList`	`const void& GetHead( ) const; void& GetHead( );`
`CStringList`	`const CString& GetHead( ) const; CString& GetHead( );`

Exemple

Consultez CObList::CObList la liste de la CAge classe.

L’exemple suivant illustre l’utilisation du GetHead côté gauche d’une instruction d’affectation.

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`

Obtient la position de l’élément principal de cette liste.

POSITION GetHeadPosition() const;

Valeur de retour

Valeur POSITION qui peut être utilisée pour l’itération ou la récupération du pointeur d’objet ; NULL si la liste est vide.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::GetHeadPosition.

Classe	Fonction membre
`CPtrList`	`POSITION GetHeadPosition( ) const;`
`CStringList`	`POSITION GetHeadPosition( ) const;`

Exemple

Consultez CObList::CObList la liste de la 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`

Obtient l’élément de liste identifié par rPosition, puis définit rPosition la POSITION valeur de l’entrée suivante dans la liste.

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

Paramètres

rPosition
Référence à une POSITION valeur retournée par un appel de fonction membre précédent GetNext, GetHeadPositionou autre.

Valeur de retour

Consultez la description de la valeur de retour pour GetHead.

Notes

Vous pouvez utiliser GetNext dans une boucle d’itération avant si vous établissez la position initiale avec un appel à GetHeadPosition ou Find.

Si l’élément récupéré est le dernier de la liste, la nouvelle valeur rPosition est définie NULLsur .

Il est possible de supprimer un élément pendant une itération. Consultez l’exemple pour RemoveAt.

Remarque

Depuis MFC 8.0, la version const de cette méthode a changé pour retourner const CObject* au lieu de const CObject*&. Cette modification a été apportée pour rendre le compilateur conforme à la norme C++.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::GetNext.

Classe	Fonction membre
`CPtrList`	`void& GetNext( POSITION&` `rPosition` `);` `const void GetNext( POSITION&` `rPosition` `) const;`
`CStringList`	`CString& GetNext( POSITION&` `rPosition` `);` `const CString& GetNext( POSITION&` `rPosition` `) const;`

Exemple

Consultez CObList::CObList la liste de la 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

Les résultats de ce programme sont les suivants :

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

`CObList::GetPrev`

Obtient l’élément de liste identifié par rPosition, puis définit rPosition la POSITION valeur de l’entrée précédente dans la liste.

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

Paramètres

rPosition
Référence à une POSITION valeur retournée par un appel de fonction membre précédent GetPrev ou autre.

Valeur de retour

Consultez la description de la valeur de retour pour GetHead.

Notes

Vous pouvez utiliser GetPrev dans une boucle d’itération inverse si vous établissez la position initiale avec un appel à GetTailPosition ou Find.

Si l’élément récupéré est le premier de la liste, la nouvelle valeur rPosition est définie NULLsur .

Remarque

Le tableau suivant présente d’autres fonctions membres similaires à CObList::GetPrev.

Classe	Fonction membre
`CPtrList`	`void& GetPrev( POSITION&` `rPosition` `);` `const void GetPrev( POSITION&` `rPosition` `) const;`
`CStringList`	`CString& GetPrev( POSITION&` `rPosition` `);` `const CString& GetPrev( POSITION&` `rPosition` `) const;`

Exemple

Consultez CObList::CObList la liste de la 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
}

Les résultats de ce programme sont les suivants :

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

`CObList::GetSize`

Retourne le nombre d’éléments de liste.

INT_PTR GetSize() const;

Valeur de retour

Nombre d'éléments dans la liste.

Notes

Appelez cette méthode pour récupérer le nombre d’éléments de la liste.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::GetSize.

Classe	Fonction membre
`CPtrList`	`INT_PTR GetSize( ) const;`
`CStringList`	`INT_PTR GetSize( ) const;`

Exemple

Consultez CObList::CObList la liste de la 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`

Obtient le CObject pointeur qui représente l’élément de fin de cette liste.

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

Valeur de retour

Consultez la description de la valeur de retour pour GetHead.

Notes

Vous devez vous assurer que la liste n’est pas vide avant d’appeler GetTail. Si la liste est vide, la version de débogage de la bibliothèque de classes Microsoft Foundation affirme. Permet IsEmpty de vérifier que la liste contient des éléments.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::GetTail.

Classe	Fonction membre
`CPtrList`	`const void& GetTail( ) const; void& GetTail( );`
`CStringList`	`const CString& GetTail( ) const; CString& GetTail( );`

Exemple

Consultez CObList::CObList la liste de la 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`

Obtient la position de l’élément tail de cette liste ; NULL si la liste est vide.

POSITION GetTailPosition() const;

Valeur de retour

Valeur POSITION qui peut être utilisée pour l’itération ou la récupération du pointeur d’objet ; NULL si la liste est vide.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::GetTailPosition.

Classe	Fonction membre
`CPtrList`	`POSITION GetTailPosition( ) const;`
`CStringList`	`POSITION GetTailPosition( ) const;`

Exemple

Consultez CObList::CObList la liste de la 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`

Ajoute un élément à cette liste après l’élément à la position spécifiée.

POSITION InsertAfter(
    POSITION position,
    CObject* newElement);

Paramètres

position
Valeur POSITION retournée par un appel de fonction membre ou FindGetPrevprécédentGetNext.

newElement
Pointeur d’objet à ajouter à cette liste.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::InsertAfter.

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

Valeur de retour

Valeur POSITION identique au position paramètre.

Exemple

Consultez CObList::CObList la liste de la 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

Les résultats de ce programme sont les suivants :

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

`CObList::InsertBefore`

Ajoute un élément à cette liste avant l’élément à la position spécifiée.

POSITION InsertBefore(
    POSITION position,
    CObject* newElement);

Paramètres

position
Valeur POSITION retournée par un appel de fonction membre ou FindGetPrevprécédentGetNext.

newElement
Pointeur d’objet à ajouter à cette liste.

Valeur de retour

Valeur POSITION qui peut être utilisée pour l’itération ou la récupération du pointeur d’objet ; NULL si la liste est vide.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::InsertBefore.

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

Exemple

Consultez CObList::CObList la liste de la 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

Les résultats de ce programme sont les suivants :

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

`CObList::IsEmpty`

Indique si cette liste ne contient aucun élément.

BOOL IsEmpty() const;

Valeur de retour

Différent de zéro si cette liste est vide ; sinon 0.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::IsEmpty.

Classe	Fonction membre
`CPtrList`	BOOL IsEmpty( ) const ;
`CStringList`	BOOL IsEmpty( ) const ;

Exemple

Consultez l’exemple pour RemoveAll.

`CObList::RemoveAll`

Supprime tous les éléments de cette liste et libère la mémoire associée CObList .

void RemoveAll();

Notes

Aucune erreur n’est générée si la liste est déjà vide.

Lorsque vous supprimez des éléments d’un CObList, vous supprimez les pointeurs d’objet de la liste. Il vous incombe de supprimer eux-mêmes les objets.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::RemoveAll.

Classe	Fonction membre
`CPtrList`	`void RemoveAll( );`
`CStringList`	`void RemoveAll( );`

Exemple

Consultez CObList::CObList la liste de la 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`

Supprime l’élément spécifié de cette liste.

void RemoveAt(POSITION position);

Paramètres

position
Position de l’élément à supprimer de la liste.

Notes

Lorsque vous supprimez un élément d’un CObListélément, vous supprimez le pointeur d’objet de la liste. Il vous incombe de supprimer eux-mêmes les objets.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::RemoveAt.

Classe	Fonction membre
`CPtrList`	`void RemoveAt( POSITION position );`
`CStringList`	`void RemoveAt( POSITION position );`

Exemple

Soyez prudent lors de la suppression d’un élément pendant une itération de liste. L’exemple suivant montre une technique de suppression qui garantit une valeur valide POSITION pour GetNext.

Consultez CObList::CObList la liste de la 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

Les résultats de ce programme sont les suivants :

RemoveAt example: A CObList with 2 elements

a CAge at $4C1E 65

a CAge at $4B22 21

`CObList::RemoveHead`

Supprime l’élément de la tête de la liste et retourne un pointeur vers celui-ci.

CObject* RemoveHead();

Valeur de retour

Pointeur CObject précédemment à la tête de la liste.

Notes

Vous devez vous assurer que la liste n’est pas vide avant d’appeler RemoveHead. Si la liste est vide, la version de débogage de la bibliothèque de classes Microsoft Foundation affirme. Permet IsEmpty de vérifier que la liste contient des éléments.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::RemoveHead.

Classe	Fonction membre
`CPtrList`	`void* RemoveHead( );`
`CStringList`	`CString RemoveHead( );`

Exemple

Consultez CObList::CObList la liste de la 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`

Supprime l’élément de la fin de la liste et retourne un pointeur vers celui-ci.

CObject* RemoveTail();

Valeur de retour

Pointeur vers l’objet qui se trouvait à la fin de la liste.

Notes

Vous devez vous assurer que la liste n’est pas vide avant d’appeler RemoveTail. Si la liste est vide, la version de débogage de la bibliothèque de classes Microsoft Foundation affirme. Permet IsEmpty de vérifier que la liste contient des éléments.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::RemoveTail.

Classe	Fonction membre
`CPtrList`	`void* RemoveTail( );`
`CStringList`	`CString RemoveTail( );`

Exemple

Consultez CObList::CObList la liste de la 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`

Définit l’élément à une position donnée.

void SetAt(
    POSITION pos,
    CObject* newElement);

Paramètres

pos
Élément POSITION à définir.

newElement
Pointeur CObject à écrire dans la liste.

Notes

Une variable de type POSITION est une clé pour la liste. Ce n’est pas le même qu’un index, et vous ne pouvez pas fonctionner sur une POSITION valeur vous-même. SetAt écrit le CObject pointeur à la position spécifiée dans la liste.

Le tableau suivant présente d’autres fonctions membres similaires à CObList::SetAt.

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

Exemple

Consultez CObList::CObList la liste de la 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

Les résultats de ce programme sont les suivants :

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

Voir aussi

CObject Classe
Graphique hiérarchique
CStringList Classe
CPtrList Classe

Share via

La classe CObList

Syntaxe

Membres

Constructeurs publics

Méthodes publiques

Notes

Hiérarchie d'héritage

Spécifications

CObList::AddHead

Paramètres

Valeur de retour

Notes

Exemple

CObList::AddTail

Paramètres

Valeur de retour

Notes

Exemple

CObList::CObList

Paramètres

Notes

Exemple

CObList::Find

Paramètres

Valeur de retour

Notes

Exemple

CObList::FindIndex

Paramètres

Valeur de retour

Notes

Exemple

CObList::GetAt

Paramètres

Valeur de retour

Notes

Exemple

CObList::GetCount

Valeur de retour

Exemple

CObList::GetHead

Valeur de retour

Notes

Exemple

CObList::GetHeadPosition

Valeur de retour

Exemple

CObList::GetNext

Paramètres

Valeur de retour

Notes

Exemple

CObList::GetPrev

Paramètres

Valeur de retour

Notes

Exemple

CObList::GetSize

Valeur de retour

Notes

Exemple

CObList::GetTail

Valeur de retour

Notes

Exemple

CObList::GetTailPosition

Valeur de retour

Exemple

CObList::InsertAfter

Paramètres

Valeur de retour

Exemple

CObList::InsertBefore

Paramètres

Valeur de retour

Exemple

CObList::IsEmpty

Valeur de retour

Exemple

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