Arrays dinámicos en memoria

[eliash]

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?

[delphi.com.ar]

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.

[eliash]

Me encantaría hacerlo pero...

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?

[eliash]

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

[piccolo2101]

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.

[eliash]

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.