Pointer :\

[Hansa]

Wie man an Dannyboys Beispiel schön sieht : er hat soviel Speicher reserviert, wie er maximal glaubt zu brauchen. Verschätzt er sich so hat er Pech. Ist der Platz zu gering bemessen dann auch.

Jetzt kommen Dateien und Listen ins Spiel. Letzteres ist wohl das, was du unter deinen "Porintern" verstehst. :mrgreen: Das betrifft aber nur den Hauptspeicher. Geht also nur, während das Programm läuft. Soll es gespeichert werden, na dann sind Dateien vorzuziehen.

[Dannyboy]

Zitat:

Wie man an Dannyboys Beispiel schön sieht : er hat soviel Speicher reserviert, wie er maximal glaubt zu brauchen. Verschätzt er sich so hat er Pech. Ist der Platz zu gering bemessen dann auch.

@Hansa:
In meinem Beispiel wollte ich illustrieren, dass man ein großes, statisches Array in eine Datei
schreiben kann. Das hat gar nichts mit verschätzen zu tun, da hier gar nix berechnet werden muss
und es ging in meinem Beispiel auch gar nicht um irgend was dynamisches. Es ist einfach
nur ein großes, gefülltes, statisches Array, das in eine Datei geschoben wird.
Da ich die Datenstrukturen von Snoop007 nicht kenne, habe ich exemplarisch (er hatte bisher noch
nichts mit Filestreams gemacht) einfach mal die Größe des kompletten Arrays (bzw. Records)
übergeben. Ich kann bisher noch nicht erkennen, in wiefern ein solcher Stream einem dynamischen
Element (lineare Liste, binärer Baum, etc.) im Wege stehen sollte.
Du, Hansa, schreibst von der Verwaltung von Speicher und ich schreibe von Streams. ... Das eine
hat mit dem anderen erst mal nix zu tun, bis zu dem Zeitpunkt, in dem die Daten in eine Datei
transportiert werden. Ich sehe kein Problem darin, einzelne Einträge einer dynamischen Liste
in einen Stream zu packen und in Datei zu speichern.
Wo hakt's denn? :gruebel:

[Hansa]

Zitat:

Zitat von Dannyboy

Wo hakt's denn? :gruebel:

Bei mir nirgends. :mrgreen: Jetzt hat er ja 2 Beispiele. Bzw. nur das von dir und meinen Vorschlag, wie es gehen kann, wenn es eben so nicht geht. :P Und das wird sowieso komplizierter. Also da ist jetzt eher snoop007 gefordert. Los, komm schon und sage uns was du genau willst. :shock:

[Dannyboy]

Wir hatten damals im Informatik-Untericht die ganzen Listen und Bäume selbst mit
Zeigern schreiben dürfen (Pascal 7). In Delphi gibt's ja bestimmt vordefinierte
Konstrukte dafür, so dass man sich den Stress sparen kann.

[maximov]

Moin,

alle die mit streams dynamische formate schreiben und laden wollen kann ich nur die TFiler klassen (TReader und TWriter) ans herz legen. Die sind wirklich sehr leicht in der handhabung und bieten für alle gängigen stadardtypen entsprechende funktion. Somit muss man sich nicht mehr mit buffern und der länge der daten herrum schlagen und kann sehr schön sequenziell lesen und schreiben.

Hier ein beispiel zum streamen einer 2D map:

Delphi-Quellcode:

Function TMap.SaveToStream(stream: TStream):Boolean;
Var writer : TWriter;
    i      : integer;
begin
  result := true;
  writer := TWriter.Create(stream, $ff);
  try
    try
      writer.WriteSignature;
      writer.WriteListBegin;
      writer.WriteString(ClassName);
      WriteData(writer);
      writer.WriteListEnd;
    except
      result := false
    end;
  finally
    writer.Free;
  end;
end;

Function TMap.LoadFromStream(stream: TStream):Boolean;
Var reader : TReader;
    ctype  : TPersistentClass;
    cname  : string;
begin
  result := true;
  reader:=TReader.Create(stream,$FFFF);
  try
    with reader do begin
      {read at beginning of file}
      ReadSignature;
      ReadListBegin;
      cname := ReadString;
      ctype := GetClass(cname);
      if Assigned(ctype) then
      begin
        try
          ReadData(reader);
        except
          result := False;
        end;
      end;
      ReadListEnd;
    end;
  finally
    reader.Free;
  end;
end;

procedure TMap.ReadData(reader: TReader);
var x,y,size : integer;
begin
 size := sizeOf(TField);
 with reader do begin
       MapName           := ReadString;
       coment         := ReadString;
       Bounds.X       := ReadInteger;
       Bounds.Y       := ReadInteger;
       //-- Read matrix -----
       SetToBounds(bounds,false);
       for x := 0 to Bounds.X-1 do
         for y := 0 to Bounds.Y-1 do
           Read(matrix[x,y],size);
       //----------------------
       ReadString;
       style          := Readinteger;
       mode           := Readinteger;
       TimeLimit      := Readinteger;
       GUID           := ReadString;
       Creator        := ReadString;
       CreateDate     := ReadDate;
  end;
end;

procedure TMap.WriteData(writer: TWriter);
var x,y,size : integer;
begin
  size := sizeOf(TField);
  with writer do begin
     WriteString(MapName);
     WriteString(coment);
     WriteInteger(Bounds.X);
     WriteInteger(Bounds.Y);
     //-- Write matrix -----
     for x := 0 to Bounds.X-1 do
       for y := 0 to Bounds.Y-1 do
         Write(matrix[x,y],size);
     //----------------------
     WriteString('');
     Writeinteger(style);
     Writeinteger(mode);
     Writeinteger(TimeLimit);
     WriteString(GUID);
     WriteString(Creator);
     WriteDate(CreateDate);
  end;
end;

Nur so als anregung, da ihr grad über dynamische (oder auch nicht) formate redet. Was meint ihr?

[Snoop007]

:gruebel: ihr machts einem auch nicht leicht ^^

das mit den pointern habe ich es so gemeint wie ich esgeschrieben hatte, ich kenne den unterschied, *g vielleicht hab ich mich auch falsch ausgedrückt, oder ich habe versucht was unmögliches zu machen, wie es aus sah, also nochmal kurz dazu

ich wollte statt den wert der variabeln vom typ File, einfach einen pointer, der auf diese variable zeigt, übergeben und mit diesem pointer weiter hantieren, scheint aber nicht zu gehen ok, abgehkt :)

zu filestream, die liste sollte schon dynamisch sein, da ich nicht so viel speicher reservieren möchte,
die komponente beinhaltet mehrere dynamische attribute

ich frage mich nur, ob man mit filestream auch dynamische listen recht einfach speichern kann,
recht einfach soll hier heissen, ich gebe einfach nur den typ / das 1. element des array(liste) an
anstatt das gesamte array (liste) zu druchlaufen und jeweils den wert speichern

dass das mit typen ( records die ein "ende" haben ) geht, ist klar

[Hansa]

Was du machen willst hört sich wirklich nach der Quadratur des Kreises an. Ich habe so was schon befürchtet. 8)

Also nochmals : was soll gespeichert werden ? Ist die Gesamtgröße stark variabel, oder die einzelnen Elemente ? Sogar in letzterem Fall gibt es noch eine Variante. Nämlich variante Records. Verstehe sowieso nicht ganz, warum du das mit Pointern machen willst. Normalerweise will sich jeder davor drücken. Meist wird nach Auswegen gesucht, um da drumrum zu kommen. :mrgreen:

[teebee]

Wenn Dein dynamische Array ausschliesslich Nicht-Zeiger-Typen (keine Strings, Objekte) beinhaltet und auch nur eindimensional ist, kannst Du es mit einer SizeOf*Length-Konstruktion wie beim statischen Array an einen Stream übergeben.
In allen anderen Fällen musst du jeden einzelnen Wert durchlaufen.

Gruß, teebee

[Snoop007]

hehe, die komponente sollte so schnell wie möglich daten verarbeiten können

die komponente ist eine klasse, die 2 records beinhaltet,
diese 2 records haben ca. 2 - 3 records und paar dynamische listen
die records der records haben dynamische elemente so und da ich nun alle durcheinander gebracht habe
sell ich das mal grafisch dar :mrgreen:

Code:

Hauptkomponente ( class )
|
--record 
|   |
|   |- record
|   |- record
|       |- attribute
|       |- attribute [] ( länge dynamisch )
|   | - record
|   |- attribute
|   |- attribute [] ( länge dynamisch )
|  
|--record 
  |- record
  |- attribute
  |- attribute [] ( länge dynamisch )
  |- attribute [] ( länge dynamisch )

gespeichert werden soll die hauptkomponente

ich wollte schon anfangen die listen zu druchlaufen und jedes elemt der liste einzeln zu speichern, wäre ja schönn wenn das mit erspart bliebe :mrgreen:

aber ich glaube das geht nicht

edit : doch, die array bestehen meist aus strings allerding mit "nur" 254 zeichen

[teebee]

Ein wichtiges weiteres Problem ist übrigens bei dynamischen Längen das Einlesen: Du musst wissen, von wo bis wo Do einlesen musst, also muss die Länge eines Blocks irgendwo stehen. Ich denke, um eine eigene Speicherlogik wirst Du nicht herumkommen.

Gruß, teebee