CObArray osztály

Támogatja a CObject mutatótömböket.

Szemantika

class CObArray : public CObject

Tagok

Nyilvános konstruktorok

Név	Leírás
CObArray::CObArray	Üres tömböt hoz létre a mutatók számára CObject .

Nyilvános metódusok

Név	Leírás
CObArray::Add	Hozzáad egy elemet a tömb végéhez; szükség esetén növeli a tömböt.
CObArray::Append	Egy másik tömb hozzáfűzése a tömbhöz; szükség esetén növeli a tömböt.
CObArray::Copy	Másik tömb másolása a tömbbe; szükség esetén növeli a tömböt.
CObArray::ElementAt	A tömbön belüli elemmutatóra mutató ideiglenes hivatkozást ad vissza.
CObArray::FreeExtra	Felszabadítja az összes fel nem használt memóriát az aktuális felső határ felett.
CObArray::GetAt	Egy adott index értékét adja vissza.
CObArray::GetCount	Lekéri a tömb elemeinek számát.
CObArray::GetData	Lehetővé teszi a tömb elemeinek elérését. Lehet NULL.
CObArray::GetSize	Lekéri a tömb elemeinek számát.
CObArray::GetUpperBound	A legnagyobb érvényes indexet adja vissza.
CObArray::InsertAt	Egy elemet (vagy egy másik tömb összes elemét) szúr be egy adott indexbe.
CObArray::IsEmpty	Meghatározza, hogy a tömb üres-e.
CObArray::RemoveAll	Eltávolítja az összes elemet ebből a tömbből.
CObArray::RemoveAt	Eltávolít egy elemet egy adott indexből.
CObArray::SetAt	Egy adott index értékét állítja be; tömb nem növekedhet.
CObArray::SetAtGrow	Egy adott index értékét állítja be; szükség esetén növeli a tömböt.
CObArray::SetSize	Beállítja a tömbben található elemek számát.

Nyilvános operátorok

Név	Leírás
CObArray::operator []	Beállítja vagy lekéri az elemet a megadott indexen.

Megjegyzések

Ezek az objektumtömbök hasonlóak a C tömbökhöz, de szükség szerint dinamikusan zsugorodhatnak és növekedhetnek.

A tömbindexek mindig a 0. pozícióban kezdődnek. Eldöntheti, hogy kijavítja-e a felső határt, vagy engedélyezi a tömb kibontásának engedélyezését, amikor az aktuális kötésen felüli elemeket ad hozzá. A rendszer a memóriát egyrészről a felső határhoz rendeli, még akkor is, ha egyes elemek vannak NULL.

A Win32 alatt az CObArray objektum mérete csak a rendelkezésre álló memóriára korlátozódik.

A C tömbhöz hasonlóan az indexelt elemek hozzáférési ideje CObArray állandó, és független a tömb méretétől.

CObArray a makrót beépíti az IMPLEMENT_SERIAL elemek szerializálásának és memóriaképének támogatására. Ha a kurzorok tömbje CObject egy archívumban van tárolva, akár a túlterhelt beszúrási operátorral, akár a Serialize tagfüggvénnyel, az egyes CObject elemek egymás után szerializálva lesznek a tömbindexével együtt.

Ha egy tömb egyes CObject elemeiből álló memóriaképre van szüksége, az objektum mélységét CDumpContext 1 vagy nagyobbra kell állítania.

CObArray Egy objektum törlésekor vagy elemeinek eltávolításakor a rendszer csak a CObject mutatókat távolítja el, a hivatkozott objektumokat nem.

Megjegyzés:

A tömb használata előtt állítsa SetSize be a méretét, és foglaljon le memóriát. Ha nem használ SetSizeelemeket a tömbhöz, az gyakran újraelosztást és másolást okoz. A gyakori újratelepítés és másolás nem hatékony, és töredezett memóriát okozhat.

A tömbosztály származtatása hasonló a lista származtatásához. A speciális célú listaosztály származtatásával kapcsolatos részletekért tekintse meg a Gyűjtemények című cikket.

Megjegyzés:

A IMPLEMENT_SERIAL makrót a származtatott osztály implementációjában kell használnia, ha szerializálni szeretné a tömböt.

Öröklési hierarchia

CObject

CObArray

Követelmények

fejléc:afxcoll.h

CObArray::Add

Új elemet ad hozzá a tömb végéhez, és 1-gyel növeli a tömböt.

INT_PTR Add(CObject* newElement);

Paraméterek

newElement
A CObject tömbhöz hozzáadni kívánt mutató.

Visszaadott érték

A hozzáadott elem indexe.

Megjegyzések

Ha SetSize 1-nél nagyobb értékkel használták nGrowBy , akkor további memória foglalható le. A felső határ azonban csak 1-sel nő.

Az alábbi táblázat a többi tagfüggvényt mutatja be, amelyek hasonlóak a következőhöz CObArray::Add:

Osztály	Tagfüggvény
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élda

Tekintse meg CObList::CObList az CAge összes gyűjtemény-példában használt osztály listáját.

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      

A program eredményei a következők:

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

CObArray::Append

Ennek a tagfüggvénynek a meghívásával adja hozzá egy másik tömb tartalmát az adott tömb végéhez.

INT_PTR Append(const CObArray& src);

Paraméterek

src
A tömbhöz fűzendő elemek forrása.

Visszaadott érték

Az első hozzáfűzött elem indexe.

Megjegyzések

A tömböknek azonos típusúnak kell lenniük.

Szükség esetén Append további memóriát is lefoglalhat a tömbhöz fűzött elemek elhelyezéséhez.

Az alábbi táblázat a többi tagfüggvényt mutatja be, amelyek hasonlóak a következőhöz CObArray::Append:

Osztály	Tagfüggvény
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élda

Tekintse meg CObList::CObList az CAge összes gyűjtemény-példában használt osztály listáját.

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

Ennek a tagfüggvénynek a meghívásával felülírhatja az adott tömb elemeit egy másik, azonos típusú tömb elemeivel.

void Copy(const CObArray& src);

Paraméterek

src
A tömbbe másolandó elemek forrása.

Megjegyzések

Copy nem szabadít fel memóriát. Szükség esetén Copy további memóriát is lefoglalhat a tömbbe másolt elemek elhelyezéséhez.

Az alábbi táblázat a többi tagfüggvényt mutatja be, amelyek hasonlóak a következőhöz CObArray::Copy:

Osztály	Tagfüggvény
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élda

Tekintse meg CObList::CObList az CAge összes gyűjtemény-példában használt osztály listáját.

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

Üres CObject mutatótömböt hoz létre.

CObArray();

Megjegyzések

A tömb egyszerre egy elemet növeszt.

Az alábbi táblázat a hasonló konstruktorokat CObArray::CObArraymutatja be.

Osztály	Konstruktor
CByteArray	CByteArray();
CDWordArray	CDWordArray();
CPtrArray	CPtrArray();
CStringArray	CStringArray();
CUIntArray	CUIntArray();
CWordArray	CWordArray();

példa

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

CObArray::ElementAt

A tömbön belüli elemmutatóra mutató ideiglenes hivatkozást ad vissza.

CObject*& ElementAt(INT_PTR nIndex);

Paraméterek

nIndex
0-nál nagyobb vagy egyenlő egész számindex, amely kisebb, mint a visszaadott GetUpperBoundérték.

Visszaadott érték

Hivatkozás egy mutatóra CObject .

Megjegyzések

A tömbök bal oldali hozzárendelési operátorának implementálására szolgál. Ez egy speciális függvény, amely csak speciális tömboperátorok implementálásához használható.

Az alábbi táblázat a többi tagfüggvényt mutatja be, amelyek hasonlóak a következőhöz CObArray::ElementAt:

Osztály	Tagfüggvény
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élda

Lásd a példát a CObArray::GetSize.

CObArray::FreeExtra

Felszabadítja a tömb termesztése során lefoglalt további memóriát.

void FreeExtra();

Megjegyzések

Ez a függvény nincs hatással a tömb méretére vagy felső határára.

Az alábbi táblázat a többi tagfüggvényt mutatja be, amelyek hasonlóak a következőhöz CObArray::FreeExtra:

Osztály	Tagfüggvény
CByteArray	void FreeExtra();
CDWordArray	void FreeExtra();
CPtrArray	void FreeExtra();
CStringArray	void FreeExtra();
CUIntArray	void FreeExtra();
CWordArray	void FreeExtra();

példa

Lásd a példát a CObArray::GetData.

CObArray::GetAt

A megadott index tömbelemét adja vissza.

CObject* GetAt(INT_PTR nIndex) const;

Paraméterek

nIndex
0-nál nagyobb vagy egyenlő egész számindex, amely kisebb, mint a visszaadott GetUpperBoundérték.

Visszaadott érték

A CObject mutatóelem jelenleg ezen az indexen.

Megjegyzések

Megjegyzés:

Ha egy negatív vagy a visszaadott értéknél nagyobb értéket ad GetUpperBound át, az hibás állítást eredményez.

Az alábbi táblázat a többi tagfüggvényt mutatja be, amelyek hasonlóak a következőhöz CObArray::GetAt:

Osztály	Tagfüggvény
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élda

Tekintse meg CObList::CObList az CAge összes gyűjtemény-példában használt osztály listáját.

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

A tömbelemek számát adja vissza.

INT_PTR GetCount() const;

Visszaadott érték

A tömb elemeinek száma.

Megjegyzések

Hívja meg ezt a metódust a tömb elemeinek számának lekéréséhez. Mivel az indexek nulla alapúak, a méret 1 nagyobb, mint a legnagyobb index.

Az alábbi táblázat a többi tagfüggvényt mutatja be, amelyek hasonlóak a következőhöz CObArray::GetCount:

Osztály	Tagfüggvény
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élda

Tekintse meg CObList::CObList az CAge összes gyűjtemény-példában használt osztály listáját.

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

Ezzel a tagfüggvénysel közvetlen hozzáférést kaphat a tömb elemeihez.

const CObject** GetData() const;

CObject** GetData();

Visszaadott érték

Mutató a mutatótömbhöz CObject .

Megjegyzések

Ha nincsenek elérhető elemek, GetData egy NULL értéket ad vissza.

Bár a tömb elemeihez való közvetlen hozzáférés segíthet a gyorsabb munkában, a híváskor GetDatakörültekintően járjon el; az esetleges hibák közvetlenül befolyásolják a tömb elemeit.

Az alábbi táblázat a többi tagfüggvényt mutatja be, amelyek hasonlóak a következőhöz CObArray::GetData:

Osztály	Tagfüggvény
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élda

Tekintse meg CObList::CObList az CAge összes gyűjtemény-példában használt osztály listáját.

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

A tömb méretét adja vissza.

INT_PTR GetSize() const;

Megjegyzések

Mivel az indexek nulla alapúak, a méret 1 nagyobb, mint a legnagyobb index.

Az alábbi táblázat a többi tagfüggvényt mutatja be, amelyek hasonlóak a következőhöz CObArray::GetSize:

Osztály	Tagfüggvény
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élda

Tekintse meg CObList::CObList az CAge összes gyűjtemény-példában használt osztály listáját.

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

A tömb aktuális felső határát adja vissza.

INT_PTR GetUpperBound() const;

Visszaadott érték

A felső kötött (nulla alapú) indexe.

Megjegyzések

Mivel a tömbindexek nulla alapúak, ez a függvény 1-nél GetSizekisebb értéket ad vissza.

A feltétel GetUpperBound() = -1 azt jelzi, hogy a tömb nem tartalmaz elemeket.

Az alábbi táblázat a többi tagfüggvényt mutatja be, amelyek hasonlóak a következőhöz CObArray::GetUpperBound:

Osztály	Tagfüggvény
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élda

Tekintse meg CObList::CObList az CAge összes gyűjtemény-példában használt osztály listáját.

CObArray arr;

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

CObArray::InsertAt

Egy elemet (vagy egy másik tömb összes elemét) szúr be egy adott indexbe.

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

void InsertAt(
    INT_PTR nStartIndex,
    CObArray* pNewArray);

Paraméterek

nIndex
Egy egész szám index, amely nagyobb lehet, mint a visszaadott GetUpperBoundérték.

newElement
A CObject tömbbe helyezendő mutató. Egy newElement érték NULL engedélyezett.

nCount
Az elem beszúrásának száma (alapértelmezés szerint 1).

nStartIndex
Egy egész szám index, amely nagyobb lehet, mint a visszaadott GetUpperBoundérték.

pNewArray
Egy másik tömb, amely a tömbhöz hozzáadandó elemeket tartalmazza.

Megjegyzések

Az első verzió InsertAt egy elemet (vagy egy elem több példányát) szúr be egy adott indexbe egy tömbben. A folyamat során felfelé tolódik (az index növelésével) az index meglévő elemét, és felfelé tolja el a fölötte lévő összes elemet.

A második verzió egy másik CObArray gyűjtemény összes elemét beszúrja a pozíciótól kezdve nStartIndex .

Ezzel szemben a SetAt függvény egy megadott tömbelemet cserél le, és nem tol el elemeket.

Az alábbi táblázat a többi tagfüggvényt mutatja be, amelyek hasonlóak a következőhöz CObArray::InsertAt:

Osztály	Tagfüggvény
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élda

Tekintse meg CObList::CObList az CAge összes gyűjtemény-példában használt osztály listáját.

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      

A program eredményei a következők:

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

Meghatározza, hogy a tömb üres-e.

BOOL IsEmpty() const;

Visszaadott érték

Nonzero, ha a tömb üres; egyéb esetben 0.

CObArray::operator [ ]

Ezek az alsó index-operátorok kényelmesen helyettesítik a függvényeket és GetAt a SetAt függvényeket.

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

Megjegyzések

A nem consttömbökhöz hívott első operátor a hozzárendelési utasítás jobb oldalán (r-érték) vagy bal oldalán (l-érték) használható. A második tömbökhöz const hívható meg, csak a jobb oldalon használható.

A kódtár hibakeresési verziója azt állítja, hogy az alsó index (a hozzárendelési utasítás bal vagy jobb oldalán) kívül esik-e a korlátokon.

Az alábbi táblázat a hasonló operátorokat CObArray::operator []mutatja be.

Osztály	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élda

Tekintse meg CObList::CObList az CAge összes gyűjtemény-példában használt osztály listáját.

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

Eltávolítja az összes mutatót ebből a tömbből, de valójában nem törli az CObject objektumokat.

void RemoveAll();

Megjegyzések

Ha a tömb már üres, a függvény továbbra is működik.

A RemoveAll függvény felszabadítja a mutatótárhelyhez használt összes memóriát.

Az alábbi táblázat a többi tagfüggvényt mutatja be, amelyek hasonlóak a következőhöz CObArray::RemoveAll:

Osztály	Tagfüggvény
CByteArray	void RemoveAll();
CDWordArray	void RemoveAll();
CPtrArray	void RemoveAll();
CStringArray	void RemoveAll();
CUIntArray	void RemoveAll();
CWordArray	void RemoveAll();

példa

Tekintse meg CObList::CObList az CAge összes gyűjtemény-példában használt osztály listáját.

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

Eltávolít egy vagy több elemet egy tömb megadott indexétől kezdve.

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

Paraméterek

nIndex
0-nál nagyobb vagy egyenlő egész számindex, amely kisebb, mint a visszaadott GetUpperBoundérték.

nCount
Az eltávolítandó elemek száma.

Megjegyzések

A folyamat során az eltávolított elem(ek) fölötti összes elem lejjebb kerül. A tömb felső határa csökken, de nem szabadít fel memóriát.

Ha több elemet próbál eltávolítani, mint amennyit az eltávolítási pont feletti tömb tartalmaz, akkor a kódtár hibakeresési verziója érvényes.

A RemoveAt függvény eltávolítja a CObject mutatót a tömbből, de magát az objektumot nem törli.

Az alábbi táblázat a többi tagfüggvényt mutatja be, amelyek hasonlóak a következőhöz CObArray::RemoveAt:

Osztály	Tagfüggvény
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élda

Tekintse meg CObList::CObList az CAge összes gyűjtemény-példában használt osztály listáját.

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      

A program eredményei a következők:

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

CObArray::SetAt

Beállítja a tömbelemet a megadott indexen.

void SetAt(
    INT_PTR nIndex,
    CObject* newElement);

Paraméterek

nIndex
0-nál nagyobb vagy egyenlő egész számindex, amely kisebb, mint a visszaadott GetUpperBoundérték.

newElement
A tömbbe beszúrandó objektummutató. Egy NULL érték engedélyezett.

Megjegyzések

SetAt a tömb nem fog növekedni. Akkor használja SetAtGrow , ha azt szeretné, hogy a tömb automatikusan növekedjen.

Győződjön meg arról, hogy az index értéke érvényes pozíciót jelöl a tömbben. Ha nincs megkötve, akkor a kódtár hibakeresési verziója érvényes.

Az alábbi táblázat a többi tagfüggvényt mutatja be, amelyek hasonlóak a következőhöz CObArray::SetAt:

Osztály	Tagfüggvény
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élda

Tekintse meg CObList::CObList az CAge összes gyűjtemény-példában használt osztály listáját.

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      

A program eredményei a következők:

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

CObArray::SetAtGrow

Beállítja a tömbelemet a megadott indexen.

void SetAtGrow(
    INT_PTR nIndex,
    CObject* newElement);

Paraméterek

nIndex
0-nál nagyobb vagy egyenlő egész számindex.

newElement
A tömbhöz hozzáadandó objektummutató. Egy NULL érték engedélyezett.

Megjegyzések

A tömb szükség esetén automatikusan növekszik (azaz a felső határ az új elem elhelyezésére van beállítva).

Az alábbi táblázat a többi tagfüggvényt mutatja be, amelyek hasonlóak a következőhöz CObArray::SetAtGrow:

Osztály	Tagfüggvény
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élda

Tekintse meg CObList::CObList az CAge összes gyűjtemény-példában használt osztály listáját.

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      

A program eredményei a következők:

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

Egy üres vagy meglévő tömb méretét határozza meg; szükség esetén lefoglalja a memóriát.

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

Paraméterek

nNewSize
Az új tömbméret (elemek száma). 0-nál nagyobbnak vagy egyenlőnek kell lennie.

nGrowBy
A lefoglalandó elemhelyek minimális száma, ha méretnövelésre van szükség.

Megjegyzések

Ha az új méret kisebb, mint a régi méret, akkor a tömb csonkolt lesz, és az összes fel nem használt memória felszabadul. A hatékonyság érdekében hívja meg SetSize a tömb méretét a használat előtt. Ez megakadályozza, hogy a tömböt minden egyes elem hozzáadásakor újra kell helyezni és kimásolni.

A nGrowBy paraméter hatással van a belső memóriafoglalásra, amíg a tömb növekszik. Használata soha nem befolyásolja a tömb méretét az GetSize and GetUpperBound.

Ha a tömb mérete megnőtt, az összes újonnan lefoglalt CObject * mutató a következőre NULLvan állítva: .

Az alábbi táblázat a többi tagfüggvényt mutatja be, amelyek hasonlóak a következőhöz CObArray::SetSize:

Osztály	Tagfüggvény
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élda

Lásd a példát a CObArray::GetData.

Lásd még

CObject osztály
hierarchiadiagram
CStringArray osztály
CPtrArray osztály
CByteArray osztály
CWordArray osztály
CDWordArray osztály