La classe CObArray

Prend en charge des tableaux de pointeurs CObject .

Syntaxe

class CObArray : public CObject

Membres

Constructeurs publics

Nom	Description
CObArray::CObArray	Construit un tableau vide pour CObject les pointeurs.

Méthodes publiques

Nom	Description
CObArray::Add	Ajoute un élément à la fin du tableau ; étend le tableau si nécessaire.
CObArray::Append	Ajoute un autre tableau au tableau ; étend le tableau si nécessaire.
CObArray::Copy	Copie un autre tableau dans le tableau ; étend le tableau si nécessaire.
CObArray::ElementAt	Retourne une référence temporaire au pointeur d'élément dans le tableau.
CObArray::FreeExtra	Libère toute la mémoire inutilisée au-dessus de la limite supérieure actuelle.
CObArray::GetAt	Retourne la valeur à un index donné.
CObArray::GetCount	Obtient le nombre d'éléments dans ce tableau.
CObArray::GetData	Autorise l'accès aux éléments du tableau. Peut être NULL.
CObArray::GetSize	Obtient le nombre d'éléments dans ce tableau.
CObArray::GetUpperBound	Retourne le plus grand index valide.
CObArray::InsertAt	Insère un élément (ou tous les éléments d'un autre tableau) à un index spécifique.
CObArray::IsEmpty	Détermine si le tableau est vide.
CObArray::RemoveAll	Supprime tous les éléments de ce tableau.
CObArray::RemoveAt	Supprime un élément à un index spécifique.
CObArray::SetAt	Définit la valeur d'un index donné. Le tableau n'est pas autorisé à s'étendre.
CObArray::SetAtGrow	Définit la valeur d'un index donné. Le tableau est étendu si nécessaire.
CObArray::SetSize	Définit le nombre d'éléments que ce tableau doit contenir.

Opérateurs publics

Nom	Description
CObArray::operator []	Définit ou obtient l'élément au niveau de l'index spécifié.

Notes

Ces tableaux d’objets sont similaires aux tableaux C, mais ils peuvent réduire et croître dynamiquement si nécessaire.

Les index de tableau commencent toujours à la position 0. Vous pouvez décider de corriger la limite supérieure ou d’autoriser le tableau à développer lorsque vous ajoutez des éléments au-delà de la limite actuelle. La mémoire est allouée contiguëment à la limite supérieure, même si certains éléments sont NULL.

Sous Win32, la taille d’un CObArray objet est limitée uniquement à la mémoire disponible.

Comme avec un tableau C, l’heure d’accès d’un CObArray élément indexé est constante et est indépendante de la taille du tableau.

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

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

Lorsqu’un CObArray 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.

La dérivation de classe de tableau est similaire à la dérivation de liste. Pour plus d’informations sur la dérivation d’une classe de liste à usage spécial, consultez l’article Collections.

Hiérarchie d'héritage

CObject

CObArray

Spécifications

En-tête : afxcoll.h

CObArray::Add

Ajoute un nouvel élément à la fin d’un tableau, augmentant le tableau de 1.

INT_PTR Add(CObject* newElement);

Paramètres

newElement
Pointeur CObject à ajouter à ce tableau.

Valeur de retour

Index de l’élément ajouté.

Notes

Si SetSize elle a été utilisée avec une nGrowBy valeur supérieure à 1, une mémoire supplémentaire peut être allouée. Toutefois, la limite supérieure augmente de seulement 1.

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

Classe	Fonction membre
CByteArray	INT_PTR Add(BYTE newElement); throw(CMemoryException*);
CDWordArray	INT_PTR Add(DWORD newElement); throw(CMemoryException*);
CPtrArray	INT_PTR Add(void* newElement); throw(CMemoryException*);
CStringArray	INT_PTR Add(LPCTSTR newElement); throw(CMemoryException*); INT_PTR Add(const CString& newElement);
CUIntArray	INT_PTR Add(UINT newElement); throw(CMemoryException*);
CWordArray	INT_PTR Add(WORD newElement); throw(CMemoryException*);

Exemple

Consultez CObList::CObList la liste de la CAge classe utilisée dans tous les exemples de collection.

CObArray arr;

arr.Add(new CAge(21)); // Element 0
arr.Add(new CAge(40)); // Element 1
#ifdef _DEBUG
   afxDump.SetDepth(1);
   afxDump << _T("Add example: ") << &arr << _T("\n");
#endif      

Les résultats de ce programme sont les suivants :

Add example: A CObArray with 2 elements
[0] = a CAge at $442A 21
[1] = a CAge at $4468 40

CObArray::Append

Appelez cette fonction membre pour ajouter le contenu d’un autre tableau à la fin du tableau donné.

INT_PTR Append(const CObArray& src);

Paramètres

src
Source des éléments à ajouter au tableau.

Valeur de retour

Index du premier élément ajouté.

Notes

Les tableaux doivent être du même type.

Si nécessaire, Append peut allouer de la mémoire supplémentaire pour prendre en charge les éléments ajoutés au tableau.

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

Classe	Fonction membre
CByteArray	INT_PTR Append(const CByteArray& src);
CDWordArray	INT_PTR Append(const CDWordArray& src);
CPtrArray	INT_PTR Append(const CPtrArray& src);
CStringArray	INT_PTR Append(const CStringArray& src);
CUIntArray	INT_PTR Append(const CUIntArray& src);
CWordArray	INT_PTR Append(const CWordArray& src);

Exemple

Consultez CObList::CObList la liste de la CAge classe utilisée dans tous les exemples de collection.

CObArray myArray1, myArray2;

// Add elements to the second array.
myArray2.Add(new CAge(21));
myArray2.Add(new CAge(42));

// Add elements to the first array and also append the second array.
myArray1.Add(new CAge(3));
myArray1.Append(myArray2);

#ifdef _DEBUG
   afxDump.SetDepth(1);
   afxDump << _T("myArray1: ") << &myArray1 << _T("\n");
   afxDump << _T("myArray2: ") << &myArray2 << _T("\n");
#endif      

CObArray::Copy

Appelez cette fonction membre pour remplacer les éléments du tableau donné avec les éléments d’un autre tableau du même type.

void Copy(const CObArray& src);

Paramètres

src
Source des éléments à copier dans le tableau.

Notes

Copy ne libère pas de mémoire. Si nécessaire, Copy peut allouer de la mémoire supplémentaire pour prendre en charge les éléments copiés dans le tableau.

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

Classe	Fonction membre
CByteArray	void Copy(const CByteArray& src);
CDWordArray	void Copy(const CDWordArray& src);
CPtrArray	void Copy(const CPtrArray& src);
CStringArray	void Copy(const CStringArray& src);
CUIntArray	void Copy(const CUIntArray& src);
CWordArray	void Copy(const CWordArray& src);

Exemple

Consultez CObList::CObList la liste de la CAge classe utilisée dans tous les exemples de collection.

CObArray myArray1, myArray2;

// Add elements to the second array.
myArray2.Add(new CAge(21));
myArray2.Add(new CAge(42));

// Copy the elements from the second array to the first.
myArray1.Copy(myArray2);

#ifdef _DEBUG
afxDump.SetDepth(1);
afxDump << "myArray1: " << &myArray1 << "\n";
afxDump << "myArray2: " << &myArray2 << "\n";
#endif      

CObArray::CObArray

Construit un tableau de pointeurs vide CObject .

CObArray();

Notes

Le tableau augmente un élément à la fois.

Le tableau suivant présente d’autres constructeurs similaires à CObArray::CObArray.

Classe	Constructeur
CByteArray	CByteArray();
CDWordArray	CDWordArray();
CPtrArray	CPtrArray();
CStringArray	CStringArray();
CUIntArray	CUIntArray();
CWordArray	CWordArray();

Exemple

CObArray arr; //Array with default blocksize
CObArray* pArray = new CObArray; //Array on the heap with default blocksize      

CObArray::ElementAt

Retourne une référence temporaire au pointeur d'élément dans le tableau.

CObject*& ElementAt(INT_PTR nIndex);

Paramètres

nIndex
Index entier supérieur ou égal à 0 et inférieur ou égal à la valeur retournée par GetUpperBound.

Valeur de retour

Référence à un CObject pointeur.

Notes

Il est utilisé pour implémenter l’opérateur d’affectation de gauche pour les tableaux. Il s’agit d’une fonction avancée qui doit être utilisée uniquement pour implémenter des opérateurs de tableau spéciaux.

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

Classe	Fonction membre
CByteArray	BYTE& ElementAt(INT_PTR nIndex);
CDWordArray	DWORD& ElementAt(INT_PTR nIndex);
CPtrArray	void*& ElementAt(INT_PTR nIndex);
CStringArray	CString& ElementAt(INT_PTR nIndex);
CUIntArray	UINT& ElementAt(INT_PTR nIndex);
CWordArray	WORD& ElementAt(INT_PTR nIndex);

Exemple

Consultez l’exemple pour CObArray::GetSize.

CObArray::FreeExtra

Libère toute mémoire supplémentaire allouée pendant la croissance du tableau.

void FreeExtra();

Notes

Cette fonction n’a aucun effet sur la taille ou la limite supérieure du tableau.

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

Classe	Fonction membre
CByteArray	void FreeExtra();
CDWordArray	void FreeExtra();
CPtrArray	void FreeExtra();
CStringArray	void FreeExtra();
CUIntArray	void FreeExtra();
CWordArray	void FreeExtra();

Exemple

Consultez l’exemple pour CObArray::GetData.

CObArray::GetAt

Retourne l’élément de tableau à l’index spécifié.

CObject* GetAt(INT_PTR nIndex) const;

Paramètres

nIndex
Index entier supérieur ou égal à 0 et inférieur ou égal à la valeur retournée par GetUpperBound.

Valeur de retour

Élément CObject pointeur actuellement à cet index.

Notes

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

Classe	Fonction membre
CByteArray	BYTE GetAt(INT_PTR nIndex) const;
CDWordArray	DWORD GetAt(INT_PTR nIndex) const;
CPtrArray	void* GetAt(INT_PTR nIndex) const;
CStringArray	const CString& GetAt(INT_PTR nIndex) const;
CUIntArray	UINT GetAt(INT_PTR nIndex) const;
CWordArray	WORD GetAt(INT_PTR nIndex) const;

Exemple

Consultez CObList::CObList la liste de la CAge classe utilisée dans tous les exemples de collection.

CObArray arr;

arr.Add(new CAge(21)); // Element 0
arr.Add(new CAge(40)); // Element 1
ASSERT(*(CAge*) arr.GetAt(0) == CAge(21));      

CObArray::GetCount

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

INT_PTR GetCount() const;

Valeur de retour

Nombre d’éléments dans le tableau.

Notes

Appelez cette méthode pour récupérer le nombre d’éléments dans le tableau. Étant donné que les index sont de base zéro, la taille est supérieure à 1 index le plus grand.

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

Classe	Fonction membre
CByteArray	INT_PTR GetCount() const;
CDWordArray	INT_PTR GetCount() const;
CPtrArray	INT_PTR GetCount() const;
CStringArray	INT_PTR GetCount() const;
CUIntArray	INT_PTR GetCount() const;
CWordArray	INT_PTR GetCount() const;

Exemple

Consultez CObList::CObList la liste de la CAge classe utilisée dans tous les exemples de collection.

CObArray myArray;

// Add elements to the array.
for (int i = 0; i < 10; i++)
   myArray.Add(new CAge(i));

// Add 100 to all the elements of the array.
for (int i = 0; i < myArray.GetCount(); i++)
{
   CAge*& pAge = (CAge*&) myArray.ElementAt(i);
   delete pAge;
   pAge = new CAge(100 + i);
}

CObArray::GetData

Utilisez cette fonction membre pour accéder directement aux éléments du tableau.

const CObject** GetData() const;

CObject** GetData();

Valeur de retour

Pointeur vers le tableau de CObject pointeurs.

Notes

Si aucun élément n’est disponible, GetData retourne une NULL valeur.

Bien que l’accès direct aux éléments d’un tableau puisse vous aider à travailler plus rapidement, utilisez la prudence lors de l’appel GetData; toutes les erreurs que vous effectuez affectent directement les éléments de votre tableau.

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

Classe	Fonction membre
CByteArray	const BYTE* GetData() const; BYTE* GetData();
CDWordArray	const DWORD* GetData() const; DWORD* GetData();
CPtrArray	const void** GetData() const; void** GetData();
CStringArray	const CString* GetData() const; CString* GetData();
CUIntArray	const UINT* GetData() const; UINT* GetData();
CWordArray	const WORD* GetData() const; WORD* GetData();

Exemple

Consultez CObList::CObList la liste de la CAge classe utilisée dans tous les exemples de collection.

CObArray myArray;

// Allocate memory for at least 32 elements.
myArray.SetSize(32, 128);

// Add elements to the array.
CAge** ppAge = (CAge * *)myArray.GetData();
for (int i = 0; i < 32; i++, ppAge++)
   * ppAge = new CAge(i);

// Only keep first 5 elements and free extra (unused) bytes.
for (int i = 5; i < myArray.GetCount(); i++)
{
   delete myArray[i]; // free objects before resetting array size.         
}
myArray.SetSize(5, 128);
myArray.FreeExtra(); // only frees pointers.

#ifdef _DEBUG
afxDump.SetDepth(1);
afxDump << _T("myArray: ") << &myArray << _T("\n");
#endif      

CObArray::GetSize

Retourne la taille du tableau.

INT_PTR GetSize() const;

Notes

Étant donné que les index sont de base zéro, la taille est supérieure à 1 index le plus grand.

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

Classe	Fonction membre
CByteArray	INT_PTR GetSize() const;
CDWordArray	INT_PTR GetSize() const;
CPtrArray	INT_PTR GetSize() const;
CStringArray	INT_PTR GetSize() const;
CUIntArray	INT_PTR GetSize() const;
CWordArray	INT_PTR GetSize() const;

Exemple

Consultez CObList::CObList la liste de la CAge classe utilisée dans tous les exemples de collection.

CObArray myArray;

// Add elements to the array.
for (int i = 0; i < 10; i++)
   myArray.Add(new CAge(i));

// Add 100 to all the elements of the array.
for (int i = 0; i < myArray.GetSize(); i++)
{
   CAge*& pAge = (CAge * &)myArray.ElementAt(i);
   delete pAge;
   pAge = new CAge(100 + i);
}

#ifdef _DEBUG
afxDump.SetDepth(1);
afxDump << _T("myArray: ") << &myArray << _T("\n");
#endif      

CObArray::GetUpperBound

Retourne la limite supérieure actuelle de ce tableau.

INT_PTR GetUpperBound() const;

Valeur de retour

Index de la limite supérieure (de base zéro).

Notes

Étant donné que les index de tableau sont de base zéro, cette fonction retourne une valeur inférieure à 1 GetSize.

La condition GetUpperBound() = -1 indique que le tableau ne contient aucun élément.

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

Classe	Fonction membre
CByteArray	INT_PTR GetUpperBound() const;
CDWordArray	INT_PTR GetUpperBound() const;
CPtrArray	INT_PTR GetUpperBound() const;
CStringArray	INT_PTR GetUpperBound() const;
CUIntArray	INT_PTR GetUpperBound() const;
CWordArray	INT_PTR GetUpperBound() const;

Exemple

Consultez CObList::CObList la liste de la CAge classe utilisée dans tous les exemples de collection.

CObArray arr;

arr.Add(new CAge(21)); // Element 0
arr.Add(new CAge(40)); // Element 1
ASSERT(arr.GetUpperBound() == 1); // Largest index      

CObArray::InsertAt

Insère un élément (ou tous les éléments d'un autre tableau) à un index spécifique.

void InsertAt(
    INT_PTR nIndex,
    CObject* newElement,
    INT_PTR nCount = 1);

void InsertAt(
    INT_PTR nStartIndex,
    CObArray* pNewArray);

Paramètres

nIndex
Index entier qui peut être supérieur à la valeur retournée par GetUpperBound.

newElement
Pointeur CObject à placer dans ce tableau. Une newElement valeur NULL est autorisée.

nCount
Nombre de fois où cet élément doit être inséré (valeur par défaut : 1).

nStartIndex
Index entier qui peut être supérieur à la valeur retournée par GetUpperBound.

pNewArray
Autre tableau qui contient des éléments à ajouter à ce tableau.

Notes

La première version d’insère InsertAt un élément (ou plusieurs copies d’un élément) à un index spécifié dans un tableau. Dans le processus, il se déplace vers le haut (en incrémentant l’index) l’élément existant à cet index, et il déplace tous les éléments au-dessus de celui-ci.

La deuxième version insère tous les éléments d’une autre CObArray collection, en commençant à la nStartIndex position.

La SetAt fonction, en revanche, remplace un élément de tableau spécifié et ne déplace aucun élément.

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

Classe	Fonction membre
CByteArray	void InsertAt(INT_PTR nIndex, BYTE newElement, int nCount = 1); throw(CMemoryException*); void InsertAt(INT_PTR nStartIndex, CByteArray* pNewArray); throw(CMemoryException*);
CDWordArray	void InsertAt(INT_PTR nIndex, DWORD newElement, int nCount = 1); throw(CMemoryException*); void InsertAt(INT_PTR nStartIndex, CDWordArray* pNewArray); throw(CMemoryException*);
CPtrArray	void InsertAt(INT_PTR nIndex, void* newElement, int nCount = 1); throw(CMemoryException*); void InsertAt(INT_PTR nStartIndex, CPtrArray* pNewArray); throw(CMemoryException*);
CStringArray	void InsertAt(INT_PTR nIndex, LPCTSTR newElement, int nCount = 1); throw(CMemoryException*); void InsertAt(INT_PTR nStartIndex, CStringArray* pNewArray); throw(CMemoryException*);
CUIntArray	void InsertAt(INT_PTR nIndex, UINT newElement, int nCount = 1); throw(CMemoryException*); void InsertAt(INT_PTR nStartIndex, CUIntArray* pNewArray); throw(CMemoryException*);
CWordArray	void InsertAt(INT_PTR nIndex, WORD newElement, int nCount = 1); throw(CMemoryException*); void InsertAt(INT_PTR nStartIndex, CWordArray* pNewArray); throw(CMemoryException*);

Exemple

Consultez CObList::CObList la liste de la CAge classe utilisée dans tous les exemples de collection.

CObArray arr;

arr.Add(new CAge(21)); // Element 0
arr.Add(new CAge(40)); // Element 1 (will become 2).
arr.InsertAt(1, new CAge(30));  // New element 1
#ifdef _DEBUG
afxDump.SetDepth(1);
afxDump << _T("InsertAt example: ") << &arr << _T("\n");
#endif      

Les résultats de ce programme sont les suivants :

InsertAt example: A CObArray with 3 elements
[0] = a CAge at $45C8 21
[1] = a CAge at $4646 30
[2] = a CAge at $4606 40

CObArray::IsEmpty

Détermine si le tableau est vide.

BOOL IsEmpty() const;

Valeur de retour

Différent de zéro si le tableau est vide ; sinon 0.

CObArray::operator [ ]

Ces opérateurs d’indice sont un substitut pratique pour les fonctions et GetAt les SetAt fonctions.

CObject*& operator[](int_ptr nindex);
CObject* operator[](int_ptr nindex) const;

Notes

Le premier opérateur, appelé pour les tableaux qui ne sont pas const, peut être utilisé à droite (r-value) ou à gauche (l-value) d’une instruction d’affectation. La deuxième, appelée pour const les tableaux, peut être utilisée uniquement à droite.

La version de débogage de la bibliothèque affirme si l’indice (à gauche ou à droite d’une instruction d’affectation) est hors limites.

Le tableau suivant présente d’autres opérateurs similaires à CObArray::operator [].

Classe	Opérateur
CByteArray	BYTE& operator [](INT_PTR nindex); BYTE operator [](INT_PTR nindex) const;
CDWordArray	DWORD& operator [](INT_PTR nindex); DWORD operator [](INT_PTR nindex) const;
CPtrArray	void*& operator [](INT_PTR nindex); void* operator [](INT_PTR nindex) const;
CStringArray	CString& operator [](INT_PTR nindex); CString operator [](INT_PTR nindex) const;
CUIntArray	UINT& operator [](INT_PTR nindex); UINT operator [](INT_PTR nindex) const;
CWordArray	WORD& operator [](INT_PTR nindex); WORD operator [](INT_PTR nindex) const;

Exemple

Consultez CObList::CObList la liste de la CAge classe utilisée dans tous les exemples de collection.

CObArray arr;
CAge* pa;

arr.Add(new CAge(21)); // Element 0
arr.Add(new CAge(40)); // Element 1
pa = (CAge*)arr[0]; // Get element 0
ASSERT(*pa == CAge(21)); // Get element 0
arr[0] = new CAge(30); // Replace element 0
delete pa;
ASSERT(*(CAge*)arr[0] == CAge(30)); // Get new element 0      

CObArray::RemoveAll

Supprime tous les pointeurs de ce tableau, mais ne supprime pas réellement les CObject objets.

void RemoveAll();

Notes

Si le tableau est déjà vide, la fonction fonctionne toujours.

La RemoveAll fonction libère toute la mémoire utilisée pour le stockage de pointeur.

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

Classe	Fonction membre
CByteArray	void RemoveAll();
CDWordArray	void RemoveAll();
CPtrArray	void RemoveAll();
CStringArray	void RemoveAll();
CUIntArray	void RemoveAll();
CWordArray	void RemoveAll();

Exemple

Consultez CObList::CObList la liste de la CAge classe utilisée dans tous les exemples de collection.

CObArray arr;
CAge* pa1;
CAge* pa2;

arr.Add(pa1 = new CAge(21)); // Element 0
arr.Add(pa2 = new CAge(40)); // Element 1
ASSERT(arr.GetSize() == 2);
arr.RemoveAll(); // Pointers removed but objects not deleted.
ASSERT(arr.GetSize() == 0);
delete pa1;
delete pa2;  // Cleans up memory.      

CObArray::RemoveAt

Supprime un ou plusieurs éléments commençant à un index spécifié dans un tableau.

void RemoveAt(
    INT_PTR nIndex,
    INT_PTR nCount = 1);

Paramètres

nIndex
Index entier supérieur ou égal à 0 et inférieur ou égal à la valeur retournée par GetUpperBound.

nCount
Nombre d'éléments à supprimer.

Notes

Dans le processus, il déplace tous les éléments au-dessus du ou des éléments supprimés. Il décrémente la limite supérieure du tableau, mais ne libère pas de mémoire.

Si vous essayez de supprimer plus d’éléments que ceux contenus dans le tableau au-dessus du point de suppression, la version de débogage de la bibliothèque affirme.

La RemoveAt fonction supprime le CObject pointeur du tableau, mais elle ne supprime pas l’objet lui-même.

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

Classe	Fonction membre
CByteArray	void RemoveAt(INT_PTR nIndex, INT_PTR nCount = 1);
CDWordArray	void RemoveAt(INT_PTR nIndex, INT_PTR nCount = 1);
CPtrArray	void RemoveAt(INT_PTR nIndex, INT_PTR nCount = 1);
CStringArray	void RemoveAt(INT_PTR nIndex, INT_PTR nCount = 1);
CUIntArray	void RemoveAt(INT_PTR nIndex, INT_PTR nCount = 1);
CWordArray	void RemoveAt(INT_PTR nIndex, INT_PTR nCount = 1);

Exemple

Consultez CObList::CObList la liste de la CAge classe utilisée dans tous les exemples de collection.

CObArray arr;
CObject* pa;

arr.Add(new CAge(21)); // Element 0
arr.Add(new CAge(40)); // Element 1
if ((pa = arr.GetAt(0)) != NULL)
{
   arr.RemoveAt(0);  // Element 1 moves to 0.
   delete pa; // Delete the original element at 0.
}
#ifdef _DEBUG
afxDump.SetDepth(1);
afxDump << _T("RemoveAt example: ") << &arr << _T("\n");
#endif      

Les résultats de ce programme sont les suivants :

RemoveAt example: A CObArray with 1 elements
[0] = a CAge at $4606 40

CObArray::SetAt

Définit l’élément de tableau à l’index spécifié.

void SetAt(
    INT_PTR nIndex,
    CObject* newElement);

Paramètres

nIndex
Index entier supérieur ou égal à 0 et inférieur ou égal à la valeur retournée par GetUpperBound.

newElement
Pointeur d’objet à insérer dans ce tableau. Une NULL valeur est autorisée.

Notes

SetAt ne provoquera pas la croissance du tableau. Utilisez SetAtGrow si vous souhaitez que le tableau augmente automatiquement.

Vérifiez que votre valeur d’index représente une position valide dans le tableau. S’il est hors limites, la version de débogage de la bibliothèque affirme.

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

Classe	Fonction membre
CByteArray	void SetAt(INT_PTR nIndex, BYTE newElement);
CDWordArray	void SetAt(INT_PTR nIndex, DWORD newElement);
CPtrArray	void SetAt(INT_PTR nIndex, void* newElement);
CStringArray	void SetAt(INT_PTR nIndex, LPCTSTR newElement);
CUIntArray	void SetAt(INT_PTR nIndex, UINT newElement);
CWordArray	void SetAt(INT_PTR nIndex, WORD newElement);

Exemple

Consultez CObList::CObList la liste de la CAge classe utilisée dans tous les exemples de collection.

CObArray arr;
CObject* pa;

arr.Add(new CAge(21)); // Element 0
arr.Add(new CAge(40)); // Element 1
if ((pa = arr.GetAt(0)) != NULL)
{
   arr.SetAt(0, new CAge(30));  // Replace element 0.
   delete pa; // Delete the original element at 0.
}
#ifdef _DEBUG
afxDump.SetDepth(1);
afxDump << _T("SetAt example: ") << &arr << _T("\n");
#endif      

Les résultats de ce programme sont les suivants :

SetAt example: A CObArray with 2 elements
[0] = a CAge at $47E0 30
[1] = a CAge at $47A0 40

CObArray::SetAtGrow

Définit l’élément de tableau à l’index spécifié.

void SetAtGrow(
    INT_PTR nIndex,
    CObject* newElement);

Paramètres

nIndex
Index entier supérieur ou égal à 0.

newElement
Pointeur d’objet à ajouter à ce tableau. Une NULL valeur est autorisée.

Notes

Le tableau augmente automatiquement si nécessaire (autrement dit, la limite supérieure est ajustée pour prendre en charge le nouvel élément).

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

Classe	Fonction membre
CByteArray	void SetAtGrow(INT_PTR nIndex, BYTE newElement); throw(CMemoryException*);
CDWordArray	void SetAtGrow(INT_PTR nIndex, DWORD newElement); throw(CMemoryException*);
CPtrArray	void SetAtGrow(INT_PTR nIndex, void* newElement); throw( CMemoryException*);
CStringArray	void SetAtGrow(INT_PTR nIndex, LPCTSTR newElement); throw(CMemoryException*);
CUIntArray	void SetAtGrow(INT_PTR nIndex, UINT newElement); throw(CMemoryException*);
CWordArray	void SetAtGrow(INT_PTR nIndex, WORD newElement); throw(CMemoryException*);

Exemple

Consultez CObList::CObList la liste de la CAge classe utilisée dans tous les exemples de collection.

CObArray arr;

arr.Add(new CAge(21)); // Element 0
arr.Add(new CAge(40)); // Element 1
arr.SetAtGrow(3, new CAge(65)); // Element 2 deliberately
                                      // skipped.
#ifdef _DEBUG
afxDump.SetDepth(1);
afxDump << _T("SetAtGrow example: ") << &arr << _T("\n");
#endif      

Les résultats de ce programme sont les suivants :

SetAtGrow example: A CObArray with 4 elements
[0] = a CAge at $47C0 21
[1] = a CAge at $4800 40
[2] = NULL
[3] = a CAge at $4840 65

CObArray::SetSize

Établit la taille d’un tableau vide ou existant ; alloue de la mémoire si nécessaire.

void SetSize(
    INT_PTR nNewSize,
    INT_PTR nGrowBy = -1);

Paramètres

nNewSize
Nouvelle taille de tableau (nombre d’éléments). Doit être supérieur ou égal à 0.

nGrowBy
Nombre minimal d’emplacements d’élément à allouer si une augmentation de taille est nécessaire.

Notes

Si la nouvelle taille est inférieure à l’ancienne taille, le tableau est tronqué et toutes les mémoires inutilisées sont libérées. Pour plus d’efficacité, appelez SetSize pour définir la taille du tableau avant de l’utiliser. Cela empêche la réaffectation et la copie du tableau chaque fois qu’un élément est ajouté.

Le nGrowBy paramètre affecte l’allocation de mémoire interne pendant la croissance du tableau. Son utilisation n’affecte jamais la taille du tableau comme indiqué par GetSize et GetUpperBound.

Si la taille du tableau a augmenté, tous les pointeurs nouvellement alloués CObject * sont définis sur NULL.

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

Classe	Fonction membre
CByteArray	void SetSize(INT_PTR nNewSize, int nGrowBy = -1); throw(CMemoryException*);
CDWordArray	void SetSize(INT_PTR nNewSize, int nGrowBy = -1); throw(CMemoryException*);
CPtrArray	void SetSize(INT_PTR nNewSize, int nGrowBy = -1); throw(CMemoryException*);
CStringArray	void SetSize(INT_PTR nNewSize, int nGrowBy = -1); throw(CMemoryException*);
CUIntArray	void SetSize(INT_PTR nNewSize, int nGrowBy = -1); throw(CMemoryException*);
CWordArray	void SetSize(INT_PTR nNewSize, int nGrowBy = -1); throw(CMemoryException*);

Exemple

Consultez l’exemple pour CObArray::GetData.

Voir aussi

CObject Classe
Graphique hiérarchique
CStringArray Classe
CPtrArray Classe
CByteArray Classe
CWordArray Classe
CDWordArray Classe