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