Freigeben über


CObArray-Klasse

Unterstützt Arrays mit CObject -Zeigern.

Syntax

class CObArray : public CObject

Member

Öffentliche Konstruktoren

Name Beschreibung
CObArray::CObArray Erstellt ein leeres Array für CObject Zeiger.

Öffentliche Methoden

Name Beschreibung
CObArray::Add Fügt am Ende des Arrays ein Element hinzu; vergrößert das Array bei Bedarf.
CObArray::Append Hängt ein anderes Array an das Array an; vergrößert das Array bei Bedarf.
CObArray::Copy Kopiert ein anderes Array in das Array; vergrößert das Array bei Bedarf.
CObArray::ElementAt Gibt einen temporären Verweis auf den Elementzeiger innerhalb des Arrays zurück.
CObArray::FreeExtra Gibt den gesamten nicht verwendeten Arbeitsspeicher über der aktuellen Obergrenze frei.
CObArray::GetAt Gibt den Wert an einem bestimmten Index zurück.
CObArray::GetCount Ruft die Anzahl der Elemente im Array ab.
CObArray::GetData Ermöglicht den Zugriff auf Elemente im Array. Kann NULL sein.
CObArray::GetSize Ruft die Anzahl der Elemente im Array ab.
CObArray::GetUpperBound Gibt den größten gültigen Index zurück.
CObArray::InsertAt Fügt ein Element (oder alle Elemente in einem anderen Array) am angegebenen Index ein.
CObArray::IsEmpty Bestimmt, ob das Array leer ist.
CObArray::RemoveAll Entfernt alle Elemente aus diesem Array.
CObArray::RemoveAt Entfernt ein Element an einem spezifischen Index.
CObArray::SetAt Legt den Wert für einen bestimmten Index fest; Array darf nicht vergrößert werden.
CObArray::SetAtGrow Legt den Wert für einen bestimmten Index fest; vergrößert das Array bei Bedarf.
CObArray::SetSize Legt die Anzahl der Elemente im Array fest.

Öffentliche Operatoren

Name Beschreibung
CObArray::operator [] Legt das Element am angegebenen Index fest oder ruft es ab.

Hinweise

Diese Objektarrays ähneln C-Arrays, können aber bei Bedarf dynamisch verkleinern und wachsen.

Arrayindizes beginnen immer an Position 0. Sie können entscheiden, ob die obere Grenze behoben werden soll, oder ob das Array erweitert werden soll, wenn Sie Elemente über die aktuelle Grenze einfügen. Der Arbeitsspeicher wird zusammenhängend der oberen Grenze zugeordnet, auch wenn einige Elemente vorhanden sind NULL.

Unter Win32 ist die Größe eines CObArray Objekts nur auf den verfügbaren Arbeitsspeicher beschränkt.

Wie bei einem C-Array ist die Zugriffszeit für ein CObArray indiziertes Element konstant und unabhängig von der Arraygröße.

CObArray enthält das Makro zur Unterstützung der IMPLEMENT_SERIAL Serialisierung und des Dumpings seiner Elemente. Wenn ein Array von CObject Zeigern in einem Archiv gespeichert wird, entweder mit dem überladenen Einfügeoperator oder mit der Serialize Memberfunktion, wird jedes CObject Element wiederum zusammen mit seinem Arrayindex serialisiert.

Wenn Sie ein Abbild einzelner CObject Elemente in einem Array benötigen, müssen Sie die Tiefe des CDumpContext Objekts auf 1 oder höher festlegen.

Wenn ein CObArray Objekt gelöscht wird oder dessen Elemente entfernt werden, werden nur die CObject Zeiger entfernt, nicht die Objekte, auf die verwiesen wird.

Hinweis

Vor dem Verwenden eines Arrays, verwenden Sie SetSize, um dessen Größe festzustellen, und weisen dafür Arbeitsspeicher zu. Wenn Sie SetSize nicht verwenden, kann das Hinzufügen von Elementen zu Ihrem Array dazu führen, dass es häufig neu zugeordnet und kopiert wird. Häufige Neuzuordnungen und Kopiervorgänge sind ineffizient und können zu einer Fragmentierung des Arbeitsspeichers führen.

Die Arrayklassenableitung ähnelt der Listenableitung. Ausführliche Informationen zur Ableitung einer speziellen Listenklasse finden Sie im Artikel Sammlungen.

Hinweis

Sie müssen das IMPLEMENT_SERIAL-Makro in der Implementierung Der abgeleiteten Klasse verwenden, wenn Sie das Array serialisieren möchten.

Vererbungshierarchie

CObject

CObArray

Anforderungen

Header: afxcoll.h

CObArray::Add

Fügt am Ende eines Arrays ein neues Element hinzu, wobei das Array um 1 wächst.

INT_PTR Add(CObject* newElement);

Parameter

newElement
Der CObject Zeiger, der diesem Array hinzugefügt werden soll.

Rückgabewert

Der Index des hinzugefügten Elements.

Hinweise

Wenn SetSize sie mit einem nGrowBy Wert verwendet wurde, der größer als 1 ist, kann zusätzlicher Arbeitsspeicher zugewiesen werden. Die obere Grenze wird jedoch nur um 1 erhöht.

In der folgenden Tabelle sind andere Memberfunktionen aufgeführt, die ähnlich sind CObArray::Add.

Klasse Memberfunktion
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*);

Beispiel

Eine Auflistung der CAge Klasse finden Sie CObList::CObList in allen Auflistungsbeispielen.

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      

Die Ergebnisse dieses Programms sind wie folgt:

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

CObArray::Append

Rufen Sie diese Memberfunktion auf, um den Inhalt eines anderen Arrays am Ende des angegebenen Arrays hinzuzufügen.

INT_PTR Append(const CObArray& src);

Parameter

src
Quelle der Elemente, die an das Array angefügt werden sollen.

Rückgabewert

Der Index des ersten angefügten Elements.

Hinweise

Die Arrays müssen denselben Typ aufweisen.

Falls erforderlich, kann zusätzlichen Arbeitsspeicher zugewiesen werden, um die elemente aufzunehmen, Append die an das Array angefügt sind.

In der folgenden Tabelle sind andere Memberfunktionen aufgeführt, die ähnlich sind CObArray::Append.

Klasse Memberfunktion
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);

Beispiel

Eine Auflistung der CAge Klasse finden Sie CObList::CObList in allen Auflistungsbeispielen.

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

Rufen Sie diese Memberfunktion auf, um die Elemente des angegebenen Arrays mit den Elementen eines anderen Arrays desselben Typs zu überschreiben.

void Copy(const CObArray& src);

Parameter

src
Quelle der Elemente, die in das Array kopiert werden sollen.

Hinweise

Copy gibt keinen Freien Arbeitsspeicher frei. Falls erforderlich, kann zusätzlichen Arbeitsspeicher zugewiesen werden, um die elemente aufzunehmen, Copy die in das Array kopiert wurden.

In der folgenden Tabelle sind andere Memberfunktionen aufgeführt, die ähnlich sind CObArray::Copy.

Klasse Memberfunktion
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);

Beispiel

Eine Auflistung der CAge Klasse finden Sie CObList::CObList in allen Auflistungsbeispielen.

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

Erstellt ein leeres CObject Zeigerarray.

CObArray();

Hinweise

Das Array vergrößert jeweils ein Element.

In der folgenden Tabelle sind andere Konstruktoren aufgeführt, die ähnlich sind CObArray::CObArray.

Klasse Konstruktor
CByteArray CByteArray();
CDWordArray CDWordArray();
CPtrArray CPtrArray();
CStringArray CStringArray();
CUIntArray CUIntArray();
CWordArray CWordArray();

Beispiel

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

CObArray::ElementAt

Gibt einen temporären Verweis auf den Elementzeiger innerhalb des Arrays zurück.

CObject*& ElementAt(INT_PTR nIndex);

Parameter

nIndex
Ein ganzzahliger Index, der größer oder gleich 0 und kleiner als oder gleich dem wert ist, der von GetUpperBound.

Rückgabewert

Ein Verweis auf einen CObject Zeiger.

Hinweise

Es wird verwendet, um den linksseitigen Zuordnungsoperator für Arrays zu implementieren. Dies ist eine erweiterte Funktion, die nur zum Implementieren spezieller Arrayoperatoren verwendet werden sollte.

In der folgenden Tabelle sind andere Memberfunktionen aufgeführt, die ähnlich sind CObArray::ElementAt.

Klasse Memberfunktion
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);

Beispiel

Ein Beispiel hierfür finden Sie unter CObArray::GetSize.

CObArray::FreeExtra

Gibt zusätzlichen Arbeitsspeicher frei, der während des Arrays zugeordnet wurde.

void FreeExtra();

Hinweise

Diese Funktion hat keine Auswirkungen auf die Größe oder obere Grenze des Arrays.

In der folgenden Tabelle sind andere Memberfunktionen aufgeführt, die ähnlich sind CObArray::FreeExtra.

Klasse Memberfunktion
CByteArray void FreeExtra();
CDWordArray void FreeExtra();
CPtrArray void FreeExtra();
CStringArray void FreeExtra();
CUIntArray void FreeExtra();
CWordArray void FreeExtra();

Beispiel

Ein Beispiel hierfür finden Sie unter CObArray::GetData.

CObArray::GetAt

Gibt das Arrayelement am angegebenen Index zurück.

CObject* GetAt(INT_PTR nIndex) const;

Parameter

nIndex
Ein ganzzahliger Index, der größer oder gleich 0 und kleiner als oder gleich dem wert ist, der von GetUpperBound.

Rückgabewert

Das CObject Zeigerelement, das sich derzeit in diesem Index befindet.

Hinweise

Hinweis

Das Übergeben eines negativen Werts oder eines Werts, der größer als der zurückgegebene GetUpperBound Wert ist, führt zu einer fehlgeschlagenen Assertion.

In der folgenden Tabelle sind andere Memberfunktionen aufgeführt, die ähnlich sind CObArray::GetAt.

Klasse Memberfunktion
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;

Beispiel

Eine Auflistung der CAge Klasse finden Sie CObList::CObList in allen Auflistungsbeispielen.

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

Gibt die Anzahl der Arrayelemente zurück.

INT_PTR GetCount() const;

Rückgabewert

Die Anzahl der Elemente im Array.

Hinweise

Rufen Sie diese Methode auf, um die Anzahl der Elemente im Array abzurufen. Da Indizes nullbasiert sind, ist die Größe 1 größer als der größte Index.

In der folgenden Tabelle sind andere Memberfunktionen aufgeführt, die ähnlich sind CObArray::GetCount.

Klasse Memberfunktion
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;

Beispiel

Eine Auflistung der CAge Klasse finden Sie CObList::CObList in allen Auflistungsbeispielen.

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

Verwenden Sie diese Memberfunktion, um direkten Zugriff auf die Elemente im Array zu erhalten.

const CObject** GetData() const;

CObject** GetData();

Rückgabewert

Ein Zeiger auf das Array von CObject Zeigern.

Hinweise

Wenn keine Elemente verfügbar sind, GetData wird ein NULL Wert zurückgegeben.

Während der direkte Zugriff auf die Elemente eines Arrays Ihnen helfen kann, schneller zu arbeiten, verwenden Sie Vorsicht beim Aufrufen GetData; alle Fehler, die Sie direkt vornehmen, wirken sich auf die Elemente Ihres Arrays aus.

In der folgenden Tabelle sind andere Memberfunktionen aufgeführt, die ähnlich sind CObArray::GetData.

Klasse Memberfunktion
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();

Beispiel

Eine Auflistung der CAge Klasse finden Sie CObList::CObList in allen Auflistungsbeispielen.

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

Gibt die Größe des Arrays zurück.

INT_PTR GetSize() const;

Hinweise

Da Indizes nullbasiert sind, ist die Größe 1 größer als der größte Index.

In der folgenden Tabelle sind andere Memberfunktionen aufgeführt, die ähnlich sind CObArray::GetSize.

Klasse Memberfunktion
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;

Beispiel

Eine Auflistung der CAge Klasse finden Sie CObList::CObList in allen Auflistungsbeispielen.

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

Gibt die aktuelle obere Grenze dieses Arrays zurück.

INT_PTR GetUpperBound() const;

Rückgabewert

Der Index der oberen Grenze (nullbasiert).

Hinweise

Da Arrayindizes nullbasiert sind, gibt diese Funktion einen Wert von 1 kleiner als GetSizezurück.

Die Bedingung GetUpperBound() = -1 gibt an, dass das Array keine Elemente enthält.

In der folgenden Tabelle sind andere Memberfunktionen aufgeführt, die ähnlich sind CObArray::GetUpperBound.

Klasse Memberfunktion
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;

Beispiel

Eine Auflistung der CAge Klasse finden Sie CObList::CObList in allen Auflistungsbeispielen.

CObArray arr;

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

CObArray::InsertAt

Fügt ein Element (oder alle Elemente in einem anderen Array) am angegebenen Index ein.

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

void InsertAt(
    INT_PTR nStartIndex,
    CObArray* pNewArray);

Parameter

nIndex
Ein ganzzahliger Index, der größer als der von GetUpperBound.

newElement
Der CObject Zeiger, der in diesem Array platziert werden soll. Ein newElement Wert NULL ist zulässig.

nCount
Die Häufigkeit, mit der dieses Element eingefügt werden soll (Standardwert ist 1).

nStartIndex
Ein ganzzahliger Index, der größer als der von GetUpperBound.

pNewArray
Ein weiteres Array, das Elemente enthält, die diesem Array hinzugefügt werden sollen.

Hinweise

Die erste Version von InsertAt Elementen fügt ein Element (oder mehrere Kopien eines Elements) an einem angegebenen Index in einem Array ein. Im Prozess verschiebt es das vorhandene Element in diesem Index nach oben (indem es den Index erhöht), und er verschiebt alle darüber stehenden Elemente nach oben.

Die zweite Version fügt alle Elemente aus einer anderen CObArray Auflistung ein, beginnend an der nStartIndex Position.

Die SetAt Funktion ersetzt dagegen ein angegebenes Arrayelement und verschiebt keine Elemente.

In der folgenden Tabelle sind andere Memberfunktionen aufgeführt, die ähnlich sind CObArray::InsertAt.

Klasse Memberfunktion
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*);

Beispiel

Eine Auflistung der CAge Klasse finden Sie CObList::CObList in allen Auflistungsbeispielen.

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      

Die Ergebnisse dieses Programms sind wie folgt:

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

Bestimmt, ob das Array leer ist.

BOOL IsEmpty() const;

Rückgabewert

Nonzero, wenn das Array leer ist; andernfalls 0.

CObArray::operator [ ]

Diese tiefgestellten Operatoren sind ein praktischer Ersatz für die SetAt und GetAt Funktionen.

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

Hinweise

Der erste Operator, der für Arrays aufgerufen wird, die nicht constverwendet werden, kann entweder auf der rechten Seite (r-Wert) oder links (l-Wert) einer Zuordnungsanweisung verwendet werden. Die zweite, die für const Arrays aufgerufen wird, kann nur auf der rechten Seite verwendet werden.

Die Debugversion der Bibliothek bestätigt, ob das Tiefgestellt (entweder auf der linken oder rechten Seite einer Zuordnungsanweisung) außerhalb der Grenzen liegt.

In der folgenden Tabelle sind andere Operatoren aufgeführt, die ähnlich sind CObArray::operator [].

Klasse Operator
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;

Beispiel

Eine Auflistung der CAge Klasse finden Sie CObList::CObList in allen Auflistungsbeispielen.

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

Entfernt alle Zeiger aus diesem Array, löscht jedoch nicht die CObject Objekte.

void RemoveAll();

Hinweise

Wenn das Array bereits leer ist, funktioniert die Funktion weiterhin.

Die RemoveAll Funktion gibt den gesamten Speicher frei, der für Zeigerspeicher verwendet wird.

In der folgenden Tabelle sind andere Memberfunktionen aufgeführt, die ähnlich sind CObArray::RemoveAll.

Klasse Memberfunktion
CByteArray void RemoveAll();
CDWordArray void RemoveAll();
CPtrArray void RemoveAll();
CStringArray void RemoveAll();
CUIntArray void RemoveAll();
CWordArray void RemoveAll();

Beispiel

Eine Auflistung der CAge Klasse finden Sie CObList::CObList in allen Auflistungsbeispielen.

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

Entfernt ein oder mehrere Elemente, die mit einem angegebenen Index in einem Array beginnen.

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

Parameter

nIndex
Ein ganzzahliger Index, der größer oder gleich 0 und kleiner als oder gleich dem wert ist, der von GetUpperBound.

nCount
Die Anzahl der zu entfernenden Elemente.

Hinweise

Im Prozess verschiebt er alle Elemente oberhalb der entfernten Elemente nach unten. Sie erhöht die obere Grenze des Arrays, freigibt jedoch keinen Arbeitsspeicher.

Wenn Sie versuchen, mehr Elemente zu entfernen, als im Array oberhalb des Entfernungspunkts enthalten sind, wird die Debugversion der Bibliothek bestätigt.

Die RemoveAt Funktion entfernt den CObject Zeiger aus dem Array, löscht jedoch nicht das Objekt selbst.

In der folgenden Tabelle sind andere Memberfunktionen aufgeführt, die ähnlich sind CObArray::RemoveAt.

Klasse Memberfunktion
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);

Beispiel

Eine Auflistung der CAge Klasse finden Sie CObList::CObList in allen Auflistungsbeispielen.

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      

Die Ergebnisse dieses Programms sind wie folgt:

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

CObArray::SetAt

Legt das Arrayelement am angegebenen Index fest.

void SetAt(
    INT_PTR nIndex,
    CObject* newElement);

Parameter

nIndex
Ein ganzzahliger Index, der größer oder gleich 0 und kleiner als oder gleich dem wert ist, der von GetUpperBound.

newElement
Der Objektzeiger, der in dieses Array eingefügt werden soll. Ein NULL Wert ist zulässig.

Hinweise

SetAt führt nicht dazu, dass das Array vergrößert wird. Verwenden Sie SetAtGrow diesen Vorgang, wenn das Array automatisch vergrößert werden soll.

Stellen Sie sicher, dass ihr Indexwert eine gültige Position im Array darstellt. Wenn dies außerhalb der Grenzen liegt, wird die Debugversion der Bibliothek bestätigt.

In der folgenden Tabelle sind andere Memberfunktionen aufgeführt, die ähnlich sind CObArray::SetAt.

Klasse Memberfunktion
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);

Beispiel

Eine Auflistung der CAge Klasse finden Sie CObList::CObList in allen Auflistungsbeispielen.

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      

Die Ergebnisse dieses Programms sind wie folgt:

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

CObArray::SetAtGrow

Legt das Arrayelement am angegebenen Index fest.

void SetAtGrow(
    INT_PTR nIndex,
    CObject* newElement);

Parameter

nIndex
Ein ganzzahliger Index, der größer oder gleich 0 ist.

newElement
Der Objektzeiger, der diesem Array hinzugefügt werden soll. Ein NULL Wert ist zulässig.

Hinweise

Das Array wird bei Bedarf automatisch wächst (d. a. die obere Grenze wird an das neue Element angepasst).

In der folgenden Tabelle sind andere Memberfunktionen aufgeführt, die ähnlich sind CObArray::SetAtGrow.

Klasse Memberfunktion
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*);

Beispiel

Eine Auflistung der CAge Klasse finden Sie CObList::CObList in allen Auflistungsbeispielen.

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      

Die Ergebnisse dieses Programms sind wie folgt:

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

Legt die Größe eines leeren oder vorhandenen Arrays fest; ordnet bei Bedarf Arbeitsspeicher zu.

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

Parameter

nNewSize
Die neue Arraygröße (Anzahl der Elemente). Muss größer als oder gleich 0 sein.

nGrowBy
Die Mindestanzahl der Elementplätze, die zugewiesen werden sollen, wenn eine Größenerhöhung erforderlich ist.

Hinweise

Wenn die neue Größe kleiner als die alte Größe ist, wird das Array abgeschnitten, und der gesamte nicht verwendete Arbeitsspeicher wird freigegeben. Rufen Sie SetSize zur Effizienz auf, um die Größe des Arrays festzulegen, bevor Sie es verwenden. Dadurch wird verhindert, dass das Array bei jedem Hinzufügen eines Elements neu zugeordnet und kopiert werden muss.

Der nGrowBy Parameter wirkt sich auf die interne Speicherzuordnung aus, während das Array wächst. Die Verwendung wirkt sich niemals auf die Arraygröße aus, wie von GetSize und GetUpperBound.

Wenn die Größe des Arrays gewachsen ist, werden alle neu zugewiesenen CObject * Zeiger auf NULLfestgelegt.

In der folgenden Tabelle sind andere Memberfunktionen aufgeführt, die ähnlich sind CObArray::SetSize.

Klasse Memberfunktion
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*);

Beispiel

Ein Beispiel hierfür finden Sie unter CObArray::GetData.

Siehe auch

CObject-Klasse
Hierarchiediagramm
CStringArray Klasse
CPtrArray Klasse
CByteArray Klasse
CWordArray Klasse
CDWordArray Klasse