Condividi tramite


Classe CObArray

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