Classe `CObArray`

Articolo
10/12/2023

Supporta matrici di puntatori CObject .

Sintassi

class CObArray : public CObject

Membri

Costruttori pubblici

Nome	Descrizione
`CObArray::CObArray`	Costruisce una matrice vuota per `CObject` i puntatori.

Metodi pubblici

Nome	Descrizione
`CObArray::Add`	Aggiunge un elemento alla fine della matrice; se necessario, aumenta le dimensioni della matrice.
`CObArray::Append`	Accoda alla matrice un'altra matrice; se necessario, aumenta le dimensioni della matrice.
`CObArray::Copy`	Copia nella matrice un'altra matrice; se necessario, aumenta le dimensioni della matrice.
`CObArray::ElementAt`	Restituisce un riferimento temporaneo al puntatore dell'elemento nella matrice.
`CObArray::FreeExtra`	Libera tutta la memoria non utilizzata oltre limite il superiore corrente.
`CObArray::GetAt`	Restituisce il valore in corrispondenza di un indice specificato.
`CObArray::GetCount`	Ottiene il numero di elementi nella matrice.
`CObArray::GetData`	Consente l'accesso a tutti gli elementi nella matrice. Può essere `NULL`.
`CObArray::GetSize`	Ottiene il numero di elementi nella matrice.
`CObArray::GetUpperBound`	Restituisce il massimo indice valido.
`CObArray::InsertAt`	Inserisce un elemento (o tutti gli elementi di un'altra matrice) in corrispondenza di un indice specificato.
`CObArray::IsEmpty`	Determina se la matrice è vuota.
`CObArray::RemoveAll`	Rimuove tutti gli elementi dalla matrice.
`CObArray::RemoveAt`	Rimuove un elemento in corrispondenza di un indice specificato.
`CObArray::SetAt`	Imposta il valore per un indice specificato; l'aumento di dimensioni della matrice non è consentito.
`CObArray::SetAtGrow`	Imposta il valore per un indice specificato; se necessario, aumenta le dimensioni della matrice.
`CObArray::SetSize`	Imposta il numero di elementi che la matrice deve contenere.

Operatori pubblici

Nome	Descrizione
`CObArray::operator []`	Imposta o ottiene l'elemento in corrispondenza dell'indice specificato.

Osservazioni:

Queste matrici di oggetti sono simili alle matrici C, ma possono ridursi e crescere in modo dinamico in base alle esigenze.

Gli indici di matrice iniziano sempre alla posizione 0. È possibile decidere se correggere il limite superiore o consentire l'espansione della matrice quando si aggiungono elementi oltre il limite corrente. La memoria viene allocata in modo contiguo al limite superiore, anche se alcuni elementi sono NULL.

In Win32 le dimensioni di un CObArray oggetto sono limitate solo alla memoria disponibile.

Come per una matrice C, il tempo di accesso per un CObArray elemento indicizzato è costante ed è indipendente dalle dimensioni della matrice.

CObArray incorpora la macro IMPLEMENT_SERIAL per supportare la serializzazione e il dump dei relativi elementi. Se una matrice di CObject puntatori viene archiviata in un archivio, con l'operatore di inserimento di overload o con la Serialize funzione membro, ogni CObject elemento è, a sua volta, serializzato insieme al relativo indice di matrice.

Se è necessario un dump di singoli CObject elementi in una matrice, è necessario impostare la profondità dell'oggetto CDumpContext su 1 o versione successiva.

Quando un CObArray oggetto viene eliminato o quando i relativi elementi vengono rimossi, vengono rimossi solo i CObject puntatori, non gli oggetti a cui fanno riferimento.

Nota

Prima di usare una matrice, usare SetSize per determinarne le dimensioni e allocare la necessaria memoria. Se non si usa SetSize, l'aggiunta di elementi alla matrice ne causa la riallocazione e la copia frequente. Le operazioni di riallocazione e copia frequenti sono inefficienti e possono frammentare la memoria.

La derivazione della classe array è simile alla derivazione list. Per informazioni dettagliate sulla derivazione di una classe di elenco per scopi speciali, vedere l'articolo Raccolte.

Nota

Se si intende serializzare la matrice, è necessario utilizzare la macro IMPLEMENT_edizione Standard RIAL nell'implementazione della classe derivata.

Gerarchia di ereditarietà

CObject

CObArray

Requisiti

Intestazione:afxcoll.h

`CObArray::Add`

Aggiunge un nuovo elemento alla fine di una matrice, aumentando la matrice di 1.

INT_PTR Add(CObject* newElement);

Parametri

newElement
Puntatore CObject da aggiungere a questa matrice.

Valore restituito

Indice dell'elemento aggiunto.

Osservazioni:

Se SetSize è stato usato con un nGrowBy valore maggiore di 1, è possibile allocare memoria aggiuntiva. Tuttavia, il limite superiore aumenterà solo di 1.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObArray::Add.

Classe	Funzione membro
`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*);`

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli esempi di raccolta.

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

I risultati di questo programma sono i seguenti:

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

`CObArray::Append`

Chiamare questa funzione membro per aggiungere il contenuto di un'altra matrice alla fine della matrice specificata.

INT_PTR Append(const CObArray& src);

Parametri

src
Origine degli elementi da aggiungere alla matrice.

Valore restituito

Indice del primo elemento accodato.

Osservazioni:

Le matrici devono essere dello stesso tipo.

Se necessario, Append può allocare memoria aggiuntiva per contenere gli elementi aggiunti alla matrice.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObArray::Append.

Classe	Funzione membro
`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);`

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli esempi di raccolta.

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`

Chiamare questa funzione membro per sovrascrivere gli elementi della matrice specificata con gli elementi di un'altra matrice dello stesso tipo.

void Copy(const CObArray& src);

Parametri

src
Origine degli elementi da copiare nella matrice.

Osservazioni:

Copy non libera memoria. Se necessario, Copy può allocare memoria aggiuntiva per contenere gli elementi copiati nella matrice.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObArray::Copy.

Classe	Funzione membro
`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);`

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli esempi di raccolta.

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`

Costruisce una matrice di puntatori vuota CObject .

CObArray();

Osservazioni:

La matrice aumenta di un elemento alla volta.

Nella tabella seguente vengono illustrati altri costruttori simili a CObArray::CObArray.

Classe	Costruttore
`CByteArray`	`CByteArray();`
`CDWordArray`	`CDWordArray();`
`CPtrArray`	`CPtrArray();`
`CStringArray`	`CStringArray();`
`CUIntArray`	`CUIntArray();`
`CWordArray`	`CWordArray();`

Esempio

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

`CObArray::ElementAt`

Restituisce un riferimento temporaneo al puntatore dell'elemento nella matrice.

CObject*& ElementAt(INT_PTR nIndex);

Parametri

nIndex
Indice integer maggiore o uguale a 0 e minore o uguale al valore restituito da GetUpperBound.

Valore restituito

Riferimento a un CObject puntatore.

Osservazioni:

Viene usato per implementare l'operatore di assegnazione sul lato sinistro per le matrici. Si tratta di una funzione avanzata che deve essere usata solo per implementare operatori di matrice speciali.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObArray::ElementAt.

Classe	Funzione membro
`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);`

Esempio

Vedere l'esempio per CObArray::GetSize.

`CObArray::FreeExtra`

Libera qualsiasi memoria aggiuntiva allocata mentre la matrice è cresciuta.

void FreeExtra();

Osservazioni:

Questa funzione non ha alcun effetto sulle dimensioni o sul limite superiore della matrice.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObArray::FreeExtra.

Classe	Funzione membro
`CByteArray`	`void FreeExtra();`
`CDWordArray`	`void FreeExtra();`
`CPtrArray`	`void FreeExtra();`
`CStringArray`	`void FreeExtra();`
`CUIntArray`	`void FreeExtra();`
`CWordArray`	`void FreeExtra();`

Esempio

Vedere l'esempio per CObArray::GetData.

`CObArray::GetAt`

Restituisce l'elemento della matrice in corrispondenza dell'indice specificato.

CObject* GetAt(INT_PTR nIndex) const;

Parametri

nIndex
Indice integer maggiore o uguale a 0 e minore o uguale al valore restituito da GetUpperBound.

Valore restituito

Elemento CObject puntatore attualmente in corrispondenza di questo indice.

Osservazioni:

Nota

Se si passa un valore negativo o un valore maggiore del valore restituito da GetUpperBound , verrà restituita un'asserzione non riuscita.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObArray::GetAt.

Classe	Funzione membro
`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;`

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli esempi di raccolta.

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`

Restituisce il numero di elementi della matrice.

INT_PTR GetCount() const;

Valore restituito

Numero di elementi nella matrice.

Osservazioni:

Chiamare questo metodo per recuperare il numero di elementi nella matrice. Poiché gli indici sono in base zero, la dimensione è 1 maggiore dell'indice più grande.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObArray::GetCount.

Classe	Funzione membro
`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;`

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli esempi di raccolta.

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`

Usare questa funzione membro per ottenere l'accesso diretto agli elementi nella matrice.

const CObject** GetData() const;

CObject** GetData();

Valore restituito

Puntatore alla matrice di CObject puntatori.

Osservazioni:

Se non sono disponibili elementi, GetData restituisce un NULL valore.

Anche se l'accesso diretto agli elementi di una matrice consente di lavorare più rapidamente, prestare attenzione quando si chiama GetData. Gli errori che si verificano influiscono direttamente sugli elementi della matrice.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObArray::GetData.

Classe	Funzione membro
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();`

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli esempi di raccolta.

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`

Restituisce le dimensioni della matrice.

INT_PTR GetSize() const;

Osservazioni:

Poiché gli indici sono in base zero, la dimensione è 1 maggiore dell'indice più grande.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObArray::GetSize.

Classe	Funzione membro
`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;`

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli esempi di raccolta.

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`

Restituisce il limite superiore corrente di questa matrice.

INT_PTR GetUpperBound() const;

Valore restituito

Indice del limite superiore (in base zero).

Osservazioni:

Poiché gli indici di matrice sono in base zero, questa funzione restituisce un valore 1 minore di GetSize.

La condizione GetUpperBound() = -1 indica che la matrice non contiene elementi.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObArray::GetUpperBound.

Classe	Funzione membro
`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;`

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli esempi di raccolta.

CObArray arr;

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

`CObArray::InsertAt`

Inserisce un elemento (o tutti gli elementi di un'altra matrice) in corrispondenza di un indice specificato.

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

void InsertAt(
    INT_PTR nStartIndex,
    CObArray* pNewArray);

Parametri

nIndex
Indice integer che può essere maggiore del valore restituito da GetUpperBound.

newElement
Puntatore CObject da posizionare in questa matrice. È consentito un newElement valore NULL .

nCount
Numero di volte in cui questo elemento deve essere inserito (il valore predefinito è 1).

nStartIndex
Indice integer che può essere maggiore del valore restituito da GetUpperBound.

pNewArray
Un'altra matrice che contiene elementi da aggiungere a questa matrice.

Osservazioni:

La prima versione di InsertAt inserisce un elemento (o più copie di un elemento) in corrispondenza di un indice specificato in una matrice. Nel processo, sposta verso l'alto (incrementando l'indice) l'elemento esistente in corrispondenza di questo indice e sposta verso l'alto tutti gli elementi sopra di esso.

La seconda versione inserisce tutti gli elementi di un'altra CObArray raccolta, a partire dalla nStartIndex posizione.

La SetAt funzione, al contrario, sostituisce un elemento di matrice specificato e non sposta alcun elemento.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObArray::InsertAt.

Classe	Funzione membro
`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*);`

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli esempi di raccolta.

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

I risultati di questo programma sono i seguenti:

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`

Determina se la matrice è vuota.

BOOL IsEmpty() const;

Valore restituito

Diverso da zero se la matrice è vuota; in caso contrario, 0.

`CObArray::operator [ ]`

Questi operatori di pedice sono un utile sostituto delle SetAt funzioni e GetAt .

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

Osservazioni:

Il primo operatore, chiamato per matrici che non constsono , può essere usato a destra (r-value) o a sinistra (l-value) di un'istruzione di assegnazione. Il secondo, chiamato per const le matrici, può essere usato solo a destra.

La versione debug della libreria asserisce se l'indice (a sinistra o a destra di un'istruzione di assegnazione) è fuori dai limiti.

Nella tabella seguente sono illustrati altri operatori simili a CObArray::operator [].

Classe	Operatore
`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;`

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli esempi di raccolta.

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`

Rimuove tutti i puntatori da questa matrice, ma non elimina effettivamente gli CObject oggetti.

void RemoveAll();

Osservazioni:

Se la matrice è già vuota, la funzione funziona ancora.

La RemoveAll funzione libera tutta la memoria usata per l'archiviazione del puntatore.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObArray::RemoveAll.

Classe	Funzione membro
`CByteArray`	`void RemoveAll();`
`CDWordArray`	`void RemoveAll();`
`CPtrArray`	`void RemoveAll();`
`CStringArray`	`void RemoveAll();`
`CUIntArray`	`void RemoveAll();`
`CWordArray`	`void RemoveAll();`

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli esempi di raccolta.

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`

Rimuove uno o più elementi a partire da un indice specificato in una matrice.

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

Parametri

nIndex
Indice integer maggiore o uguale a 0 e minore o uguale al valore restituito da GetUpperBound.

nCount
Numero di elementi da rimuovere.

Osservazioni:

Nel processo, sposta verso il basso tutti gli elementi sopra gli elementi rimossi. Decrementa il limite superiore della matrice, ma non libera memoria.

Se si tenta di rimuovere più elementi di quelli contenuti nella matrice sopra il punto di rimozione, la versione Debug della libreria asserisce.

La RemoveAt funzione rimuove il CObject puntatore dalla matrice, ma non elimina l'oggetto stesso.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObArray::RemoveAt.

Classe	Funzione membro
`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);`

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli esempi di raccolta.

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

I risultati di questo programma sono i seguenti:

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

`CObArray::SetAt`

Imposta l'elemento della matrice in corrispondenza dell'indice specificato.

void SetAt(
    INT_PTR nIndex,
    CObject* newElement);

Parametri

nIndex
Indice integer maggiore o uguale a 0 e minore o uguale al valore restituito da GetUpperBound.

newElement
Puntatore all'oggetto da inserire in questa matrice. È consentito un NULL valore.

Osservazioni:

SetAt non causerà l'aumento della matrice. Usare SetAtGrow se si vuole che la matrice cresca automaticamente.

Verificare che il valore di indice rappresenti una posizione valida nella matrice. Se è fuori dai limiti, la versione di debug della libreria asserisce.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObArray::SetAt.

Classe	Funzione membro
`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);`

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli esempi di raccolta.

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

I risultati di questo programma sono i seguenti:

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

`CObArray::SetAtGrow`

Imposta l'elemento della matrice in corrispondenza dell'indice specificato.

void SetAtGrow(
    INT_PTR nIndex,
    CObject* newElement);

Parametri

nIndex
Indice integer maggiore o uguale a 0.

newElement
Puntatore all'oggetto da aggiungere a questa matrice. È consentito un NULL valore.

Osservazioni:

Se necessario, la matrice aumenta automaticamente, ovvero il limite superiore viene regolato in base al nuovo elemento.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObArray::SetAtGrow.

Classe	Funzione membro
`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*);`

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli esempi di raccolta.

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

I risultati di questo programma sono i seguenti:

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`

Stabilisce le dimensioni di una matrice vuota o esistente; alloca memoria, se necessario.

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

Parametri

nNewSize
Nuova dimensione della matrice (numero di elementi). Deve essere maggiore o uguale a 0.

nGrowBy
Numero minimo di slot di elemento da allocare se è necessario un aumento delle dimensioni.

Osservazioni:

Se le nuove dimensioni sono inferiori alle dimensioni precedenti, la matrice viene troncata e viene rilasciata tutta la memoria inutilizzata. Per un'efficienza, chiamare SetSize per impostare le dimensioni della matrice prima di usarla. In questo modo si evita la necessità di riallocare e copiare la matrice ogni volta che viene aggiunto un elemento.

Il nGrowBy parametro influisce sull'allocazione di memoria interna durante l'aumento della matrice. L'uso non influisce mai sulle dimensioni della matrice come indicato da GetSize e GetUpperBound.

Se le dimensioni della matrice sono aumentate, tutti i puntatori appena allocati CObject * vengono impostati su NULL.

Nella tabella seguente vengono illustrate altre funzioni membro simili a CObArray::SetSize.

Classe	Funzione membro
`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*);`

Esempio

Vedere l'esempio per CObArray::GetData.

Vedi anche

CObject Classe
Grafico della gerarchia
CStringArray Classe
CPtrArray Classe
CByteArray Classe
CWordArray Classe
CDWordArray Classe

Condividi tramite

Classe CObArray

Sintassi

Membri

Costruttori pubblici

Metodi pubblici

Operatori pubblici

Osservazioni:

Gerarchia di ereditarietà

Requisiti

CObArray::Add

Parametri

Valore restituito

Osservazioni:

Esempio

CObArray::Append

Parametri

Valore restituito

Osservazioni:

Esempio

CObArray::Copy

Parametri

Osservazioni:

Esempio

CObArray::CObArray

Osservazioni:

Esempio

CObArray::ElementAt

Parametri

Valore restituito

Osservazioni:

Esempio

CObArray::FreeExtra

Osservazioni:

Esempio

CObArray::GetAt

Parametri

Valore restituito

Osservazioni:

Esempio

CObArray::GetCount

Valore restituito

Osservazioni:

Esempio

CObArray::GetData

Valore restituito

Osservazioni:

Esempio

CObArray::GetSize

Osservazioni:

Esempio

CObArray::GetUpperBound

Valore restituito

Osservazioni:

Esempio

CObArray::InsertAt

Parametri

Osservazioni:

Esempio

CObArray::IsEmpty

Valore restituito

CObArray::operator [ ]

Osservazioni:

Esempio

CObArray::RemoveAll

Osservazioni:

Esempio

CObArray::RemoveAt

Parametri

Osservazioni:

Esempio

CObArray::SetAt

Parametri

Osservazioni:

Esempio

CObArray::SetAtGrow

Parametri

Osservazioni:

Esempio

CObArray::SetSize

Classe `CObArray`

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