`CObArray` Třída

Článek
10/12/2023

Podporuje pole CObject ukazatelů.

Syntaxe

class CObArray : public CObject

Členové

Veřejné konstruktory

Název	Popis
`CObArray::CObArray`	Vytvoří prázdné pole pro `CObject` ukazatele.

Veřejné metody

Název	Popis
`CObArray::Add`	Přidá prvek na konec pole; v případě potřeby pole zvětšuje.
`CObArray::Append`	Připojí k matici další pole; v případě potřeby pole zvětšuje.
`CObArray::Copy`	Zkopíruje další pole do pole; v případě potřeby pole zvětšuje.
`CObArray::ElementAt`	Vrátí dočasný odkaz na ukazatel prvku v rámci pole.
`CObArray::FreeExtra`	Uvolní veškerou nevyužitou paměť nad aktuální horní mez.
`CObArray::GetAt`	Vrátí hodnotu v daném indexu.
`CObArray::GetCount`	Získá počet prvků v tomto poli.
`CObArray::GetData`	Umožňuje přístup k prvkům v poli. Může to být `NULL`.
`CObArray::GetSize`	Získá počet prvků v tomto poli.
`CObArray::GetUpperBound`	Vrátí největší platný index.
`CObArray::InsertAt`	Vloží prvek (nebo všechny prvky v jiném poli) do zadaného indexu.
`CObArray::IsEmpty`	Určuje, zda je pole prázdné.
`CObArray::RemoveAll`	Odebere všechny prvky z tohoto pole.
`CObArray::RemoveAt`	Odebere prvek v určitém indexu.
`CObArray::SetAt`	Nastaví hodnotu pro daný index; pole nelze zvětšit.
`CObArray::SetAtGrow`	Nastaví hodnotu pro daný index; v případě potřeby pole zvětšuje.
`CObArray::SetSize`	Nastaví počet prvků, které mají být obsaženy v tomto poli.

Veřejné operátory

Název	Popis
`CObArray::operator []`	Nastaví nebo získá prvek v zadaném indexu.

Poznámky

Tato pole objektů jsou podobná polím jazyka C, ale podle potřeby se můžou dynamicky zmenšovat a zvětšovat.

Indexy pole vždy začínají na pozici 0. Můžete se rozhodnout, jestli chcete opravit horní mez, nebo povolit rozbalení pole, když přidáte prvky za aktuální vazbu. Paměť je přidělována souvisle hornímu hranici, i když jsou NULLněkteré prvky .

V systému Win32 je velikost objektu omezena pouze na dostupnou CObArray paměť.

Stejně jako u pole jazyka C je doba přístupu indexovaného CObArray prvku konstantní a je nezávislá na velikosti pole.

CObArrayIMPLEMENT_SERIAL obsahuje makro pro podporu serializace a dumpingu jeho prvků. Pokud je pole CObject ukazatelů uloženo do archivu, buď s přetíženým operátorem vložení, nebo s Serialize členovou funkcí, je každý CObject prvek serializován společně s indexem pole.

Pokud potřebujete výpis jednotlivých CObject prvků v poli, je nutné nastavit hloubku objektu CDumpContext na hodnotu 1 nebo vyšší.

Při odstranění objektu CObArray nebo při odebrání jeho prvků se odeberou pouze CObject ukazatele, nikoli objekty, na které odkazují.

Poznámka:

Před použitím pole použijte SetSize k vytvoření jeho velikosti a přidělení paměti. Pokud nepoužíváte SetSize, přidání prvků do pole způsobí, že se často relokuje a kopíruje. Časté relokace a kopírování jsou neefektivní a můžou fragmentovat paměť.

Odvození třídy pole je podobné odvození seznamu. Podrobnosti o odvození třídy seznamu pro zvláštní účely naleznete v článku Kolekce.

Poznámka:

Chcete-li serializovat pole, je nutné použít makro IMPLEMENT_SERIAL v implementaci odvozené třídy.

Hierarchie dědičnosti

CObject

CObArray

Požadavky

Záhlaví: afxcoll.h

`CObArray::Add`

Přidá nový prvek na konec pole a zvětšuje matici o 1.

INT_PTR Add(CObject* newElement);

Parametry

newElement
Ukazatel CObject , který se má přidat do tohoto pole.

Návratová hodnota

Index přidaného prvku.

Poznámky

Pokud SetSize byla použita s nGrowBy hodnotou větší než 1, může být přidělena dodatečná paměť. Horní mez se však zvýší pouze o 1.

V následující tabulce jsou uvedeny další členské funkce, které jsou podobné CObArray::Add.

Třída	Členská funkce
`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*);`

Příklad

Podívejte CObList::CObList se na výpis CAge třídy použité ve všech příkladech kolekce.

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

Výsledky z tohoto programu jsou následující:

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

`CObArray::Append`

Voláním této členské funkce přidáte obsah jiného pole na konec daného pole.

INT_PTR Append(const CObArray& src);

Parametry

src
Zdroj prvků, které mají být připojeny k poli.

Návratová hodnota

Index prvního připojeného prvku.

Poznámky

Matice musí být stejného typu.

V případě potřeby Append může přidělit dodatečnou paměť pro přizpůsobení prvků připojených k poli.

V následující tabulce jsou uvedeny další členské funkce, které jsou podobné CObArray::Append.

Třída	Členská funkce
`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);`

Příklad

Podívejte CObList::CObList se na výpis CAge třídy použité ve všech příkladech kolekce.

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`

Voláním této členské funkce přepíšete prvky daného pole prvky jiného pole stejného typu.

void Copy(const CObArray& src);

Parametry

src
Zdroj elementů, které se mají zkopírovat do pole.

Poznámky

Copy nezbídní paměť. V případě potřeby může přidělit dodatečnou paměť pro Copy přizpůsobení prvků zkopírovaných do pole.

V následující tabulce jsou uvedeny další členské funkce, které jsou podobné CObArray::Copy.

Třída	Členská funkce
`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);`

Příklad

Podívejte CObList::CObList se na výpis CAge třídy použité ve všech příkladech kolekce.

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`

Vytvoří prázdné CObject pole ukazatele.

CObArray();

Poznámky

Pole najednou roste o jeden prvek.

Následující tabulka ukazuje další konstruktory, které jsou podobné CObArray::CObArray.

Třída	Konstruktor
`CByteArray`	`CByteArray();`
`CDWordArray`	`CDWordArray();`
`CPtrArray`	`CPtrArray();`
`CStringArray`	`CStringArray();`
`CUIntArray`	`CUIntArray();`
`CWordArray`	`CWordArray();`

Příklad

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

`CObArray::ElementAt`

Vrátí dočasný odkaz na ukazatel prvku v rámci pole.

CObject*& ElementAt(INT_PTR nIndex);

Parametry

nIndex
Celočíselná hodnota, která je větší nebo rovna 0 a menší nebo rovna hodnotě GetUpperBoundvrácené hodnotou .

Návratová hodnota

Odkaz na CObject ukazatel.

Poznámky

Slouží k implementaci operátoru přiřazení na levé straně pro pole. Jedná se o pokročilou funkci, která by se měla použít pouze k implementaci speciálních maticových operátorů.

V následující tabulce jsou uvedeny další členské funkce, které jsou podobné CObArray::ElementAt.

Třída	Členská funkce
`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);`

Příklad

Podívejte se na příklad pro CObArray::GetSize.

`CObArray::FreeExtra`

Uvolní veškerou nadbytečnou paměť přidělenou při matici.

void FreeExtra();

Poznámky

Tato funkce nemá žádný vliv na velikost nebo horní mez pole.

V následující tabulce jsou uvedeny další členské funkce, které jsou podobné CObArray::FreeExtra.

Třída	Členská funkce
`CByteArray`	`void FreeExtra();`
`CDWordArray`	`void FreeExtra();`
`CPtrArray`	`void FreeExtra();`
`CStringArray`	`void FreeExtra();`
`CUIntArray`	`void FreeExtra();`
`CWordArray`	`void FreeExtra();`

Příklad

Podívejte se na příklad pro CObArray::GetData.

`CObArray::GetAt`

Vrátí prvek pole v zadaném indexu.

CObject* GetAt(INT_PTR nIndex) const;

Parametry

nIndex
Celočíselná hodnota, která je větší nebo rovna 0 a menší nebo rovna hodnotě GetUpperBoundvrácené hodnotou .

Návratová hodnota

Prvek CObject ukazatele aktuálně v tomto indexu.

Poznámky

Poznámka:

Předání záporné hodnoty nebo hodnoty větší než hodnota vrácená GetUpperBound výsledkem bude neúspěšný kontrolní výraz.

V následující tabulce jsou uvedeny další členské funkce, které jsou podobné CObArray::GetAt.

Třída	Členská funkce
`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;`

Příklad

Podívejte CObList::CObList se na výpis CAge třídy použité ve všech příkladech kolekce.

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`

Vrátí počet prvků pole.

INT_PTR GetCount() const;

Návratová hodnota

Počet položek v poli

Poznámky

Voláním této metody načtěte počet prvků v poli. Vzhledem k tomu, že indexy jsou založené na nule, je velikost 1 větší než největší index.

V následující tabulce jsou uvedeny další členské funkce, které jsou podobné CObArray::GetCount.

Třída	Členská funkce
`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;`

Příklad

Podívejte CObList::CObList se na výpis CAge třídy použité ve všech příkladech kolekce.

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`

Pomocí této členské funkce získáte přímý přístup k prvkům v poli.

const CObject** GetData() const;

CObject** GetData();

Návratová hodnota

Ukazatel na pole CObject ukazatelů.

Poznámky

Pokud nejsou k dispozici žádné prvky, GetData vrátí NULL hodnotu.

I když přímý přístup k prvkům pole vám může pomoct rychleji pracovat, při volání GetDatabuďte opatrní. Všechny chyby, které uděláte přímo, ovlivní prvky pole.

V následující tabulce jsou uvedeny další členské funkce, které jsou podobné CObArray::GetData.

Třída	Členská funkce
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();`

Příklad

Podívejte CObList::CObList se na výpis CAge třídy použité ve všech příkladech kolekce.

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`

Vrátí velikost pole.

INT_PTR GetSize() const;

Poznámky

Vzhledem k tomu, že indexy jsou založené na nule, je velikost větší než největší index.

V následující tabulce jsou uvedeny další členské funkce, které jsou podobné CObArray::GetSize.

Třída	Členská funkce
`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;`

Příklad

Podívejte CObList::CObList se na výpis CAge třídy použité ve všech příkladech kolekce.

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`

Vrátí aktuální horní mez tohoto pole.

INT_PTR GetUpperBound() const;

Návratová hodnota

Index horní hranice (založený na nule).

Poznámky

Vzhledem k tomu, že indexy pole jsou založené na nule, vrátí tato funkce hodnotu 1 menší než GetSize.

Podmínka GetUpperBound() = -1 označuje, že pole neobsahuje žádné prvky.

V následující tabulce jsou uvedeny další členské funkce, které jsou podobné CObArray::GetUpperBound.

Třída	Členská funkce
`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;`

Příklad

Podívejte CObList::CObList se na výpis CAge třídy použité ve všech příkladech kolekce.

CObArray arr;

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

`CObArray::InsertAt`

Vloží prvek (nebo všechny prvky v jiném poli) do zadaného indexu.

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

void InsertAt(
    INT_PTR nStartIndex,
    CObArray* pNewArray);

Parametry

nIndex
Celočíselné indexy, které mohou být větší než hodnota vrácená GetUpperBoundhodnotou .

newElement
Ukazatel CObject , který se má umístit do tohoto pole. NULL Hodnota newElement je povolená.

nCount
Počet vložení tohoto prvku (výchozí hodnota je 1).

nStartIndex
Celočíselné indexy, které mohou být větší než hodnota vrácená GetUpperBoundhodnotou .

pNewArray
Další pole, které obsahuje prvky, které mají být přidány do tohoto pole.

Poznámky

První verze InsertAt vloží jeden prvek (nebo více kopií elementu) do zadaného indexu v poli. V procesu se posune nahoru (zvýšením indexu) existující prvek v tomto indexu a posune všechny prvky nad ním.

Druhá verze vloží všechny prvky z jiné CObArray kolekce počínaje nStartIndex pozicí.

Funkce SetAt naproti tomu nahradí jeden zadaný prvek pole a nepřesouvají žádné prvky.

V následující tabulce jsou uvedeny další členské funkce, které jsou podobné CObArray::InsertAt.

Třída	Členská funkce
`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*);`

Příklad

Podívejte CObList::CObList se na výpis CAge třídy použité ve všech příkladech kolekce.

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

Výsledky z tohoto programu jsou následující:

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`

Určuje, zda je pole prázdné.

BOOL IsEmpty() const;

Návratová hodnota

Nenulové, pokud je pole prázdné; jinak 0.

`CObArray::operator [ ]`

Tyto operátory dolního indexu představují pohodlnou náhradu SetAt za funkce a GetAt funkce.

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

Poznámky

První operátor, který volá pole, která nejsou const, se může použít na pravé straně (r-hodnota) nebo vlevo (l-hodnota) příkazu přiřazení. Druhý, volaný pro const pole, lze použít pouze na pravé straně.

Ladicí verze knihovny se používá, pokud je dolní index (na levé nebo pravé straně příkazu přiřazení) mimo hranice.

Následující tabulka ukazuje další operátory, které jsou podobné CObArray::operator [].

Třída	Operátor
`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;`

Příklad

Podívejte CObList::CObList se na výpis CAge třídy použité ve všech příkladech kolekce.

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`

Odebere všechny ukazatele z tohoto pole, ale ve skutečnosti neodstraní CObject objekty.

void RemoveAll();

Poznámky

Pokud je pole již prázdné, funkce stále funguje.

Funkce RemoveAll uvolní veškerou paměť použitou pro ukládání ukazatelů.

V následující tabulce jsou uvedeny další členské funkce, které jsou podobné CObArray::RemoveAll.

Třída	Členská funkce
`CByteArray`	`void RemoveAll();`
`CDWordArray`	`void RemoveAll();`
`CPtrArray`	`void RemoveAll();`
`CStringArray`	`void RemoveAll();`
`CUIntArray`	`void RemoveAll();`
`CWordArray`	`void RemoveAll();`

Příklad

Podívejte CObList::CObList se na výpis CAge třídy použité ve všech příkladech kolekce.

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`

Odebere jeden nebo více prvků počínaje zadaným indexem v poli.

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

Parametry

nIndex
Celočíselná hodnota, která je větší nebo rovna 0 a menší nebo rovna hodnotě GetUpperBoundvrácené hodnotou .

nCount
Počet prvků, které chcete odebrat.

Poznámky

V procesu se posune dolů všechny prvky nad odebranými elementy. Dekrementuje horní mez pole, ale nezbavuje paměť.

Pokud se pokusíte odebrat více prvků, než je obsaženo v poli nad bodem odebrání, pak ladicí verze knihovny asserts.

Funkce RemoveAt odebere CObject ukazatel z pole, ale neodstraní samotný objekt.

V následující tabulce jsou uvedeny další členské funkce, které jsou podobné CObArray::RemoveAt.

Třída	Členská funkce
`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);`

Příklad

Podívejte CObList::CObList se na výpis CAge třídy použité ve všech příkladech kolekce.

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

Výsledky z tohoto programu jsou následující:

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

`CObArray::SetAt`

Nastaví prvek pole v zadaném indexu.

void SetAt(
    INT_PTR nIndex,
    CObject* newElement);

Parametry

nIndex
Celočíselná hodnota, která je větší nebo rovna 0 a menší nebo rovna hodnotě GetUpperBoundvrácené hodnotou .

newElement
Ukazatel objektu, který má být vložen do tohoto pole. Je povolená NULL hodnota.

Poznámky

SetAt nezpůsobí zvětšení pole. Použijte SetAtGrow , pokud chcete, aby se pole automaticky zvětšovat.

Ujistěte se, že hodnota indexu představuje platnou pozici v poli. Pokud je mimo hranice, pak ladicí verze knihovny asserts.

V následující tabulce jsou uvedeny další členské funkce, které jsou podobné CObArray::SetAt.

Třída	Členská funkce
`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);`

Příklad

Podívejte CObList::CObList se na výpis CAge třídy použité ve všech příkladech kolekce.

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

Výsledky z tohoto programu jsou následující:

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

`CObArray::SetAtGrow`

Nastaví prvek pole v zadaném indexu.

void SetAtGrow(
    INT_PTR nIndex,
    CObject* newElement);

Parametry

nIndex
Celočíselná hodnota, která je větší nebo rovna 0.

newElement
Ukazatel objektu, který se má přidat do tohoto pole. Je povolená NULL hodnota.

Poznámky

Pole se v případě potřeby automaticky rozrůstá (to znamená, že horní mez se upraví tak, aby vyhovovala novému prvku).

V následující tabulce jsou uvedeny další členské funkce, které jsou podobné CObArray::SetAtGrow.

Třída	Členská funkce
`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*);`

Příklad

Podívejte CObList::CObList se na výpis CAge třídy použité ve všech příkladech kolekce.

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

Výsledky z tohoto programu jsou následující:

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`

Vytvoří velikost prázdného nebo existujícího pole; v případě potřeby přidělí paměť.

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

Parametry

nNewSize
Nová velikost pole (počet prvků) Musí být větší než nebo rovno 0.

nGrowBy
Minimální počet slotů prvků, které se mají přidělit, pokud je potřeba zvětšit velikost.

Poznámky

Pokud je nová velikost menší než stará velikost, pole se zkrátí a uvolní se všechna nevyužitá paměť. Z důvodu efektivity zavolejte SetSize , abyste před použitím nastavili velikost pole. Zabráníte tak tomu, aby bylo nutné pole při každém přidání položky převést do skutečného umístění a zkopírovat ho.

Parametr nGrowBy má vliv na přidělení interní paměti, zatímco pole roste. Jeho použití nikdy neovlivní velikost pole, jak GetSize je hlášeno a GetUpperBound.

Pokud se velikost pole zvětšila, nastaví se všechny nově přidělené CObject * ukazatele na NULLhodnotu .

V následující tabulce jsou uvedeny další členské funkce, které jsou podobné CObArray::SetSize.

Třída	Členská funkce
`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*);`

Příklad

Podívejte se na příklad pro CObArray::GetData.

Viz také

CObject Třída
Graf hierarchie
CStringArray Třída
CPtrArray Třída
CByteArray Třída
CWordArray Třída
CDWordArray Třída

Sdílet prostřednictvím

CObArray Třída

Syntaxe

Členové

Veřejné konstruktory

Veřejné metody

Veřejné operátory

Poznámky

Hierarchie dědičnosti

Požadavky

CObArray::Add

Parametry

Návratová hodnota

Poznámky

Příklad

CObArray::Append

Parametry

Návratová hodnota

Poznámky

Příklad

CObArray::Copy

Parametry

Poznámky

Příklad

CObArray::CObArray

Poznámky

Příklad

CObArray::ElementAt

Parametry

Návratová hodnota

Poznámky

Příklad

CObArray::FreeExtra

Poznámky

Příklad

CObArray::GetAt

Parametry

Návratová hodnota

Poznámky

Příklad

CObArray::GetCount

Návratová hodnota

Poznámky

Příklad

CObArray::GetData

Návratová hodnota

Poznámky

Příklad

CObArray::GetSize

Poznámky

Příklad

CObArray::GetUpperBound

Návratová hodnota

Poznámky

Příklad

CObArray::InsertAt

Parametry

Poznámky

Příklad

CObArray::IsEmpty

Návratová hodnota

CObArray::operator [ ]

Poznámky

Příklad

CObArray::RemoveAll

Poznámky

Příklad

CObArray::RemoveAt

Parametry

Poznámky

Příklad

CObArray::SetAt

Parametry

Poznámky

Příklad

CObArray::SetAtGrow

Parametry

Poznámky

Příklad

CObArray::SetSize

`CObArray` Třída

`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`