Partager via


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.

Remarque

Avant d'utiliser un tableau, utilisez SetSize pour définir sa taille et lui allouer la mémoire nécessaire. Si vous n'utilisez pas SetSize, l'ajout d'éléments à votre tableau risque d'entraîner de fréquentes opérations de réallocation et de copie de ce dernier. Les opérations fréquentes de réallocation et de copie sont inefficaces et peuvent fragmenter la mémoire.

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.

Remarque

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

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

Remarque

Le passage d’une valeur négative ou d’une valeur supérieure à la valeur retournée entraîne GetUpperBound une assertion ayant échoué.

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