Record zu TStringlist hinzufügen

[TiGü]

Zitat von EWeiss:

Zitat von DeddyH:

Wieso nicht? Ich sehe da auf Anhieb nichts in Deinem Code, das unbedingt Records und Arrays brauchen würde.

Du siehst aber schon wie viele Indexe ich benötige um die Sprites zu zuweisen?
Found, Count, FlagFound, Prop.RecycleBin ?

Sprite[Count].Top := Bottom;
Das ist ein Array oder?
Und das wollte ich nicht!
Somit hat sich das erledigt.

Geh schlafen Emil, du bist doch wahrscheinlich schon die ganze Nacht wach.
Und höre auf deine Beiträge ständig nach zu editieren, man weiß gar nicht auf was man antworten soll.
Erstelle einfach einen neuen Beitrag.

Das von jaenicke gezeigte Sprite[Count].Top := Bottom; ist ein ganz normaler Zugriff auf eine Liste.
Ja, auch Listen können mit Integer-Indizes angesprochen werden.

[EWeiss]

Zitat:

Das von jaenicke gezeigte Sprite[Count].Top := Bottom; ist ein ganz normaler Zugriff auf eine Liste.
Ja, auch Listen können mit Integer-Indizes angesprochen werden.

Und sind intern auch nichts anderes als Arrays.

gruss

[SneakyBagels]

Gibt es einen Grund, weshalb du keine Arrays möchtest?
Wenn man wüsste warum, könnte man vielleicht andere, bessere Lösungen ausarbeiten.

[TiGü]

Schau dir dieses simple Konsolenprogramm mal an und versuche die einzelnen Abschnitte zu verstehen:

Delphi-Quellcode:

program Project1;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  SysUtils,
  Generics.Collections;

type
  TSprite = class
    Top, Left, Right, Bottom: Integer;
    function ToString: string;
  end;

  TSprites = TObjectList<TSprite>;

  { TSprite }

function TSprite.ToString: string;
begin
  Result := 'Sprite-Werte' + sLineBreak;
  Result := Result + ' Top: ' + IntToStr(Top) + ' Left: ' + IntToStr(Left) + ' Right: ' + IntToStr(Right) + ' Bottom: ' +IntToStr(Bottom);
end;

procedure Main;
var
  SingleSprite: TSprite;
  Sprites: TSprites;
  I: Integer;
begin
  Sprites := TSprites.Create;
  try
    Sprites.Add(TSprite.Create);
    Sprites.Add(TSprite.Create);
    Sprites.Add(TSprite.Create);

    Writeln('Sprites.Count: ' + IntToStr(Sprites.Count));

    // Zugriff auf Listenelement - Variante 1
    Sprites[0].Top := 1;
    Sprites[0].Left := 2;
    Sprites[0].Right := 3;
    Sprites[0].Bottom := 4;

    // Zugriff auf Listenelement - Variante 2
    Sprites.Items[1].Top := 4;
    Sprites.Items[1].Left := 6;
    Sprites.Items[1].Right := 7;
    Sprites.Items[1].Bottom := 8;

    // Zugriff auf Listenelement - Variante 3
    SingleSprite := Sprites.Items[2];
    SingleSprite.Top := 9;
    SingleSprite.Left := 10;
    SingleSprite.Right := 11;
    SingleSprite.Bottom := 12;

    Writeln;

    Writeln('Iterieren durch die Liste mit Index:');
    for I := 0 to Sprites.Count - 1 do
    begin
      Writeln(IntToStr(I) + '. ' + Sprites.Items[I].ToString)
    end;

    Writeln;

    Writeln('Iterieren durch die Liste mit for-in:');
    for SingleSprite in Sprites do
    begin
      Writeln(SingleSprite.ToString)
    end;

    Writeln;

    Writeln('Löschen des mittleren Elements aus Sprites!');
    Sprites.Delete(1);
    Writeln('Sprites.Count: ' + IntToStr(Sprites.Count));

    Writeln;

    Writeln('Entfernen des ersten Elements aus Sprites!');
    SingleSprite :=  Sprites.First;
    Sprites.Remove(SingleSprite);
    Writeln('Sprites.Count: ' + IntToStr(Sprites.Count));
  finally
    Sprites.Free;
  end;
end;

begin
  try
    Main;
    Readln;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;

end.

[Lemmy]

Zitat von EWeiss:

Zitat:

Das von jaenicke gezeigte Sprite[Count].Top := Bottom; ist ein ganz normaler Zugriff auf eine Liste.
Ja, auch Listen können mit Integer-Indizes angesprochen werden.

Und sind intern auch nichts anderes als Arrays.

nein, Listen sind Listen und Arrays sind Arrays. Listen verwalten ihren benötigten Speicher in aller Regel selbst (es macht bei bestimmten AKtionen ggf. Sinn hier selbst Hand anzulegen), bei Arrays machst Du das selbst. Dazu kommen noch einige weitere Vorteile von Listen (Sort, typsicherer Zugriff bei generischen Listen,...). Ich habe vor 3 Wochen das erste mal seit mehreren Jahren wieder mit einem Array arbeiten müssen und habe mnir fast die Finger gebrochen...

[EWeiss]

Zitat:

und habe mnir fast die Finger gebrochen...

Hoffe es hat nicht zu sehr weh getan.

Na ja..
Warum ich das machen will hat eigentlich mit der Code Struktur zu tun.
Ich möchte das ganze etwas aufgeräumt haben bevor ich den Quelltext hoch lade.

Das mit den Arrays ist ein totales Kuddelmuddel.
Deshalb will ich das weg haben. (Aber nicht mit aller Gewalt, wenn es nicht geht lass ich es lieber).

gruss

[Jumpy]

Zitat von EWeiss:

Das mit den Arrays ist ein totales Kuddelmuddel.
Deshalb will ich das weg haben. (Aber nicht mit aller Gewalt, wenn es nicht geht lass ich es lieber).

Vielleicht siehst du das mal als mehrstufigen Prozess an. Zunächst ersetzt du das Array durch die Liste und machst die dafür nötigen minimalen Änderungen im Code (z.B. Muss du die Liste nicht dimensionieren, Count statt High, usw.). Nun hast du erstmal nicht viel anderes als vorher, aber wenn es läuft ist schon mal der erste Schritt gemacht.
Dann kannst du deinen Code an die Möglichkeiten der Liste anpassen, das was du machen willst um den "Salat" aufzuräumen, den du siehst, wobei von außen betrachtet jetzt nicht klar ist, was das sein könnte, aber man könnte z.B. for-Schleifen mit Index durch for each Schleifen erstzen usw.

[Union]

So würde ich das ansatzweise machen. Minimale Implementation:

Delphi-Quellcode:

type
  // Du nimmst natürlich Deinen Record
  TDataRecord = record
    Name : string[20];
    Zahl : Integer;
  end;

  PDataRecord = ^TDataRecord;


  TDataRecordList = class(TList)
  protected
    function GetItem(AIndex: Integer): PDataRecord;
    procedure SetItem(AIndex: Integer; const Value: PDataRecord);
  public
    function Add(AData: TDataRecord): Integer;
    procedure Clear; override;
    property Items[AIndex : Integer] : PDataRecord read GetItem write SetItem; default;
  end;

implementation

{ TDataRecordList }

function TDataRecordList.Add(AData: TDataRecord): Integer;
var
  PData : PDataRecord;
begin
  New(PData);
  // Record-Inhalt kopieren (evtl. auch mit move). So bleibt Erzeugung und Freigabe in der Klasse.
  // Natürlich könnte man ein Overload von Add mit PData machen.
  PData.Name := AData.Name;
  PData.Zahl := AData.Zahl;
  Result := inherited Add(PData);
end;

procedure TDataRecordList.Clear;
var
  PData : PDataRecord;
  I     : Integer;
begin
  for I := 0 to Count - 1 do
  begin
    PData := Items[I];
    Dispose(PData);
  end;
  inherited;
end;

// Setter und Getter geben jeweils wieder den Pointer zurück, um sich Kopiervorgänge zu ersparen
function TDataRecordList.GetItem(AIndex: Integer): PDataRecord;
begin
  Result := inherited Items[AIndex];
end;

procedure TDataRecordList.SetItem(AIndex: Integer; const Value: PDataRecord);
begin
  inherited Items[AIndex] := Value; 
end;

[EWeiss]

Danke für das Beispiel.. Im Moment scheint es zu gehen obwohl in der Liste 2 Einträge mehr addiert werden als ich initialisiert habe.
Macht Probleme wenn ich den Count überprüfe.

Siehe Pic!
Warum werden mehr Einträge addiert?

gruss