`CObArray` Kelas

Artikel
06/16/2023

Mendukung array CObject pointer.

Sintaks

class CObArray : public CObject

Anggota

Konstruktor Publik

Nama	Deskripsi
`CObArray::CObArray`	Membuat array kosong untuk `CObject` pointer.

Metode Publik

Nama	Deskripsi
`CObArray::Add`	Menambahkan elemen ke akhir array; menumbuhkan array jika perlu.
`CObArray::Append`	Menambahkan array lain ke array; menumbuhkan array jika perlu.
`CObArray::Copy`	Menyalin array lain ke array; menumbuhkan array jika perlu.
`CObArray::ElementAt`	Mengembalikan referensi sementara ke penunjuk elemen dalam array.
`CObArray::FreeExtra`	Membebaskan semua memori yang tidak digunakan di atas batas atas saat ini.
`CObArray::GetAt`	Mengembalikan nilai pada indeks tertentu.
`CObArray::GetCount`	Mendapatkan jumlah elemen dalam array ini.
`CObArray::GetData`	Memungkinkan akses ke elemen dalam array. Bisa jadi `NULL`.
`CObArray::GetSize`	Mendapatkan jumlah elemen dalam array ini.
`CObArray::GetUpperBound`	Mengembalikan indeks valid terbesar.
`CObArray::InsertAt`	Menyisipkan elemen (atau semua elemen dalam array lain) pada indeks tertentu.
`CObArray::IsEmpty`	Menentukan apakah array kosong.
`CObArray::RemoveAll`	Menghapus semua elemen dari array ini.
`CObArray::RemoveAt`	Menghapus elemen pada indeks tertentu.
`CObArray::SetAt`	Mengatur nilai untuk indeks tertentu; array tidak diizinkan untuk tumbuh.
`CObArray::SetAtGrow`	Mengatur nilai untuk indeks tertentu; menumbuhkan array jika perlu.
`CObArray::SetSize`	Mengatur jumlah elemen yang akan dimuat dalam array ini.

Operator Publik

Nama	Deskripsi
`CObArray::operator []`	Mengatur atau mendapatkan elemen pada indeks yang ditentukan.

Keterangan

Array objek ini mirip dengan array C, tetapi dapat secara dinamis menyusut dan tumbuh seperlunya.

Indeks array selalu dimulai pada posisi 0. Anda dapat memutuskan apakah akan memperbaiki batas atas atau mengizinkan array untuk diperluas saat Anda menambahkan elemen melewati batas saat ini. Memori dialokasikan secara berdekatan dengan batas atas, bahkan jika beberapa elemen adalah NULL.

Di bawah Win32, ukuran objek hanya terbatas pada memori yang CObArray tersedia.

Seperti halnya array C, waktu akses untuk CObArray elemen terindeks konstan dan tidak bergantung pada ukuran array.

CObArray menggabungkan IMPLEMENT_SERIAL makro untuk mendukung serialisasi dan pembuangan elemennya. Jika array CObject pointer disimpan ke arsip, baik dengan operator penyisipan yang kelebihan beban atau dengan Serialize fungsi anggota, setiap CObject elemen, pada gilirannya, diserialisasikan bersama dengan indeks array-nya.

Jika Anda memerlukan cadangan elemen individual CObject dalam array, Anda harus mengatur kedalaman CDumpContext objek ke 1 atau lebih besar.

CObArray Saat objek dihapus, atau ketika elemennya dihapus, hanya CObject penunjuk yang dihapus, bukan objek yang mereka referensikan.

Catatan

Sebelum menggunakan array, gunakan SetSize untuk menetapkan ukurannya dan mengalokasikan memori untuk array tersebut. Jika Anda tidak menggunakan SetSize, menambahkan elemen ke array Anda menyebabkannya sering direalokasi dan disalin. Realokasi dan penyalinan yang sering tidak efisien dan dapat memfragmentasi memori.

Derivasi kelas array mirip dengan derivasi daftar. Untuk detail tentang turunan kelas daftar tujuan khusus, lihat artikel Koleksi.

Catatan

Anda harus menggunakan makro IMPLEMENT_SERIAL dalam implementasi kelas turunan Anda jika Anda ingin membuat serial array.

Hierarki Warisan

CObject

CObArray

Persyaratan

Header: afxcoll.h

`CObArray::Add`

Menambahkan elemen baru ke akhir array, menumbuhkan array sebesar 1.

INT_PTR Add(CObject* newElement);

Parameter

newElement
Penunjuk CObject yang akan ditambahkan ke array ini.

Tampilkan Nilai

Indeks elemen yang ditambahkan.

Keterangan

Jika SetSize telah digunakan dengan nilai yang nGrowBy lebih besar dari 1, maka memori tambahan dapat dialokasikan. Namun, batas atas hanya akan meningkat 1.

Tabel berikut ini memperlihatkan fungsi anggota lain yang mirip CObArray::Adddengan .

Kelas	Fungsi Anggota
`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*);`

Contoh

Lihat CObList::CObList untuk daftar kelas yang CAge digunakan dalam semua contoh koleksi.

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

Hasil dari program ini adalah sebagai berikut:

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

`CObArray::Append`

Panggil fungsi anggota ini untuk menambahkan konten array lain ke akhir array yang diberikan.

INT_PTR Append(const CObArray& src);

Parameter

src
Sumber elemen yang akan ditambahkan ke array.

Tampilkan Nilai

Indeks elemen pertama yang ditambahkan.

Keterangan

Array harus berjenis yang sama.

Jika perlu, Append dapat mengalokasikan memori tambahan untuk mengakomodasi elemen yang ditambahkan ke array.

Tabel berikut ini memperlihatkan fungsi anggota lain yang mirip CObArray::Appenddengan .

Kelas	Fungsi Anggota
`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);`

Contoh

Lihat CObList::CObList untuk daftar kelas yang CAge digunakan dalam semua contoh koleksi.

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`

Panggil fungsi anggota ini untuk menimpa elemen array yang diberikan dengan elemen array lain dengan jenis yang sama.

void Copy(const CObArray& src);

Parameter

src
Sumber elemen yang akan disalin ke array.

Keterangan

Copy tidak membebaskan memori. Jika perlu, Copy dapat mengalokasikan memori tambahan untuk mengakomodasi elemen yang disalin ke array.

Tabel berikut ini memperlihatkan fungsi anggota lain yang mirip CObArray::Copydengan .

Kelas	Fungsi Anggota
`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);`

Contoh

Lihat CObList::CObList untuk daftar kelas yang CAge digunakan dalam semua contoh koleksi.

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`

Membuat array pointer kosong CObject .

CObArray();

Keterangan

Array menumbuhkan satu elemen pada satu waktu.

Tabel berikut ini memperlihatkan konstruktor lain yang mirip CObArray::CObArraydengan .

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

Contoh

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

`CObArray::ElementAt`

Mengembalikan referensi sementara ke penunjuk elemen dalam array.

CObject*& ElementAt(INT_PTR nIndex);

Parameter

nIndex
Indeks bilangan bulat yang lebih besar dari atau sama dengan 0 dan kurang dari atau sama dengan nilai yang dikembalikan oleh GetUpperBound.

Tampilkan Nilai

Referensi ke CObject penunjuk.

Keterangan

Ini digunakan untuk mengimplementasikan operator penugasan sisi kiri untuk array. Ini adalah fungsi lanjutan yang harus digunakan hanya untuk menerapkan operator array khusus.

Tabel berikut ini memperlihatkan fungsi anggota lain yang mirip CObArray::ElementAtdengan .

Kelas	Fungsi Anggota
`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);`

Contoh

Lihat contoh untuk CObArray::GetSize.

`CObArray::FreeExtra`

Membebaskan memori tambahan yang dialokasikan saat array tumbuh.

void FreeExtra();

Keterangan

Fungsi ini tidak berpengaruh pada ukuran atau batas atas array.

Tabel berikut ini memperlihatkan fungsi anggota lain yang mirip CObArray::FreeExtradengan .

Kelas	Fungsi Anggota
`CByteArray`	`void FreeExtra();`
`CDWordArray`	`void FreeExtra();`
`CPtrArray`	`void FreeExtra();`
`CStringArray`	`void FreeExtra();`
`CUIntArray`	`void FreeExtra();`
`CWordArray`	`void FreeExtra();`

Contoh

Lihat contoh untuk CObArray::GetData.

`CObArray::GetAt`

Mengembalikan elemen array pada indeks yang ditentukan.

CObject* GetAt(INT_PTR nIndex) const;

Parameter

nIndex
Indeks bilangan bulat yang lebih besar dari atau sama dengan 0 dan kurang dari atau sama dengan nilai yang dikembalikan oleh GetUpperBound.

Tampilkan Nilai

Elemen CObject penunjuk saat ini pada indeks ini.

Keterangan

Catatan

Meneruskan nilai negatif atau nilai yang lebih besar dari nilai yang dikembalikan oleh GetUpperBound akan mengakibatkan pernyataan gagal.

Tabel berikut ini memperlihatkan fungsi anggota lain yang mirip CObArray::GetAtdengan .

Kelas	Fungsi Anggota
`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;`

Contoh

Lihat CObList::CObList untuk daftar kelas yang CAge digunakan dalam semua contoh koleksi.

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`

Mengembalikan jumlah elemen array.

INT_PTR GetCount() const;

Tampilkan Nilai

Jumlah item dalam array.

Keterangan

Panggil metode ini untuk mengambil jumlah elemen dalam array. Karena indeks berbasis nol, ukurannya 1 lebih besar dari indeks terbesar.

Tabel berikut ini memperlihatkan fungsi anggota lain yang mirip CObArray::GetCountdengan .

Kelas	Fungsi Anggota
`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;`

Contoh

Lihat CObList::CObList untuk daftar kelas yang CAge digunakan dalam semua contoh koleksi.

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`

Gunakan fungsi anggota ini untuk mendapatkan akses langsung ke elemen dalam array.

const CObject** GetData() const;

CObject** GetData();

Tampilkan Nilai

Penunjuk ke array CObject pointer.

Keterangan

Jika tidak ada elemen yang tersedia, GetData mengembalikan NULL nilai.

Meskipun akses langsung ke elemen array dapat membantu Anda bekerja lebih cepat, berhati-hatilah saat memanggil GetData; kesalahan apa pun yang Anda buat secara langsung memengaruhi elemen array Anda.

Tabel berikut ini memperlihatkan fungsi anggota lain yang mirip CObArray::GetDatadengan .

Kelas	Fungsi Anggota
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();`

Contoh

Lihat CObList::CObList untuk daftar kelas yang CAge digunakan dalam semua contoh koleksi.

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`

Mengembalikan ukuran array.

INT_PTR GetSize() const;

Keterangan

Karena indeks berbasis nol, ukurannya 1 lebih besar dari indeks terbesar.

Tabel berikut ini memperlihatkan fungsi anggota lain yang mirip CObArray::GetSizedengan .

Kelas	Fungsi Anggota
`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;`

Contoh

Lihat CObList::CObList untuk daftar kelas yang CAge digunakan dalam semua contoh koleksi.

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`

Mengembalikan batas atas array ini saat ini.

INT_PTR GetUpperBound() const;

Tampilkan Nilai

Indeks batas atas (berbasis nol).

Keterangan

Karena indeks array berbasis nol, fungsi ini mengembalikan nilai 1 kurang dari GetSize.

Kondisi GetUpperBound() = -1 menunjukkan bahwa array tidak berisi elemen.

Tabel berikut ini memperlihatkan fungsi anggota lain yang mirip CObArray::GetUpperBounddengan .

Kelas	Fungsi Anggota
`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;`

Contoh

Lihat CObList::CObList untuk daftar kelas yang CAge digunakan dalam semua contoh koleksi.

CObArray arr;

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

`CObArray::InsertAt`

Menyisipkan elemen (atau semua elemen dalam array lain) pada indeks tertentu.

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

void InsertAt(
    INT_PTR nStartIndex,
    CObArray* pNewArray);

Parameter

nIndex
Indeks bilangan bulat yang mungkin lebih besar dari nilai yang dikembalikan oleh GetUpperBound.

newElement
Penunjuk CObject yang akan ditempatkan dalam array ini. Nilai newElement NULL diperbolehkan.

nCount
Frekuensi elemen ini harus disisipkan (default ke 1).

nStartIndex
Indeks bilangan bulat yang mungkin lebih besar dari nilai yang dikembalikan oleh GetUpperBound.

pNewArray
Array lain yang berisi elemen yang akan ditambahkan ke array ini.

Keterangan

Versi InsertAt pertama menyisipkan satu elemen (atau beberapa salinan elemen) pada indeks tertentu dalam array. Dalam prosesnya, ia bergeser ke atas (dengan meningkatkan indeks) elemen yang ada pada indeks ini, dan menggeser semua elemen di atasnya.

Versi kedua menyisipkan semua elemen dari koleksi lain CObArray , dimulai dari nStartIndex posisi.

Fungsi ini SetAt , sebaliknya, menggantikan satu elemen array yang ditentukan dan tidak menggeser elemen apa pun.

Tabel berikut ini memperlihatkan fungsi anggota lain yang mirip CObArray::InsertAtdengan .

Kelas	Fungsi Anggota
`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*);`

Contoh

Lihat CObList::CObList untuk daftar kelas yang CAge digunakan dalam semua contoh koleksi.

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

Hasil dari program ini adalah sebagai berikut:

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`

Menentukan apakah array kosong.

BOOL IsEmpty() const;

Tampilkan Nilai

Bukan nol jika array kosong; jika tidak, 0.

`CObArray::operator [ ]`

Operator subskrip ini adalah pengganti SetAt fungsi dan GetAt yang nyaman.

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

Keterangan

Operator pertama, yang dipanggil untuk array yang tidak const, dapat digunakan di kanan (r-value) atau kiri (nilai l) dari pernyataan penugasan. Yang kedua, yang dipanggil untuk const array, hanya dapat digunakan di sebelah kanan.

Versi Debug pustaka menegaskan jika subskrip (baik di sisi kiri atau kanan pernyataan penugasan) berada di luar batas.

Tabel berikut ini memperlihatkan operator lain yang mirip CObArray::operator []dengan .

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

Contoh

Lihat CObList::CObList untuk daftar kelas yang CAge digunakan dalam semua contoh koleksi.

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`

Menghapus semua pointer dari array ini tetapi tidak benar-benar menghapus CObject objek.

void RemoveAll();

Keterangan

Jika array sudah kosong, fungsi masih berfungsi.

Fungsi ini RemoveAll membebaskan semua memori yang digunakan untuk penyimpanan pointer.

Tabel berikut ini memperlihatkan fungsi anggota lain yang mirip CObArray::RemoveAlldengan .

Kelas	Fungsi Anggota
`CByteArray`	`void RemoveAll();`
`CDWordArray`	`void RemoveAll();`
`CPtrArray`	`void RemoveAll();`
`CStringArray`	`void RemoveAll();`
`CUIntArray`	`void RemoveAll();`
`CWordArray`	`void RemoveAll();`

Contoh

Lihat CObList::CObList untuk daftar kelas yang CAge digunakan dalam semua contoh koleksi.

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`

Menghapus satu atau beberapa elemen yang dimulai pada indeks tertentu dalam array.

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

Parameter

nIndex
Indeks bilangan bulat yang lebih besar dari atau sama dengan 0 dan kurang dari atau sama dengan nilai yang dikembalikan oleh GetUpperBound.

nCount
Jumlah elemen yang akan dihapus.

Keterangan

Dalam prosesnya, ia menggeser ke bawah semua elemen di atas elemen yang dihapus. Ini mengurangi batas atas array tetapi tidak membebaskan memori.

Jika Anda mencoba menghapus lebih banyak elemen daripada yang terkandung dalam array di atas titik penghapusan, maka versi Debug pustaka menegaskan.

Fungsi ini RemoveAt menghapus penunjuk CObject dari array, tetapi tidak menghapus objek itu sendiri.

Tabel berikut ini memperlihatkan fungsi anggota lain yang mirip CObArray::RemoveAtdengan .

Kelas	Fungsi Anggota
`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);`

Contoh

Lihat CObList::CObList untuk daftar kelas yang CAge digunakan dalam semua contoh koleksi.

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

Hasil dari program ini adalah sebagai berikut:

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

`CObArray::SetAt`

Mengatur elemen array pada indeks yang ditentukan.

void SetAt(
    INT_PTR nIndex,
    CObject* newElement);

Parameter

nIndex
Indeks bilangan bulat yang lebih besar dari atau sama dengan 0 dan kurang dari atau sama dengan nilai yang dikembalikan oleh GetUpperBound.

newElement
Penunjuk objek yang akan disisipkan dalam array ini. Nilai NULL diperbolehkan.

Keterangan

SetAt tidak akan menyebabkan array tumbuh. Gunakan SetAtGrow jika Anda ingin array tumbuh secara otomatis.

Pastikan nilai indeks Anda mewakili posisi yang valid dalam array. Jika di luar batas, maka versi Debug pustaka menegaskan.

Tabel berikut ini memperlihatkan fungsi anggota lain yang mirip CObArray::SetAtdengan .

Kelas	Fungsi Anggota
`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);`

Contoh

Lihat CObList::CObList untuk daftar kelas yang CAge digunakan dalam semua contoh koleksi.

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

Hasil dari program ini adalah sebagai berikut:

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

`CObArray::SetAtGrow`

Mengatur elemen array pada indeks yang ditentukan.

void SetAtGrow(
    INT_PTR nIndex,
    CObject* newElement);

Parameter

nIndex
Indeks bilangan bulat yang lebih besar dari atau sama dengan 0.

newElement
Penunjuk objek yang akan ditambahkan ke array ini. Nilai NULL diperbolehkan.

Keterangan

Array tumbuh secara otomatis jika perlu (yaitu, batas atas disesuaikan untuk mengakomodasi elemen baru).

Tabel berikut ini memperlihatkan fungsi anggota lain yang mirip CObArray::SetAtGrowdengan .

Kelas	Fungsi Anggota
`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*);`

Contoh

Lihat CObList::CObList untuk daftar kelas yang CAge digunakan dalam semua contoh koleksi.

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

Hasil dari program ini adalah sebagai berikut:

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`

Menetapkan ukuran array kosong atau yang ada; mengalokasikan memori jika perlu.

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

Parameter

nNewSize
Ukuran array baru (jumlah elemen). Harus lebih besar dari atau sama dengan 0.

nGrowBy
Jumlah minimum slot elemen untuk dialokasikan jika peningkatan ukuran diperlukan.

Keterangan

Jika ukuran baru lebih kecil dari ukuran lama, maka array dipotong dan semua memori yang tidak digunakan dilepaskan. Untuk efisiensi, panggil SetSize untuk mengatur ukuran array sebelum menggunakannya. Ini mencegah kebutuhan untuk merealokasi dan menyalin array setiap kali item ditambahkan.

Parameter nGrowBy memengaruhi alokasi memori internal saat array tumbuh. Penggunaannya tidak pernah memengaruhi ukuran array seperti yang dilaporkan oleh GetSize dan GetUpperBound.

Jika ukuran array telah tumbuh, semua pointer yang baru dialokasikan CObject * diatur ke NULL.

Tabel berikut ini memperlihatkan fungsi anggota lain yang mirip CObArray::SetSizedengan .

Kelas	Fungsi Anggota
`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*);`

Contoh

Lihat contoh untuk CObArray::GetData.

Lihat juga

CObject Kelas
Bagan Hierarki
CStringArray Kelas
CPtrArray Kelas
CByteArray Kelas
CWordArray Kelas
CDWordArray Kelas

Bagikan melalui

CObArray Kelas

Sintaks

Anggota

Konstruktor Publik

Metode Publik

Operator Publik

Keterangan

Hierarki Warisan

Persyaratan

CObArray::Add

Parameter

Tampilkan Nilai

Keterangan

Contoh

CObArray::Append

Parameter

Tampilkan Nilai

Keterangan

Contoh

CObArray::Copy

Parameter

Keterangan

Contoh

CObArray::CObArray

Keterangan

Contoh

CObArray::ElementAt

Parameter

Tampilkan Nilai

Keterangan

Contoh

CObArray::FreeExtra

Keterangan

Contoh

CObArray::GetAt

Parameter

Tampilkan Nilai

Keterangan

Contoh

CObArray::GetCount

Tampilkan Nilai

Keterangan

Contoh

CObArray::GetData

Tampilkan Nilai

Keterangan

Contoh

CObArray::GetSize

Keterangan

Contoh

CObArray::GetUpperBound

Tampilkan Nilai

Keterangan

Contoh

CObArray::InsertAt

Parameter

Keterangan

Contoh

CObArray::IsEmpty

Tampilkan Nilai

CObArray::operator [ ]

Keterangan

Contoh

CObArray::RemoveAll

Keterangan

Contoh

CObArray::RemoveAt

Parameter

Keterangan

Contoh

CObArray::SetAt

Parameter

Keterangan

Contoh

CObArray::SetAtGrow

Parameter

Keterangan

Contoh

CObArray::SetSize

`CObArray` Kelas

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