Stack Overflow al declarar arrays

[ecfisa]

Hola jularaXD.

Mas allá del tamaño de tu arreglo en memoria (50000*6*11 = 33.14713 Mb), podría suceder que mas adelante se les ocurra pedirte que obtengas el valor de una monitorización de un año atrás... Entonces tendrás para manejar 397,69 Mb aprox.

Como sugirió Lepe, lo podes gestionar de manera sencilla usando listas dinámicas como en este esbozo al vuelo:

Código Delphi [-]
...
uses contnrs;

type
  TStr10 = string[10];
  TClase = class
    v: array[0..5] of TStr10;
  end;

var
  List: TObjectList;

procedure TForm1.FormCreate(Sender: TObject);
var
  i: Integer;
  C: TClase;
begin
  List:= TObjectList.Create;
  for i:= 0 to 100 do
  begin
    C:= TClase.Create;
    C.v[0]:= 'cero';
    C.v[1]:= 'uno';
    C.v[2]:= 'dos';
    c.v[3]:= 'tres';
    c.v[4]:= 'cuatro';
    c.v[5]:= 'cinco';
    List.Add(TObject(C));
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  col,row: Integer;
  s: string;
begin
  for row:= 0 to 100 do
  begin
    s:= IntToStr(row)+') ';
    for col:= 0 to 5 do s:= s + TClase(List[row]).v[col] + ',';
    SetLength(s,Length(s)-1);
    ListBox1.Items.Add(s);
  end;
end;
...

también con un árbol binario de búsqueda o un arreglo de apuntadores, cada una con sus pros y contras. Estas soluciones han sido (y son), usadas como las mejores en los procesamientos de arreglos casi vacíos, vg.: planillas de cálculo.

O también,como sugirió duiliosola, mediante un archivo de acceso directo :

Código Delphi [-]
unit Directo;

interface

type
  TStr10     = string[10];
  TDataClass = class
  private
    FData    : array[0..5] of TStr10;
    FFileName: string;
    function  GetDatos(Index: Integer): TStr10;
    procedure SetDatos(Index: Integer; const Value: TStr10);
    function  GetSize: Integer;
  public
    property  FileName: string read FFileName write FFileName;
    property  Data[Index: Integer]: TStr10 read GetDatos write SetDatos; default;
    procedure Open;
    property  Size: Integer read GetSize;
    procedure ReadData(const Posic: Integer);
    procedure SaveData(const Posic: Integer);
    procedure AppendData;
    procedure Close;
    //...
  end;

implementation

uses SysUtils;

type
  TRegData = packed record
    VData: array[0..5] of TStr10;
  end;
  TFileReg = file of TRegData;

var
  RegData : TRegData;
  FileReg: TFileReg;

procedure TDataClass.Open;
begin
  if FFileName = EmptyStr then
    raise Exception.Create('Falta el nombre de archivo');
  AssignFile(FileReg, FFileName);
  try
    Reset(FileReg);
  except
    Rewrite(FileReg);
  end;
end;

function TDataClass.GetDatos(Index: Integer): TStr10;
begin
  Result:= FData[Index];
end;

procedure TDataClass.SetDatos(Index: Integer; const Value: TStr10);
begin
  FData[Index]:= Value;
end;

function TDataClass.GetSize: Integer;
begin
  Result:= FileSize(FileReg);
end;

procedure TDataClass.ReadData(const Posic: Integer);
begin
  if Posic >= Size then
    raise Exception.Create('Índice fuera de rango');
  Seek(FileReg, Posic);
  Read(FileReg, RegData);
  Move(RegData.VData, FData, SizeOf(FData));
end;

procedure TDataClass.SaveData(const Posic: Integer);
begin
  if Posic >= Size then
    raise Exception.Create('Índice fuera de rango');
  Move(FData, RegData.VData, SizeOf(RegData.VData));
  Seek(FileReg, Posic);
  Write(FileReg, RegData);
end;

procedure TDataClass.AppendData;
begin
  Move(FData, RegData.VData, SizeOf(RegData.VData));
  Seek(FileReg, FileSize(FileReg));
  Write(FileReg, RegData);
end;

procedure TDataClass.Close;
begin
  CloseFile(FileReg);
end;
//...
end.

Pero en términos de simpleza, fiabilidad y escalabilidad pienso que almacenar esos valores de monitorización como campos de una tabla de una base de datos tampoco es mala idea.

Saludos

[jularaXD]

Muchas gracias a todos por vuestras respuestas y disculpad el retraso, que este fin de semana he estado muy liado...
Ahora me voy a poner a rehacer el código a ver con que método me quedare, supongo con el de las listas dinámicas, ya que me iría bien un algoritmo de ordenación, pero la verdad es que todos me van a servir en algún momento u otro.

Salu2

[[nlsgarcia]]

jularaXD,

Empezado por jularaXD

...estoy creando arrays de un gran tamaño...Mirando el array en el modo debug puedo apreciar que en las últimas filas hay datos que no están vacíos...¿Como podría solucionar este problema?...

Revisa este código:

Código Delphi [-]
procedure TForm1.Button1Click(Sender: TObject);
var
   A1 : Array[0..49999, 0..5] of String[10];
begin
   FillChar(A1, SizeOf(A1),' ');
end;

El código anterior inicializa a blancos un arreglo de dos dimensiones de tipo String[10].

Espero sea útil

Nelson.

[[nlsgarcia]]

jularaXD,

Empezado por jularaXD

...estoy creando arrays de un gran tamaño, ya que tengo ficheros con registros que quiero cargar y procesar...de esta forma puedo buscar datos en concreto dentro del archivo sin tener que leer el archivo de principio a fin...

Revisa este código:

Código Delphi [-]
unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

  TMonitor = record
     CodMon : Array[0..9] of Char;
     FecMon : Array[0..9] of Char;
     DesMon : Array[0..29] of Char;
     CRLF : Array[0..1] of Char;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure ProcessFile(FileName , CodMon : String);
var
   M : TMemoryStream;
   Buffer : TMonitor;

begin

   try

      M := TMemoryStream.Create;
      M.LoadFromFile(FileName);
      M.Seek(0,soFromBeginning);
      while M.Position < M.Size do
      begin
         M.Read(Buffer, SizeOf(Buffer));
         if Buffer.CodMon = CodMon then
         begin
            ShowMessage('Proceso a Realizar');
         end;
      end;

      MessageDlg('Archivo Procesado',mtInformation,[mbOK],0)

   except

      MessageDlg('Error en Procesamiento de Archivo',mtError,[mbOK],0)

   end;

   M.Free;

end;

procedure TForm1.Button1Click(Sender: TObject);
var
   FileName : String;
   CodMon : String;
begin
   FileName := 'FileMon.txt';
   CodMon := '0000100000';
   ProcessFile(FileName, CodMon);
end;

end.

El código anterior permite cargar dinámicamente un archivo en disco a memoria utilizando solo la memoria mínima requerida, procesar el mismo y liberar la memoria al finalizar el proceso, esto es una alternativa al concepto de un arreglo de registros. En el caso de querer procesar un registro particular, por ejemplo el número 11 (Los registros se numeran de 0 a n) se puede ir directamente a este por medio del siguiente código:

Código Delphi [-]
begin
   M.Seek(SizeOf(Buffer)*10,soFromBeginning);
end;

Nota: El código sugerido fue probado con un archivo de texto de 100.000 Registros con un tiempo de proceso en el orden de las milésimas de segundos.

Espero sea útil

Nelson.