Record zu TStringlist hinzufügen

[EWeiss]

Zitat von DeddyH:

Nochmal ganz langsam: wie spricht man ein Array-Element an?
Array[Index] Und ein Listenelement?
List[Index] Mal abgesehen von Low() und High() müsste am Zugriff auf die Elemente doch nichts ändern. Sry, ich verstehe Deine Einwände nicht.

Ich wollte keine Arrays und das ist eins!
Sprite[Count].Top := Bottom;

Array habe ich schon warum dann extra eine Liste wie auch immer verwenden wenn ich doch wieder Array nutzen muss.
Sprite: TArray<TSprite>;

gruss

[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.

[jaenicke]

Zitat von EWeiss:

Ich wollte keine Arrays und das ist eins!
Sprite[Count].Top := Bottom;

Es ist ein indexbasierter Zugriff. Ob auf ein Array oder eine Liste kann man an der Zeile nicht unterscheiden.
Im Falle einer Liste läuft das ganze auf eine Index-Property mit einer Getter-Methode, die das Element zurückliefert.

Sinnvoll ist aus Performancegründen natürlich eher ohne die vielen Indexzugriffe zu arbeiten und das aktuelle Element in eine Variable zu packen:

Delphi-Quellcode:

var
  Sprites: TObjectList<TSprite>;
  Sprite: TSprite;
begin
  ...
  Sprite := Sprites[Count];
  Sprite.Top := ...;
  Sprite.Def := ...;

Meinst du das?

[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.

[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...

[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.

[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

[EWeiss]

Zitat von jaenicke:

Zitat von EWeiss:

Ich wollte keine Arrays und das ist eins!
Sprite[Count].Top := Bottom;

Es ist ein indexbasierter Zugriff. Ob auf ein Array oder eine Liste kann man an der Zeile nicht unterscheiden.
Im Falle einer Liste läuft das ganze auf eine Index-Property mit einer Getter-Methode, die das Element zurückliefert.

Sinnvoll ist aus Performancegründen natürlich eher ohne die vielen Indexzugriffe zu arbeiten und das aktuelle Element in eine Variable zu packen:

Delphi-Quellcode:

var
  Sprites: TObjectList<TSprite>;
  Sprite: TSprite;
begin
  ...
  Sprite := Sprites[Count];
  Sprite.Top := ...;
  Sprite.Def := ...;

Meinst du das?

genau so wollte ich das haben..

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.