`CObArray`-klass

Stöder matriser med CObject pekare.

Syntax

class CObArray : public CObject

Medlemmar

Offentliga konstruktorer

Namn	Beskrivning
`CObArray::CObArray`	Skapar en tom matris för `CObject` pekare.

Offentliga metoder

Namn	Beskrivning
`CObArray::Add`	Lägger till ett element i slutet av matrisen. växer matrisen om det behövs.
`CObArray::Append`	Lägger till en annan matris i matrisen. växer matrisen om det behövs.
`CObArray::Copy`	Kopierar en annan matris till matrisen. växer matrisen om det behövs.
`CObArray::ElementAt`	Returnerar en tillfällig referens till elementpekaren i matrisen.
`CObArray::FreeExtra`	Frigör allt oanvänt minne ovanför den aktuella övre gränsen.
`CObArray::GetAt`	Returnerar värdet vid ett angivet index.
`CObArray::GetCount`	Hämtar antalet element i den här matrisen.
`CObArray::GetData`	Tillåter åtkomst till element i matrisen. Kan vara `NULL`.
`CObArray::GetSize`	Hämtar antalet element i den här matrisen.
`CObArray::GetUpperBound`	Returnerar det största giltiga indexet.
`CObArray::InsertAt`	Infogar ett element (eller alla element i en annan matris) vid ett angivet index.
`CObArray::IsEmpty`	Avgör om matrisen är tom.
`CObArray::RemoveAll`	Tar bort alla element från den här matrisen.
`CObArray::RemoveAt`	Tar bort ett element i ett specifikt index.
`CObArray::SetAt`	Anger värdet för ett visst index. matrisen får inte växa.
`CObArray::SetAtGrow`	Anger värdet för ett visst index. växer matrisen om det behövs.
`CObArray::SetSize`	Anger antalet element som ska finnas i den här matrisen.

Offentliga operatörer

Namn	Beskrivning
`CObArray::operator []`	Anger eller hämtar elementet vid det angivna indexet.

Anmärkningar

Dessa objektmatriser liknar C-matriser, men de kan dynamiskt krympa och växa efter behov.

Matrisindex börjar alltid vid position 0. Du kan bestämma om du vill åtgärda den övre gränsen eller tillåta att matrisen expanderas när du lägger till element förbi den aktuella bindningen. Minnet allokeras sammanhängande till den övre gränsen, även om vissa element är NULL.

Under Win32 begränsas storleken på ett CObArray objekt endast till tillgängligt minne.

Precis som med en C-matris är åtkomsttiden för ett CObArray indexerat element konstant och oberoende av matrisstorleken.

CObArray innehåller makrot IMPLEMENT_SERIAL för att stödja serialisering och dumpning av dess element. Om en matris CObject med pekare lagras i ett arkiv, antingen med den överlagrade infogningsoperatorn eller med Serialize medlemsfunktionen, serialiseras varje CObject element i sin tur tillsammans med dess matrisindex.

Om du behöver en dump med enskilda CObject element i en matris måste du ange djupet för CDumpContext objektet till 1 eller större.

När ett CObArray objekt tas bort, eller när dess element tas bort, tas bara pekarna CObject bort, inte de objekt som de refererar till.

Anmärkning

Innan du använder en matris använder du SetSize för att fastställa dess storlek och allokera minne för den. Om du inte använder SetSizegör tillägg av element i matrisen att den ofta omallokeras och kopieras. Frekvent omallokering och kopiering är ineffektiva och kan fragmentera minnet.

Matrisklasshärledning liknar listhärledning. Mer information om härledning av en speciallistklass finns i artikeln Samlingar.

Anmärkning

Du måste använda IMPLEMENT_SERIAL makrot i implementeringen av din härledda klass om du tänker serialisera matrisen.

Arvshierarki

CObject

CObArray

Kravspecifikation

rubrik:afxcoll.h

`CObArray::Add`

Lägger till ett nytt element i slutet av en matris och utökar matrisen med 1.

INT_PTR Add(CObject* newElement);

Parameterar

newElement
Pekaren CObject som ska läggas till i den här matrisen.

Returvärde

Indexet för det tillagda elementet.

Anmärkningar

Om SetSize har använts med ett nGrowBy värde som är större än 1 kan extra minne allokeras. Den övre gränsen ökar dock bara med 1.

I följande tabell visas andra medlemsfunktioner som liknar CObArray::Add.

Klass	Medlemsfunktion
`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*);`

Exempel

Se CObList::CObList en lista över klassen CAge som används i alla samlingsexempel.

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

Resultatet från det här programmet är följande:

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

`CObArray::Append`

Anropa den här medlemsfunktionen för att lägga till innehållet i en annan matris i slutet av den angivna matrisen.

INT_PTR Append(const CObArray& src);

Parameterar

src
Källa för de element som ska läggas till i matrisen.

Returvärde

Indexet för det första bifogade elementet.

Anmärkningar

Matriserna måste vara av samma typ.

Om det behövs Append kan du allokera extra minne för att hantera de element som läggs till i matrisen.

I följande tabell visas andra medlemsfunktioner som liknar CObArray::Append.

Klass	Medlemsfunktion
`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);`

Exempel

Se CObList::CObList en lista över klassen CAge som används i alla samlingsexempel.

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`

Anropa den här medlemsfunktionen för att skriva över elementen i den angivna matrisen med elementen i en annan matris av samma typ.

void Copy(const CObArray& src);

Parameterar

src
Källa för de element som ska kopieras till matrisen.

Anmärkningar

Copy frigör inte minne. Om det behövs Copy kan du allokera extra minne för de element som kopieras till matrisen.

I följande tabell visas andra medlemsfunktioner som liknar CObArray::Copy.

Klass	Medlemsfunktion
`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);`

Exempel

Se CObList::CObList en lista över klassen CAge som används i alla samlingsexempel.

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`

Skapar en tom CObject pekarmatris.

CObArray();

Anmärkningar

Matrisen växer ett element i taget.

I följande tabell visas andra konstruktorer som liknar CObArray::CObArray.

Klass	Konstruktor
`CByteArray`	`CByteArray();`
`CDWordArray`	`CDWordArray();`
`CPtrArray`	`CPtrArray();`
`CStringArray`	`CStringArray();`
`CUIntArray`	`CUIntArray();`
`CWordArray`	`CWordArray();`

Exempel

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

`CObArray::ElementAt`

Returnerar en tillfällig referens till elementpekaren i matrisen.

CObject*& ElementAt(INT_PTR nIndex);

Parameterar

nIndex
Ett heltalsindex som är större än eller lika med 0 och mindre än eller lika med det värde som returneras av GetUpperBound.

Returvärde

En referens till en CObject pekare.

Anmärkningar

Den används för att implementera tilldelningsoperatorn på vänster sida för matriser. Det här är en avancerad funktion som endast ska användas för att implementera särskilda matrisoperatorer.

I följande tabell visas andra medlemsfunktioner som liknar CObArray::ElementAt.

Klass	Medlemsfunktion
`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);`

Exempel

Se exemplet för CObArray::GetSize.

`CObArray::FreeExtra`

Frigör extra minne som allokerades medan matrisen odlades.

void FreeExtra();

Anmärkningar

Den här funktionen påverkar inte matrisens storlek eller övre gräns.

I följande tabell visas andra medlemsfunktioner som liknar CObArray::FreeExtra.

Klass	Medlemsfunktion
`CByteArray`	`void FreeExtra();`
`CDWordArray`	`void FreeExtra();`
`CPtrArray`	`void FreeExtra();`
`CStringArray`	`void FreeExtra();`
`CUIntArray`	`void FreeExtra();`
`CWordArray`	`void FreeExtra();`

Exempel

Se exemplet för CObArray::GetData.

`CObArray::GetAt`

Returnerar matriselementet vid det angivna indexet.

CObject* GetAt(INT_PTR nIndex) const;

Parameterar

nIndex
Ett heltalsindex som är större än eller lika med 0 och mindre än eller lika med det värde som returneras av GetUpperBound.

Returvärde

Pekarelementet CObject för närvarande vid det här indexet.

Anmärkningar

Anmärkning

Om du skickar ett negativt värde eller ett värde som är större än det värde som returneras av GetUpperBound resulterar det i en misslyckad försäkran.

I följande tabell visas andra medlemsfunktioner som liknar CObArray::GetAt.

Klass	Medlemsfunktion
`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;`

Exempel

Se CObList::CObList en lista över klassen CAge som används i alla samlingsexempel.

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`

Returnerar antalet matriselement.

INT_PTR GetCount() const;

Returvärde

Antalet objekt i matrisen.

Anmärkningar

Anropa den här metoden för att hämta antalet element i matrisen. Eftersom index är nollbaserade är storleken 1 större än det största indexet.

I följande tabell visas andra medlemsfunktioner som liknar CObArray::GetCount.

Klass	Medlemsfunktion
`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;`

Exempel

Se CObList::CObList en lista över klassen CAge som används i alla samlingsexempel.

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`

Använd den här medlemsfunktionen för att få direkt åtkomst till elementen i matrisen.

const CObject** GetData() const;

CObject** GetData();

Returvärde

En pekare till matrisen med CObject pekare.

Anmärkningar

Om inga element är tillgängliga GetData returnerar ett NULL värde.

Även om direkt åtkomst till elementen i en matris kan hjälpa dig att arbeta snabbare bör du vara försiktig när du anropar GetData. Eventuella fel som du gör påverkar elementen i matrisen direkt.

I följande tabell visas andra medlemsfunktioner som liknar CObArray::GetData.

Klass	Medlemsfunktion
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();`

Exempel

Se CObList::CObList en lista över klassen CAge som används i alla samlingsexempel.

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`

Returnerar matrisens storlek.

INT_PTR GetSize() const;

Anmärkningar

Eftersom index är nollbaserade är storleken 1 större än det största indexet.

I följande tabell visas andra medlemsfunktioner som liknar CObArray::GetSize.

Klass	Medlemsfunktion
`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;`

Exempel

Se CObList::CObList en lista över klassen CAge som används i alla samlingsexempel.

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`

Returnerar den aktuella övre gränsen för den här matrisen.

INT_PTR GetUpperBound() const;

Returvärde

Indexet för den övre gränsen (nollbaserad).

Anmärkningar

Eftersom matrisindex är nollbaserade returnerar den här funktionen värdet 1 mindre än GetSize.

Villkoret GetUpperBound() = -1 anger att matrisen inte innehåller några element.

I följande tabell visas andra medlemsfunktioner som liknar CObArray::GetUpperBound.

Klass	Medlemsfunktion
`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;`

Exempel

Se CObList::CObList en lista över klassen CAge som används i alla samlingsexempel.

CObArray arr;

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

`CObArray::InsertAt`

Infogar ett element (eller alla element i en annan matris) vid ett angivet index.

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

void InsertAt(
    INT_PTR nStartIndex,
    CObArray* pNewArray);

Parameterar

nIndex
Ett heltalsindex som kan vara större än värdet som returneras av GetUpperBound.

newElement
Pekaren CObject som ska placeras i den här matrisen. Ett newElement värde NULL tillåts.

nCount
Antalet gånger som det här elementet ska infogas (standardvärdet är 1).

nStartIndex
Ett heltalsindex som kan vara större än värdet som returneras av GetUpperBound.

pNewArray
En annan matris som innehåller element som ska läggas till i den här matrisen.

Anmärkningar

Den första versionen av InsertAt infogar ett element (eller flera kopior av ett element) vid ett angivet index i en matris. I processen flyttas det upp (genom att öka indexet) det befintliga elementet i det här indexet, och det flyttar upp alla element ovanför det.

Den andra versionen infogar alla element från en annan CObArray samling, med början vid positionen nStartIndex .

Funktionen SetAt ersätter däremot ett angivet matriselement och flyttar inga element.

I följande tabell visas andra medlemsfunktioner som liknar CObArray::InsertAt.

Klass	Medlemsfunktion
`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*);`

Exempel

Se CObList::CObList en lista över klassen CAge som används i alla samlingsexempel.

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

Resultatet från det här programmet är följande:

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`

Avgör om matrisen är tom.

BOOL IsEmpty() const;

Returvärde

Nonzero om matrisen är tom; annars 0.

`CObArray::operator [ ]`

Dessa nedsänkta operatorer är ett bekvämt substitut för SetAt funktionerna och GetAt .

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

Anmärkningar

Den första operatorn, som anropas för matriser som inte constär , kan användas till höger (r-värde) eller till vänster (l-värde) för en tilldelningsinstruktor. Den andra, som kallas för const matriser, kan endast användas till höger.

Felsökningsversionen av biblioteket anger om den nedsänkta (antingen till vänster eller höger sida av en tilldelningsinstruktor) ligger utanför gränserna.

I följande tabell visas andra operatorer som liknar CObArray::operator [].

Klass	Operatör
`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;`

Exempel

Se CObList::CObList en lista över klassen CAge som används i alla samlingsexempel.

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`

Tar bort alla pekare från den här matrisen men tar inte bort objekten CObject .

void RemoveAll();

Anmärkningar

Om matrisen redan är tom fungerar funktionen fortfarande.

Funktionen RemoveAll frigör allt minne som används för pekarlagring.

I följande tabell visas andra medlemsfunktioner som liknar CObArray::RemoveAll.

Klass	Medlemsfunktion
`CByteArray`	`void RemoveAll();`
`CDWordArray`	`void RemoveAll();`
`CPtrArray`	`void RemoveAll();`
`CStringArray`	`void RemoveAll();`
`CUIntArray`	`void RemoveAll();`
`CWordArray`	`void RemoveAll();`

Exempel

Se CObList::CObList en lista över klassen CAge som används i alla samlingsexempel.

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`

Tar bort ett eller flera element som börjar vid ett angivet index i en matris.

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

Parameterar

nIndex
Ett heltalsindex som är större än eller lika med 0 och mindre än eller lika med det värde som returneras av GetUpperBound.

nCount
Antalet element som ska tas bort.

Anmärkningar

I processen flyttas alla element ovanför de borttagna elementen ned. Den minskar matrisens övre gräns men frigör inte minne.

Om du försöker ta bort fler element än vad som finns i matrisen ovanför borttagningspunkten, hävdar felsökningsversionen av biblioteket.

Funktionen RemoveAt tar bort pekaren CObject från matrisen, men den tar inte bort själva objektet.

I följande tabell visas andra medlemsfunktioner som liknar CObArray::RemoveAt.

Klass	Medlemsfunktion
`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);`

Exempel

Se CObList::CObList en lista över klassen CAge som används i alla samlingsexempel.

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

Resultatet från det här programmet är följande:

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

`CObArray::SetAt`

Anger matriselementet till det angivna indexet.

void SetAt(
    INT_PTR nIndex,
    CObject* newElement);

Parameterar

nIndex
Ett heltalsindex som är större än eller lika med 0 och mindre än eller lika med det värde som returneras av GetUpperBound.

newElement
Objektpekaren som ska infogas i den här matrisen. Ett NULL värde tillåts.

Anmärkningar

SetAt kommer inte att leda till att matrisen växer. Använd SetAtGrow om du vill att matrisen ska växa automatiskt.

Kontrollera att indexvärdet representerar en giltig position i matrisen. Om det är utanför gränserna, hävdar felsökningsversionen av biblioteket.

I följande tabell visas andra medlemsfunktioner som liknar CObArray::SetAt.

Klass	Medlemsfunktion
`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);`

Exempel

Se CObList::CObList en lista över klassen CAge som används i alla samlingsexempel.

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

Resultatet från det här programmet är följande:

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

`CObArray::SetAtGrow`

Anger matriselementet till det angivna indexet.

void SetAtGrow(
    INT_PTR nIndex,
    CObject* newElement);

Parameterar

nIndex
Ett heltalsindex som är större än eller lika med 0.

newElement
Objektpekaren som ska läggas till i den här matrisen. Ett NULL värde tillåts.

Anmärkningar

Matrisen växer automatiskt om det behövs (d.v.s. den övre gränsen justeras för att passa det nya elementet).

I följande tabell visas andra medlemsfunktioner som liknar CObArray::SetAtGrow.

Klass	Medlemsfunktion
`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*);`

Exempel

Se CObList::CObList en lista över klassen CAge som används i alla samlingsexempel.

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

Resultatet från det här programmet är följande:

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`

Anger storleken på en tom eller befintlig matris. allokerar minne om det behövs.

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

Parameterar

nNewSize
Den nya matrisstorleken (antal element). Måste vara större än eller lika med 0.

nGrowBy
Det minsta antalet elementplatser som ska allokeras om en storleksökning krävs.

Anmärkningar

Om den nya storleken är mindre än den gamla storleken trunkeras matrisen och allt oanvänt minne frigörs. För effektivitet anropar du SetSize för att ange matrisens storlek innan du använder den. Detta förhindrar behovet av att omallokera och kopiera matrisen varje gång ett objekt läggs till.

Parametern nGrowBy påverkar intern minnesallokering medan matrisen växer. Dess användning påverkar aldrig matrisstorleken som rapporterats av GetSize och GetUpperBound.

Om matrisens storlek har ökat är alla nyligen allokerade CObject * pekare inställda på NULL.

I följande tabell visas andra medlemsfunktioner som liknar CObArray::SetSize.

Klass	Medlemsfunktion
`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*);`

Exempel

Se exemplet för CObArray::GetData.

Se även

CObject klass
hierarkidiagram
CStringArray klass
CPtrArray klass
CByteArray klass
CWordArray klass
CDWordArray klass

Feedback

Var den här sidan till hjälp?

Last updated on 2025-11-07

Dela via

CObArray-klass

Syntax

Medlemmar

Offentliga konstruktorer

Offentliga metoder

Offentliga operatörer

Anmärkningar

Arvshierarki

Kravspecifikation

CObArray::Add

Parameterar

Returvärde

Anmärkningar

Exempel

CObArray::Append

Parameterar

Returvärde

Anmärkningar

Exempel

CObArray::Copy

Parameterar

Anmärkningar

Exempel

CObArray::CObArray

Anmärkningar

Exempel

CObArray::ElementAt

Parameterar

Returvärde

Anmärkningar

Exempel

CObArray::FreeExtra

Anmärkningar

Exempel

CObArray::GetAt

Parameterar

Returvärde

Anmärkningar

Exempel

CObArray::GetCount

Returvärde

Anmärkningar

Exempel

CObArray::GetData

Returvärde

Anmärkningar

Exempel

CObArray::GetSize

Anmärkningar

Exempel

CObArray::GetUpperBound

Returvärde

Anmärkningar

Exempel

CObArray::InsertAt

Parameterar

Anmärkningar

Exempel

CObArray::IsEmpty

Returvärde

CObArray::operator [ ]

Anmärkningar

Exempel

CObArray::RemoveAll

Anmärkningar

Exempel

CObArray::RemoveAt

Parameterar

Anmärkningar

Exempel

CObArray::SetAt

Parameterar

Anmärkningar

Exempel

CObArray::SetAtGrow

Parameterar

Anmärkningar

Exempel

CObArray::SetSize

`CObArray`-klass

`CObArray::Add`

`CObArray::Append`

`CObArray::Copy`

`CObArray::CObArray`

`CObArray::ElementAt`

`CObArray::FreeExtra`

`CObArray::GetAt`

`CObArray::GetCount`

`CObArray::GetData`

`CObArray::GetSize`

`CObArray::GetUpperBound`

`CObArray::InsertAt`

`CObArray::IsEmpty`

`CObArray::operator [ ]`

`CObArray::RemoveAll`

`CObArray::RemoveAt`

`CObArray::SetAt`

`CObArray::SetAtGrow`

`CObArray::SetSize`