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