baum bestehend aus arrays abspeichern

[SirThornberry]

Gibt es nur soviel Strings (A) wieviel Knoten es auch gibt (S)?

Hier die Speichern- und Laden-Procedure, allerdings ungetestet

Delphi-Quellcode:

procedure LoadKnotFromStream(AStream: TStream; AKnot: PKnot);
var LChilds, LCount, LInt: Integer;
begin
  AStream.Read(LChilds, SizeOf(LChilds));
  for LCount := 1 to 11 do
  begin
    if LCount <= LChilds then
    begin
      //Länge des Strings lesen
      AStream.Read(LInt, SizeOf(LInt));
      setlength(AKnot.A[LCount], LInt);
      //String aus Stream lesen
      AStream.Read(AKnot.A[LCount][1], LInt);
      //speicher für unterknoten anfordern
      new(AKnot.S[LCount]);
      LoadKnotFromStream(AStream, AKnot.S[LCount]);
    end else
      AKnot.S[LCount] := nil;
  end;
end;

procedure SaveKnotToStream(AStream: TStream; AKnot: PKnot);
var LChilds, LCount, LInt: Integer;
begin
  //ermitteln wieviel Chidls
  LChilds := 0;
  while (LChilds < 11) and (AKnot.S[LChilds + 1] <> nil) do
    inc(LChilds);
  //Anzahl der Childs in Stream speichern
  AStream.Write(LChilds, SizeOf(LChilds));
  //Childs durchgehen
  for LCount := 1 to LChilds do
  begin
    //Länge des Strings ermitteln
    LInt := Length(AKnot.A[LCount]);
    //Länge des Strings speichern
    AStream.Write(LInt, SizeOf(LInt));
    //String speichern
    AStream.Write(AKnot.A[LCount][1], LInt);
    //unterKnoten aufrufen
    SaveKnotToStream(AStream, AKnot.S[LChilds]);
  end;
end;

irgendwo wirst du ja einen RootKnoten vom Typ "TKnot" haben. Somit erfolgt der Aufruf so:

Delphi-Quellcode:

var LStream: TStream;
begin
  LStream := TMemoryStream.Create;
  SaveKnotToStream(LStream, PKnot(@YourRootKnot));
  LStream.SaveToFile('xyz.txt');
  LStream.Free;
end;

Laden funkioniert dann nach dem gleichen Prinzip.

[brutus]

nein es kann z.b. auch folgender maßen aufgebaut sein:

Knoten 1: besteht aus 4 strings und verweist 2 andere Knoten die aus 3 und 6 strings bestehen u.s.w.

[brutus]

DANKE ! ! ! ich werd es gleich mal ausprobieren !!!

[SirThornberry]

hmm, dann müsst ich bzw. eher du den source bissl abändern.
woher weißt du wieviel Stings benötigt werden (also abgespeicher werden müssen). Mit <> nil gehts ja diesmal nicht.

So hier mal abgeänderter Source um alle 11 Strings abzuspeichern (ungetestet)

Delphi-Quellcode:

procedure LoadKnotFromStream(AStream: TStream; AKnot: PKnot);
var LChilds, LCount, LInt: Integer;
begin
  for LCount := 1 to 11 do
  begin
    //Länge des Strings lesen
    AStream.Read(LInt, SizeOf(LInt));
    setlength(AKnot.A[LCount], LInt);
    //String aus Stream lesen
    AStream.Read(AKnot.A[LCount][1], LInt);
  end;

  AStream.Read(LChilds, SizeOf(LChilds));
  for LCount := 1 to 11 do
  begin
    if LCount <= LChilds then
    begin
      //speicher für unterknoten anfordern
      new(AKnot.S[LCount]);
      LoadKnotFromStream(AStream, AKnot.S[LCount]);
    end else
      AKnot.S[LCount] := nil;
  end;
end;

procedure SaveKnotToStream(AStream: TStream; AKnot: PKnot);
var LChilds, LCount, LInt: Integer;
begin
  for LCount := 1 to 11 do
  begin
    //Länge des Strings ermitteln
    LInt := Length(AKnot.A[LCount]);
    //Länge des Strings speichern
    AStream.Write(LInt, SizeOf(LInt));
    //String speichern
    AStream.Write(AKnot.A[LCount][1], LInt);
  end;

  //ermitteln wieviel Chidls
  LChilds := 0;
  while (LChilds < 11) and (AKnot.S[LChilds + 1] <> nil) do
    inc(LChilds);
  //Anzahl der Childs in Stream speichern
  AStream.Write(LChilds, SizeOf(LChilds));
  //Childs durchgehen
  for LCount := 1 to LChilds do
    SaveKnotToStream(AStream, AKnot.S[LChilds]);
end;

[brutus]

der benutzer gibt an (per radiobutton.activated) wieviel strings benötigt werden und wie sie gefüllt werden

[SirThornberry]

ok, hier schonmal die speichernprocedure

Delphi-Quellcode:

function LoadKnotFromFile(AFilename: String; AKnot: TKnot): Integer;
  procedure LLoadKnotFromStream(AStream: TStream; APKnot: PKnot; AStrCount: Integer);
  var LChilds, LCount, LInt: Integer;
  begin
    for LCount := 1 to AStrCount do
    begin
      //Länge des Strings lesen
      AStream.Read(LInt, SizeOf(LInt));
      setlength(APKnot.A[LCount], LInt);
      //String aus Stream lesen
      AStream.Read(APKnot.A[LCount][1], LInt);
    end;

    AStream.Read(LChilds, SizeOf(LChilds));
    for LCount := 1 to 11 do
    begin
      if LCount <= LChilds then
      begin
        //speicher für unterknoten anfordern
        new(APKnot.S[LCount]);
        LLoadKnotFromStream(AStream, APKnot.S[LCount], AStrCount);
      end else
        APKnot.S[LCount] := nil;
    end;
  end;
var LStream: TMemoryStream;
    LStrCount: Integer;
begin
  LStream := TMemoryStream.Create;
  LStream.LoadFromFile(AFilename);
  LStream.Read(LStrCount, SizeOf(LStrCount));
  LLoadKnotFromStream(LStream, @AKnot, LStrCount);
  LStream.Free;
  result := LStrCount;
end;

procedure SaveToFile(AFilename: String; AKnot: TKnot; AStrCount: Integer);
  procedure LSaveKnotToStream(AStream: TStream; APKnot: PKnot);
  var LChilds, LCount, LInt: Integer;
  begin
    for LCount := 1 to AStrCount do
    begin
      //Länge des Strings ermitteln
      LInt := Length(APKnot.A[LCount]);
      //Länge des Strings speichern
      AStream.Write(LInt, SizeOf(LInt));
      //String speichern
      AStream.Write(APKnot.A[LCount][1], LInt);
    end;

    //ermitteln wieviel Chidls
    LChilds := 0;
    while (LChilds < 11) and (APKnot.S[LChilds + 1] <> nil) do
      inc(LChilds);
    //Anzahl der Childs in Stream speichern
    AStream.Write(LChilds, SizeOf(LChilds));
    //Childs durchgehen
    for LCount := 1 to LChilds do
      LSaveKnotToStream(AStream, APKnot.S[LChilds]);
  end;
var LStream: TMemoryStream;
begin
  LStream := TMemoryStream.Create;
  LStream.Write(AStrCount, SizeOf(AStrCount));
  LSaveKnotToStream(LStream, @AKnot);
  LStream.SaveToFile(AFilename);
  LStream.Free;
end;