Clase `CObArray`

Artículo
06/16/2023

Admite matrices de punteros CObject .

Sintaxis

class CObArray : public CObject

Miembros

Constructores públicos

Nombre	Descripción
`CObArray::CObArray`	Construye una lista vacía para punteros `CObject`.

Métodos públicos

Nombre	Descripción
`CObArray::Add`	Agrega un elemento al final de la matriz; aumenta el tamaño de la matriz si es necesario.
`CObArray::Append`	Anexa otra matriz a la matriz; aumenta el tamaño de la matriz si es necesario.
`CObArray::Copy`	Copia otra matriz a la matriz; aumenta el tamaño de la matriz si es necesario.
`CObArray::ElementAt`	Devuelve una referencia temporal al puntero del elemento dentro de la matriz.
`CObArray::FreeExtra`	Libera toda la memoria no usada por encima del límite superior actual.
`CObArray::GetAt`	Devuelve el valor en un índice dado.
`CObArray::GetCount`	Obtiene el número de elementos de esta matriz.
`CObArray::GetData`	Permite el acceso a los elementos de la matriz. Puede ser `NULL`.
`CObArray::GetSize`	Obtiene el número de elementos de esta matriz.
`CObArray::GetUpperBound`	Devuelve el índice válido de mayor tamaño.
`CObArray::InsertAt`	Inserta un elemento (o todos los elementos de otra matriz) en un índice especificado.
`CObArray::IsEmpty`	Determina si la matriz está vacía.
`CObArray::RemoveAll`	Quita todos los elementos de esta matriz.
`CObArray::RemoveAt`	Quita un elemento en un índice específico.
`CObArray::SetAt`	Establece el valor de un índice dado; la matriz no puede aumentar de tamaño.
`CObArray::SetAtGrow`	Establece el valor de un índice dado; aumenta el tamaño de la matriz si es necesario.
`CObArray::SetSize`	Establece el número de elementos que contendrá esta matriz.

Operadores públicos

Nombre	Descripción
`CObArray::operator []`	Establece u obtiene el elemento en el índice especificado.

Comentarios

Estas matrices de objetos son similares a las matrices de C, pero pueden reducirse y crecer dinámicamente según sea necesario.

Los índices de matriz siempre comienzan en la posición 0. Puedes decidir si corregir el límite superior o permitir que la matriz se expanda al agregar elementos más allá del límite actual. La memoria se asigna de manera contigua al límite superior, incluso si algunos elementos son NULL.

En Win32, el tamaño de un objeto CObArray solo se limita a la memoria disponible.

Al igual que con una matriz de C, el tiempo de acceso de un elemento indexado CObArray es constante y es independiente del tamaño de la matriz.

CObArray incorpora la macro IMPLEMENT_SERIAL para admitir la serialización y el volcado de sus elementos. Si se almacena una matriz de punteros CObjecten un archivo, ya sea con el operador de inserción sobrecargado o con la Serializefunción miembro, cada CObjectelemento es, a su vez, serializado junto con su índice de matriz.

Si necesita un volcado de los elementos CObject individuales de una matriz, debe establecer la profundidad del objeto CDumpContext en 1 o más.

Cuando se elimina un objeto CObArray, o cuando se quitan sus elementos, solo se quitan los punteros CObject, no los objetos a los que hacen referencia.

Nota:

Antes de usar una matriz, use SetSize para establecer su tamaño y asignarle memoria. Si no usa SetSize, al agregar elementos a la matriz, esta se reasigna y se copia con frecuencia. La reasignación y copia frecuentes son ineficaces y pueden fragmentar la memoria.

La derivación de clases de matriz es similar a la derivación de listas. Para más detalles sobre la derivación de una clase de lista de propósito especial, véase el artículo Colecciones.

Nota:

Debes usar la macro IMPLEMENT_SERIAL en la implementación de la clase derivada si tiene previsto serializar la matriz.

Jerarquía de herencia

CObject

CObArray

Requisitos

Encabezado: afxcoll.h

`CObArray::Add`

Agrega un nuevo elemento al final de una matriz, aumentando la matriz en 1.

INT_PTR Add(CObject* newElement);

Parámetros

newElement
El puntero CObject que se va a agregar a esta matriz.

Valor devuelto

El índice del elemento agregado.

Comentarios

Si SetSize se ha usado con un valor nGrowBy mayor que 1, se puede asignar memoria adicional. Sin embargo, el límite superior aumentará solo en 1.

En la tabla siguiente se muestran otras funciones miembro similares a CObArray::Add.

Clase	Función miembro
`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*);`

Ejemplo

Consulta CObList::CObList para obtener una lista de la clase CAge que se usa en todos los ejemplos de la colección.

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

Los resultados de este programa son los siguientes:

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

`CObArray::Append`

Llama a esta función miembro para añadir el contenido de otra matriz al final de la matriz dada.

INT_PTR Append(const CObArray& src);

Parámetros

src
Origen de los elementos que se van a anexar a la matriz.

Valor devuelto

Índice del primer elemento anexado.

Comentarios

Las matrices deben ser del mismo tipo.

Si es necesario, Append puede asignar memoria adicional para acomodar los elementos anexados a la matriz.

En la tabla siguiente se muestran otras funciones miembro similares a CObArray::Append.

Clase	Función miembro
`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);`

Ejemplo

Consulta CObList::CObList para obtener una lista de la clase CAge que se usa en todos los ejemplos de la colección.

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`

Llama a esta función miembro para sobrescribir los elementos de la matriz dada con los elementos de otra matriz del mismo tipo.

void Copy(const CObArray& src);

Parámetros

src
Origen de los elementos que se van a copiar en una matriz.

Comentarios

Copy no libera memoria. Si es necesario, Copy puedes asignar memoria adicional para acomodar los elementos anexados a la matriz.

En la tabla siguiente se muestran otras funciones miembro similares a CObArray::Copy.

Clase	Función miembro
`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);`

Ejemplo

Consulta CObList::CObList para obtener una lista de la clase CAge que se usa en todos los ejemplos de la colección.

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`

Construye una matriz de punteros CObject vacía.

CObArray();

Comentarios

La matriz crece un elemento cada vez.

En la tabla siguiente se muestran otros constructores similares a CObArray::CObArray.

Clase	Constructor
`CByteArray`	`CByteArray();`
`CDWordArray`	`CDWordArray();`
`CPtrArray`	`CPtrArray();`
`CStringArray`	`CStringArray();`
`CUIntArray`	`CUIntArray();`
`CWordArray`	`CWordArray();`

Ejemplo

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

`CObArray::ElementAt`

Devuelve una referencia temporal al puntero del elemento dentro de la matriz.

CObject*& ElementAt(INT_PTR nIndex);

Parámetros

nIndex
Índice entero mayor o igual que 0 y menor o igual que el valor devuelto por GetUpperBound.

Valor devuelto

Una referencia a un puntero CObject.

Comentarios

Se usa para implementar el operador de asignación del lado izquierdo de las matrices. Se trata de una función avanzada que solo se debe usar para implementar operadores de matriz especiales.

En la tabla siguiente se muestran otras funciones miembro similares a CObArray::ElementAt.

Clase	Función miembro
`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);`

Ejemplo

Vea el ejemplo de CObArray::GetSize.

`CObArray::FreeExtra`

Libera memoria adicional que se haya asignado mientras crecía la matriz.

void FreeExtra();

Comentarios

Esta función no tiene ningún efecto sobre el tamaño o el límite superior de la matriz.

En la tabla siguiente se muestran otras funciones miembro similares a CObArray::FreeExtra.

Clase	Función miembro
`CByteArray`	`void FreeExtra();`
`CDWordArray`	`void FreeExtra();`
`CPtrArray`	`void FreeExtra();`
`CStringArray`	`void FreeExtra();`
`CUIntArray`	`void FreeExtra();`
`CWordArray`	`void FreeExtra();`

Ejemplo

Vea el ejemplo de CObArray::GetData.

`CObArray::GetAt`

Devuelve el elemento de matriz que se encuentra en el índice especificado.

CObject* GetAt(INT_PTR nIndex) const;

Parámetros

nIndex
Índice entero mayor o igual que 0 y menor o igual que el valor devuelto por GetUpperBound.

Valor devuelto

Elemento puntero CObject que se encuentra actualmente en este índice.

Comentarios

Nota:

Si se pasa un valor negativo o un valor mayor que el valor devuelto por GetUpperBound, se producirá un error en la aserción.

En la tabla siguiente se muestran otras funciones miembro similares a CObArray::GetAt.

Clase	Función miembro
`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;`

Ejemplo

Consulta CObList::CObList para obtener una lista de la clase CAge que se usa en todos los ejemplos de la colección.

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`

Devuelve el número de elementos de matriz.

INT_PTR GetCount() const;

Valor devuelto

Número de elementos de la matriz.

Comentarios

Llame a este método para recuperar el número de elementos de la matriz. Dado que los índices se basan en cero, el tamaño es 1 mayor que el índice más grande.

En la tabla siguiente se muestran otras funciones miembro similares a CObArray::GetCount.

Clase	Función miembro
`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;`

Ejemplo

Consulta CObList::CObList para obtener una lista de la clase CAge que se usa en todos los ejemplos de la colección.

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`

Usa esta función miembro para obtener acceso directo a los elementos de una matriz.

const CObject** GetData() const;

CObject** GetData();

Valor devuelto

Un puntero a los punteros CObject de matriz.

Comentarios

Si no hay elementos disponibles, GetData devuelve un valorNULL.

Aunque el acceso directo a los elementos de una matriz puede ayudarle a trabajar más rápidamente, tenga cuidado al llamar a GetData; los errores que cometa afectan directamente a los elementos de la matriz.

En la tabla siguiente se muestran otras funciones miembro similares a CObArray::GetData.

Clase	Función miembro
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();`

Ejemplo

Consulta CObList::CObList para obtener una lista de la clase CAge que se usa en todos los ejemplos de la colección.

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`

Devuelve el tamaño de la matriz.

INT_PTR GetSize() const;

Comentarios

Dado que los índices se basan en cero, el tamaño es 1 mayor que el índice más grande.

En la tabla siguiente se muestran otras funciones miembro similares a CObArray::GetSize.

Clase	Función miembro
`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;`

Ejemplo

Consulta CObList::CObList para obtener una lista de la clase CAge que se usa en todos los ejemplos de la colección.

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`

Devuelve el límite superior actual de esta matriz.

INT_PTR GetUpperBound() const;

Valor devuelto

Índice del límite superior (basado en cero).

Comentarios

Dado que los índices de matriz se basan en cero, esta función devuelve un valor 1 menor que GetSize.

La condición GetUpperBound() = -1 indica que la matriz no contiene ningún elemento.

En la tabla siguiente se muestran otras funciones miembro similares a CObArray::GetUpperBound.

Clase	Función miembro
`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;`

Ejemplo

Consulta CObList::CObList para obtener una lista de la clase CAge que se usa en todos los ejemplos de la colección.

CObArray arr;

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

`CObArray::InsertAt`

Inserta un elemento (o todos los elementos de otra matriz) en un índice especificado.

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

void InsertAt(
    INT_PTR nStartIndex,
    CObArray* pNewArray);

Parámetros

nIndex
Índice entero que puede ser mayor que el valor devuelto por GetUpperBound.

newElement
El puntero CObject de objeto que se va a colocar en esta matriz. Se permite un valor newElement de NULL.

nCount
Número de veces que se debe insertar este elemento (el valor predeterminado es 1).

nStartIndex
Índice entero que puede ser mayor que el valor devuelto por GetUpperBound.

pNewArray
Otra matriz que contiene elementos que se van a agregar a esta matriz.

Comentarios

La primera versión de InsertAt inserta un elemento (o varias copias de un elemento) en un índice especificado de una matriz. En el proceso, desplaza hacia arriba (incrementando el índice) el elemento existente en este índice y desplaza hacia arriba todos los elementos por encima de él.

La segunda versión inserta todos los elementos de otra colección CObArray, empezando por la posición nStartIndex.

La función SetAt, en cambio, reemplaza un elemento de matriz especificado y no desplaza ningún elemento.

En la tabla siguiente se muestran otras funciones miembro similares a CObArray::InsertAt.

Clase	Función miembro
`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*);`

Ejemplo

Consulta CObList::CObList para obtener una lista de la clase CAge que se usa en todos los ejemplos de la colección.

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

Los resultados de este programa son los siguientes:

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 si la matriz está vacía.

BOOL IsEmpty() const;

Valor devuelto

Distinto de cero si la matriz está vacía; de lo contrario, 0.

`CObArray::operator [ ]`

Estos operadores de subíndice son un buen sustituto de las funciones SetAt y GetAt.

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

Comentarios

El primer operador, llamado para las matrices que no son const, se puede usar a la derecha (r-value) o a la izquierda (l-value) de una instrucción de asignación. El segundo, llamado para las matrices const, solo se puede usar a la derecha.

La versión de depuración de la biblioteca afirma si el subíndice (ya sea en el lado izquierdo o derecho de una instrucción de asignación) está fuera de los límites.

En la tabla siguiente se muestran otros constructores similares a CObArray::operator [].

Clase	Operador
`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;`

Ejemplo

Consulta CObList::CObList para obtener una lista de la clase CAge que se usa en todos los ejemplos de la colección.

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`

Quita todos los punteros de esta matriz, pero no elimina realmente los CObject objetos.

void RemoveAll();

Comentarios

Si la matriz ya está vacía, la función sigue funcionando.

La RemoveAll función libera toda la memoria usada para el almacenamiento de punteros.

En la tabla siguiente se muestran otras funciones miembro similares a CObArray::RemoveAll.

Clase	Función miembro
`CByteArray`	`void RemoveAll();`
`CDWordArray`	`void RemoveAll();`
`CPtrArray`	`void RemoveAll();`
`CStringArray`	`void RemoveAll();`
`CUIntArray`	`void RemoveAll();`
`CWordArray`	`void RemoveAll();`

Ejemplo

Consulta CObList::CObList para obtener una lista de la clase CAge que se usa en todos los ejemplos de la colección.

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`

Quita uno o varios elementos que comienzan en un índice especificado de una matriz.

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

Parámetros

nIndex
Índice entero mayor o igual que 0 y menor o igual que el valor devuelto por GetUpperBound.

nCount
Número de elementos que se va a quitar.

Comentarios

En el proceso, desplaza hacia abajo todos los elementos situados encima de los elementos quitados. Disminuye el límite superior de la matriz, pero no libera memoria.

Si intenta quitar más elementos de los contenidos en la matriz por encima del punto de eliminación, se produce una aserción en la versión de depuración de la biblioteca.

La RemoveAt función quita el CObject puntero de la matriz, pero no elimina el propio objeto.

En la tabla siguiente se muestran otras funciones miembro similares a CObArray::RemoveAt.

Clase	Función miembro
`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);`

Ejemplo

Consulta CObList::CObList para obtener una lista de la clase CAge que se usa en todos los ejemplos de la colección.

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

Los resultados de este programa son los siguientes:

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

`CObArray::SetAt`

Establece el elemento de matriz en el índice especificado.

void SetAt(
    INT_PTR nIndex,
    CObject* newElement);

Parámetros

nIndex
Índice entero mayor o igual que 0 y menor o igual que el valor devuelto por GetUpperBound.

newElement
El puntero de objeto que se va a insertar en esta matriz. Se permite un valor NULL.

Comentarios

SetAt no hará que la matriz crezca. Use SetAtGrow si quiere que la matriz crezca automáticamente.

Debes asegurarte de que el valor de índice represente una posición válida en la matriz. Si estás fuera de los límites, se realiza una aserción en la versión de depuración de la biblioteca.

En la tabla siguiente se muestran otras funciones miembro similares a CObArray::SetAt.

Clase	Función miembro
`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);`

Ejemplo

Consulta CObList::CObList para obtener una lista de la clase CAge que se usa en todos los ejemplos de la colección.

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

Los resultados de este programa son los siguientes:

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

`CObArray::SetAtGrow`

Establece el elemento de matriz en el índice especificado.

void SetAtGrow(
    INT_PTR nIndex,
    CObject* newElement);

Parámetros

nIndex
Índice entero mayor o igual que 0.

newElement
Puntero de objeto que se vaya a agregar a esta matriz. Se permite un valor NULL.

Comentarios

La matriz crece automáticamente si es necesario (es decir, el límite superior se ajusta para acomodar el nuevo elemento).

En la tabla siguiente se muestran otras funciones miembro similares a CObArray::SetAtGrow.

Clase	Función miembro
`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*);`

Ejemplo

Consulta CObList::CObList para obtener una lista de la clase CAge que se usa en todos los ejemplos de la colección.

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

Los resultados de este programa son los siguientes:

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`

Establece el tamaño de una matriz vacía o existente; asigna memoria si es necesario.

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

Parámetros

nNewSize
Nuevo tamaño de matriz (número de elementos). Debe ser mayor o igual que 0.

nGrowBy
Número mínimo de ranuras de elemento que se van a asignar si es necesario un aumento de tamaño.

Comentarios

Si el nuevo tamaño es menor que el tamaño anterior, la matriz se trunca y se libera toda la memoria no utilizada. Para mejorar la eficacia, llama SetSize a para establecer el tamaño de la matriz antes de usarlo. Esto evita la necesidad de reasignar y copiar la matriz cada vez que se agrega un elemento.

El parámetro nGrowBy afecta a la asignación de memoria interna mientras la matriz crece. Su uso nunca afecta al tamaño de la matriz según lo notificado por GetSize y GetUpperBound.

Si el tamaño de la matriz ha crecido, todos los punteros recién asignados CObject * se establecen en NULL.

En la tabla siguiente se muestran otras funciones miembro similares a CObArray::SetSize.

Clase	Función miembro
`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*);`

Ejemplo

Vea el ejemplo de CObArray::GetData.

Consulte también

CObject (clase)
Gráfico de jerarquías
CStringArray (clase)
CPtrArray (clase)
CByteArray (clase)
CWordArray (clase)
CDWordArray (clase)

Compartir a través de

Clase CObArray

Sintaxis

Miembros

Constructores públicos

Métodos públicos

Operadores públicos

Comentarios

Jerarquía de herencia

Requisitos

CObArray::Add

Parámetros

Valor devuelto

Comentarios

Ejemplo

CObArray::Append

Parámetros

Valor devuelto

Comentarios

Ejemplo

CObArray::Copy

Parámetros

Comentarios

Ejemplo

CObArray::CObArray

Comentarios

Ejemplo

CObArray::ElementAt

Parámetros

Valor devuelto

Comentarios

Ejemplo

CObArray::FreeExtra

Comentarios

Ejemplo

CObArray::GetAt

Parámetros

Valor devuelto

Comentarios

Ejemplo

CObArray::GetCount

Valor devuelto

Comentarios

Ejemplo

CObArray::GetData

Valor devuelto

Comentarios

Ejemplo

CObArray::GetSize

Comentarios

Ejemplo

CObArray::GetUpperBound

Valor devuelto

Comentarios

Ejemplo

CObArray::InsertAt

Parámetros

Comentarios

Ejemplo

CObArray::IsEmpty

Valor devuelto

CObArray::operator [ ]

Comentarios

Ejemplo

CObArray::RemoveAll

Comentarios

Ejemplo

CObArray::RemoveAt

Parámetros

Comentarios

Ejemplo

CObArray::SetAt

Parámetros

Comentarios

Ejemplo

CObArray::SetAtGrow

Parámetros

Comentarios

Ejemplo

CObArray::SetSize

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