Foros Club Delphi - Arrays dinámicos en memoria

Foros Club Delphi (https://www.clubdelphi.com/foros/index.php)

- OOP (https://www.clubdelphi.com/foros/forumdisplay.php?f=5)

- - Arrays dinámicos en memoria (https://www.clubdelphi.com/foros/showthread.php?t=29703)

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?

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.

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;

Ésto me sobrepasa ampliamente. De hecho no se ni por donde cogerlo :|
Si no es mucha molestia me gustaría saber, por lo menos, cuanto espacio reserva un array dinámico en memoria...
¿Alguien lo sabe?

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í!

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.

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.