FTP | CCD | Buscar | Trucos | Trabajo | Foros |
|
Registrarse | FAQ | Miembros | Calendario | Guía de estilo | Buscar | Temas de Hoy | Marcar Foros Como Leídos |
|
Herramientas | Buscar en Tema | Desplegado |
#1
|
||||
|
||||
Arrays dinámicos en memoria
Imaginad que tengo 500 o 1000 objetos con un array cada uno;
hay algún problema en que estos arrays sean dinámicos, de forma que de vez en cuando, al añadir o eliminar un valor se aumente o elimine una variable del array? O sería mejor modificar el número de variables, por ejemplo, de 100 en 100, y no estar cambiandolo todo el rato (1 por 1)? me explico: ¿Cuando declaro un array dinámico este deja un buen espacio en memoria para aumentar su número de miembros, o tendrá que reestructurarse frecuentemente su espacio en la memoria? Esto último querría evitarlo... supongo. ¿Que hago? |
#2
|
||||
|
||||
Si te interesa saber como funcionan los Arrays dinámicos, puedes estudiarte el procedimiento DynArraySetLength ubicado en la unit System, que es el que utiliza Delphi para redimensionarlos.
__________________
delphi.com.ar Dedique el tiempo suficiente para formular su pregunta si pretende que alguien dedique su tiempo en contestarla. Última edición por delphi.com.ar fecha: 31-01-2006 a las 16:15:31. |
#3
|
||||
|
||||
Me encantaría hacerlo pero...
Código:
procedure DynArraySetLength(var a: Pointer; typeInfo: Pointer; dimCnt: Longint; lengthVec: PLongint); var i: Integer; newLength, oldLength, minLength: Longint; elSize: Longint; neededSize: Longint; p, pp: Pointer; begin p := a; // Fetch the new length of the array in this dimension, and the old length newLength := PLongint(lengthVec)^; if newLength <= 0 then begin if newLength < 0 then Error(reRangeError); DynArrayClear(a, typeInfo); exit; end; oldLength := 0; if p <> nil then begin Dec(PLongint(p)); oldLength := PLongint(p)^; Dec(PLongint(p)); end; // Calculate the needed size of the heap object Inc(PChar(typeInfo), Length(PDynArrayTypeInfo(typeInfo).name)); elSize := PDynArrayTypeInfo(typeInfo).elSize; if PDynArrayTypeInfo(typeInfo).elType <> nil then typeInfo := PDynArrayTypeInfo(typeInfo).elType^ else typeInfo := nil; neededSize := newLength*elSize; if neededSize div newLength <> elSize then Error(reRangeError); Inc(neededSize, Sizeof(Longint)*2); // If the heap object isn't shared (ref count = 1), just resize it. Otherwise, we make a copy if (p = nil) or (PLongint(p)^ = 1) then begin pp := p; if (newLength < oldLength) and (typeInfo <> nil) then FinalizeArray(PChar(p) + Sizeof(Longint)*2 + newLength*elSize, typeInfo, oldLength - newLength); ReallocMem(pp, neededSize); p := pp; end else begin Dec(PLongint(p)^); GetMem(p, neededSize); minLength := oldLength; if minLength > newLength then minLength := newLength; if typeInfo <> nil then begin FillChar((PChar(p) + Sizeof(Longint)*2)^, minLength*elSize, 0); CopyArray(PChar(p) + Sizeof(Longint)*2, a, typeInfo, minLength) end else Move(PChar(a)^, (PChar(p) + Sizeof(Longint)*2)^, minLength*elSize); end; // The heap object will now have a ref count of 1 and the new length PLongint(p)^ := 1; Inc(PLongint(p)); PLongint(p)^ := newLength; Inc(PLongint(p)); // Set the new memory to all zero bits FillChar((PChar(p) + elSize * oldLength)^, elSize * (newLength - oldLength), 0); // Take care of the inner dimensions, if any if dimCnt > 1 then begin Inc(lengthVec); Dec(dimCnt); for i := 0 to newLength-1 do DynArraySetLength(PPointerArray(p)[i], typeInfo, dimCnt, lengthVec); end; a := p; end; procedure _DynArraySetLength; asm { PROCEDURE _DynArraySetLength(var a: dynarray; typeInfo: PDynArrayTypeInfo; dimCnt: Longint; lengthVec: ^Longint) } { ->EAX Pointer to dynamic array (= pointer to pointer to heap object) } { EDX Pointer to type info for the dynamic array } { ECX number of dimensions } { [ESP+4] dimensions } PUSH ESP ADD dword ptr [ESP],4 CALL DynArraySetLength end; Si no es mucha molestia me gustaría saber, por lo menos, cuanto espacio reserva un array dinámico en memoria... ¿Alguien lo sabe? |
#4
|
||||
|
||||
Como conmemoración de mis 30 post editados (no os creais, son casi todo preguntas) he insertado un avatar en mi perfil... ¡dibujado por mí!
|
#5
|
|||
|
|||
Hola,
un array dinámico no es más que un puntero a una dirección de memoria así que si no has creado elementos para el array, este sólo ocupara los bytes necesarios para guardar una dirección que suele depender de la arquitectura (2 ó 4). Si quieres saber cuánto ocupa una vez creado hay que describirlo de la siguiente manera: Por un lado el puntero al array ocupa lo que ya te comenté y se suele ubicar en el segmento de datos o en la pila. Por otro lado, la memoria nueva que pides cuando creas el array suele ser memoria del Heap que crece en sentido contrario a la memoria de pila. ¿Qué implica esto? implica que si usas mucho heap, llegado un momento, este se solapa con la memoria de pila y, o bien al intentar pedir más memoria el SO te dice que no hay, o si no usas más memoria puede que el SO también de error porque necesita pila y no queda porque el espacio esta ocupado por la memoria de tu heap (por ejemplo el SO necesita pila para llamadas a procedimientos, calculos temporales,...). Es evidente que la gestión de memoria que trabaja aumentando en 1 los arrays es poco eficiente si tu aplicación va a estar continuamente insertando y eliminando elementos del array, pero es más seguro (digamos que pides la memoria justa que vas a necesitar). Por otro lado, si decides hacer incrementos de x en x cada vez que ves que te quedas sin espacio corres el riesgo de que el SO te diga no puede insertar en el array 1 elemento cuando en realidad si que cabe porque al intentar insertarlo, si ve que necesita más memoria pedirá espacio para x.(por ejemplo si queda espacio para 99 quieres insertar 1 y el intenta pedir 100 te dira que no). La politica depende de tu aplicación y la carga de trabajo sobre el array. Muchas clases implementadas en lenguajes con C++ o javap permiten definir si quieres que el array incremente en 1 o en más en caso de quedarse sin espacio. Para terminar te diré que el espacio real de tu array en un instante de tiempo sería el número de elementos que hay en ese instante por la cantidad de bytes de cada elemento (dependiente de la arquitectura). Bueno, espero que te haya servido de ayuda y un saludo. Última edición por piccolo2101 fecha: 01-02-2006 a las 10:52:28. |
#6
|
||||
|
||||
piccolo2101:
Gracias por las molestias; despues de haber leido tu post, he decidido que voy a aumentar/disminuir los elementos de la matriz en 1 con cada inserción/borrado; Los arrays que te comentaba son en realidad listas de punteros en Nodos Gráficos en un programa tipo Flow. Cada nodo tiene dos arrays: de entrada y de salida. Cuando establezco una conexión entre dos nodos (siempre a nivel de interface gráfico), se añade un puntero de salida en un nodo y otro de entrada en otro nodo, de forma que la inserción de datos no es masiva. Gracias de nuevo. |
Herramientas | Buscar en Tema |
Desplegado | |
|
|
Temas Similares | ||||
Tema | Autor | Foro | Respuestas | Último mensaje |
arrays dinamicos | Chompiras | Varios | 8 | 14-07-2015 22:49:51 |
Arrays dinámicos con Delphi.NET | mamen | .NET | 0 | 25-11-2004 14:21:35 |
manejo de la memoria en delphi | jac000y | Varios | 7 | 03-02-2004 15:03:28 |
CreateFileMapping (memoria compartida) | Al González | API de Windows | 2 | 18-12-2003 15:04:44 |
Arrays Dinamicos | mauro | Varios | 4 | 05-07-2003 21:14:29 |
|