Record zu TStringlist hinzufügen

[EWeiss]

Zitat:

Zitat von DeddyH (Beitrag 1374366)

Nochmal ganz langsam: wie spricht man ein Array-Element an?

Delphi-Quellcode:

Array[Index]

Und ein Listenelement?

Delphi-Quellcode:

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!

Delphi-Quellcode:

Sprite[Count].Top := Bottom;

Array habe ich schon warum dann extra eine Liste wie auch immer verwenden wenn ich doch wieder Array nutzen muss.

Delphi-Quellcode:

Sprite: TArray<TSprite>;

gruss

[TiGü]

Zitat:

Zitat von EWeiss (Beitrag 1374365)

Zitat:

Zitat von DeddyH (Beitrag 1374363)

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 ?

Delphi-Quellcode:

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

Delphi-Quellcode:

Sprite[Count].Top := Bottom;

ist ein ganz normaler Zugriff auf eine Liste.
Ja, auch Listen können mit Integer-Indizes angesprochen werden.

[jaenicke]

Zitat:

Zitat von EWeiss (Beitrag 1374367)

Ich wollte keine Arrays und das ist eins!

Delphi-Quellcode:

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:

Zitat von EWeiss (Beitrag 1374370)

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:

Zitat von jaenicke (Beitrag 1374369)

Zitat:

Zitat von EWeiss (Beitrag 1374367)

Ich wollte keine Arrays und das ist eins!

Delphi-Quellcode:

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:

Zitat von EWeiss (Beitrag 1374375)

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

[Daniel]

Dem Screenshot nach steht Count auf "6", was den Einträgen #0 bis #5 entspricht. Alles korrekt.
Wie die Liste sich intern verwaltet, manchmal dimensioniert sie das interne Array eine Idee größer (Stichwort Eigenschaft "Grow"), ist nur für sie selbst von Bedeutung.

[EWeiss]

Zitat:

Zitat von Daniel (Beitrag 1374384)

Dem Screenshot nach steht Count auf "6", was den Einträgen #0 bis #5 entspricht. Alles korrekt.
Wie die Liste sich intern verwaltet, manchmal dimensioniert sie das interne Array eine Idee größer (Stichwort Eigenschaft "Grow"), ist nur für sie selbst von Bedeutung.

Hmmmm bekomme aber einen falschen Count das führt zum Absturz.
Habe ja noch 6 und 7 auch wenn sie NIL sind.

Werden diese mitgezählt beim Sprites.Count ?.
Sorry habe mich mit dem Kram noch nie beschäftigt.

gruss

[DeddyH]

Nein, Count sollte in Deinem Fall 6 ergeben (man darf Count nicht mit Capacity verwechseln).

[EWeiss]

Zitat:

Zitat von DeddyH (Beitrag 1374386)

Nein, Count sollte in Deinem Fall 6 ergeben (man darf Count nicht mit Capacity verwechseln).

Ok Danke ;)

gruss

[EWeiss]

Habe da jetzt ein kleines Problem ;)
Wie kann ich die Einträge in der Liste verschieben ?

Delphi-Quellcode:

                  if (Item + ID_MAIN) <> FlagFound then
                  begin
                    if Prop.ShortCutfound > 0 then
                      NewLen := Sprites.Count + Prop.ShortCutfound
                    else
                      NewLen := Sprites.Count;

                    Sprites.Add(TSprite.Create);
                    CreateRecycleBin(MainHandle, NewLen);
                    for x := ID_FIRST to NewLen do
                    begin
                      Sprites[x] := Sprites[x + 1];
                      if x = (NewLen - Prop.ShortCutfound) then
                      begin
                        for X1 := (NewLen - 1) downto (NewLen - Prop.ShortCutfound) do
                          Sprites.Delete(X1);
                      end;
                    end;
                    FlagFound := count;
                  end;

vorher mit dem Array war das kein Problem.

Delphi-Quellcode:

                  if (Item + ID_MAIN) <> FlagFound then
                  begin
                    if Prop.ShortCutfound > 0 then
                      NewLen := High(Sprite) + Prop.ShortCutfound
                    else
                      NewLen := High(Sprite) + 1;

                    Setlength(Sprite, NewLen);
                    CreateRecycleBin(MainHandle, NewLen);
                    for x := ID_FIRST to NewLen do
                    begin
                      Sprite[x] := Sprite[x + 1];
                      if x = (NewLen - Prop.ShortCutfound) then
                      begin
                        for X1 := (NewLen - 1) downto (NewLen - Prop.ShortCutfound) do
                          Delete(Sprite, X1);
                      end;
                    end;
                    FlagFound := count;
                  end;

gruss

[Daniel]

Delphi-Quellcode:

TList<>.Move

bzw.

Delphi-Quellcode:

TList<>.Exchange

.
http://docwiki.embarcadero.com/Libra...TList.Exchange

[EWeiss]

Zitat:

Zitat von Daniel (Beitrag 1374395)

Delphi-Quellcode:

TList<>.Move

bzw.

Delphi-Quellcode:

TList<>.Exchange

.
http://docwiki.embarcadero.com/Libra...TList.Exchange

Danke werde es mal versuchen ;)

gruss

[EWeiss]

Noch ein einfache frage.. reicht ein einfaches Free damit alle Classen freigegeben werden oder muss ich da
noch etwas besonderes beachten?

gruss

[SneakyBagels]

Soweit ich weiß muss man jedes Objekt selber freigeben und dann die Liste.

[haentschman]

Moin...:P
Mit TList<> mußt du dich selbst um die Freigabe kümmern. Die TObjectList<> kümmert sich selbst um die Freigabe. 8-)

[EWeiss]

Zitat:

Zitat von haentschman (Beitrag 1374422)

Moin...:P
Mit TList<> mußt du dich selbst um die Freigabe kümmern. Die TObjectList<> kümmert sich selbst um die Freigabe. 8-)

Ok ;)
Da ich TObjectList verwende sollte das dann reichen.
OK bevor ich diese Freigebe lösche ich natürlich noch die Bitmap Ressourcen.

Mehr ist das ja nicht.
Danke.

gruss

[himitsu]

Bei TList mit Pointern ja,
in TList<IrgendeinPointer> auch,
aber die TList<EinRecordOderEinAndererEinfacherTypSowieDynA rraysUndInterfaces> kümmert sich um alles.

Unter ARC werden auch Objekte gut verwaltet ... da ist dann eine TList<> und TObjektList<> praktisch das Selbe.

Bei TObjectList und Anderen kann man im Constructor angeben, ob sich die Liste um das Free kümmert.

[EWeiss]

Zitat:

Bei TObjectList und Anderen kann man im Constructor angeben, ob sich die Liste um das Free kümmert.

Das ist ja wie ich gelesen habe Default auf True gestellt. ;)

Habe es jetzt fertig hoffe das mein Teil noch läuft..
Bei mir geht's (Aber das ist ja immer so).

gruss

[himitsu]

Zitat:

Zitat von EWeiss (Beitrag 1374431)

Das ist ja wie ich gelesen habe Default auf True gestellt. ;)

Nicht übeball, wie z.B. beim TDictionary.

[jaenicke]

Zitat:

Zitat von EWeiss (Beitrag 1374424)

OK bevor ich diese Freigebe lösche ich natürlich noch die Bitmap Ressourcen.

Befinden diese sich ebenfalls in der Klasse? Dann kannst du einfach den Destruktor überschreiben und das dort machen. Dann musst du dich nicht darum kümmern, dass das vorher passiert. Der wird dann automatisch aufgerufen, wenn die Liste das Objekt freigibt.

[EWeiss]

Das mache ich alles nach PostQuitMessage.
Danke.

Delphi-Quellcode:

      // Windows Messagen verarbeiten
      while GetMessage(Msg, 0, 0, 0) do
      begin
        if IsDialogMessage(MainHandle, Msg) = false then
        begin
          TranslateMessage(Msg);
          DispatchMessage(Msg);
        end;
      end;

      KillTimer(MainHandle, 1);
      // Menu Resource freigeben
      GDIP_DisposeImage(ImgBack);
      GDIP_DisposeImage(ImgHover);
      GDIP_DisposeImage(SideBarImg);

      if hNotifyRBin > 0 then
        SHChangeNotifyDeregister(MainHandle);

      CreateIcon.ShowDesktopIcons(True);

      for X := 0 to Sprites.Count - 1 do
      begin
        if Sprites[X].h_Bitmap <> 0 then
        begin
          DeleteObject(Sprites[X].h_Bitmap);
          Sprites[X].h_Bitmap := 0;
        end;
      end;
      Sprites.Free;

      FreeAndNil(CreateIcon);
      FreeAndNil(DockBar);
      FreeAndNil(ShortCut);

      SKAERO_Free;

gruss

[jaenicke]

Genau, sauberer wäre aber, wenn sich ein TSprite selbst darum kümmern würde. Sprich statt:

Delphi-Quellcode:

      for X := 0 to Sprites.Count - 1 do
      begin
        if Sprites[X].h_Bitmap <> 0 then
        begin
          DeleteObject(Sprites[X].h_Bitmap);
          Sprites[X].h_Bitmap := 0;
        end;
      end;
      Sprites.Free;

So:

Delphi-Quellcode:

type
  TSprite = class
  ...
  public
    destructor Destroy; override;
  end;

destructor TSprite.Destroy; 
begin
  inherited;
  if h_Bitmap <> 0 then
  begin
    DeleteObject(h_Bitmap);
    h_Bitmap := 0;
  end;
end;

// und dann an deiner Stelle nur noch:
      Sprites.Free;

[EWeiss]

Du hast recht ;)

Habe zwar den Quelltext schon hochgeladen werde es aber trotzdem deinem Beispiel zu folgen noch ändern.
Danke schön.

Ist dann im nächsten Update enthalten. (Wenn noch eins kommt)

Moment ;)
Nein geht nicht! (Bei normalen Classen schon)
Ich habe ja keine Class in herkömmlichen sinne.
Sondern nur meinen Record umbenannt.

Delphi-Quellcode:

  TSprite = class
    CtrlName: WideString;
    CtrlIndex: Integer;
    Left: Single;
    Top: Single;
    Width: Integer;
    Height: Integer;
    Scale: Single;
    Opacity: Byte;
    ShellTo: string;
    IconPath: WideString;
    WorkDir: WideString;
    UseLabel: string;
    CmdLine: WideString;
    ShowCmd: longint;
    h_Bitmap: HBitmap;
    Visible: Bool;
  end;
  PSprite = ^TSprite;

gruss

[DeddyH]

Ja und? Du kannst doch trotzdem den Destruktor überschreiben.

[EWeiss]

Zitat:

Zitat von DeddyH (Beitrag 1374496)

Ja und? Du kannst doch trotzdem den Destruktor überschreiben.

Sorry bin ich wirklich so blöd? (Tja wenn er denn definiert wäre) ;)

Normale Class

Delphi-Quellcode:

  TMagnetic = class(TInterfacedPersistent, ISkinMagnetic, ISkinMagneticEx)
    constructor Create;
    destructor Destroy; override;

hier wurden Create und Destroy definiert..
somit kann ich sie beim start und beenden verwenden/überschreiben oder was auch immer.

Schicke ich ein Free wird Destroy aufgerufen.

Beide werden aber in meiner Class TSprite nicht erstellt und auch nicht code mäßig aufgerufen.
Intern allerdings schon verwaltet.

Also erstelle ich meine Class wird im Quelltext Create gar nicht aufgerufen.
Somit kann ich da auch gar nichts eingeben.

Verstehst was ich meine?
Ich rede nicht davon das es grundsätzlich nicht geht sondern davon das ich beides in meiner Class/Record nicht definiert habe.
Ohne Definition kann ich dort Codemäßig auch nichts eingeben.
Die Funktionen existieren nicht!

Ich möchte sie auch in der Class nicht definieren diese soll weiterhin wie ein Record aussehen.

gruss

[jaenicke]

Du kannst den Destruktor doch jederzeit hinzufügen:

Delphi-Quellcode:

  TSprite = class
    CtrlName: WideString;
    CtrlIndex: Integer;
    Left: Single;
    Top: Single;
    Width: Integer;
    Height: Integer;
    Scale: Single;
    Opacity: Byte;
    ShellTo: string;
    IconPath: WideString;
    WorkDir: WideString;
    UseLabel: string;
    CmdLine: WideString;
    ShowCmd: longint;
    h_Bitmap: HBitmap;
    Visible: Bool;
  public
    destructor Destroy; override;
  end;

Ändern tut sich dadurch ja sonst nichts.

[EWeiss]

Zitat:

Zitat von jaenicke (Beitrag 1374499)

Du kannst den Destruktor doch jederzeit hinzufügen:

Delphi-Quellcode:

  TSprite = class
    CtrlName: WideString;
    CtrlIndex: Integer;
    Left: Single;
    Top: Single;
    Width: Integer;
    Height: Integer;
    Scale: Single;
    Opacity: Byte;
    ShellTo: string;
    IconPath: WideString;
    WorkDir: WideString;
    UseLabel: string;
    CmdLine: WideString;
    ShowCmd: longint;
    h_Bitmap: HBitmap;
    Visible: Bool;
  public
    destructor Destroy; override;
  end;

Ja aber das würde die Ansicht des Record/Class verändern und ich möchte diese Sichtbar als Record erhalten.
Alles andere verwirrt nur. ;)

Hatte meine Beitrag oben nochmal korrigiert. Sorry.

Zitat:

Ich möchte sie auch in der Class nicht definieren diese soll weiterhin wie ein Record aussehen.

Aber ich gebe dir recht wenn sie DEFINIERT ist das es funktioniert.

gruss

[EWeiss]

Auf der anderen Seite wir TSprite von TObjectList verwaltet und auch von dieser freigegeben.
Es ist nicht nötig hier ein Destroy zu definieren und zu überschreiben.
Das mit den HBitmaps mache ich vorsorglich da ich mir nicht sicher bin das TObjectList diese korrekt frei gibt.

Und ja ich weiß das TObjectList den Destructor aufruft wenn ich diese Freigebe
aber ich möchte den Destructor nicht definieren.

gruss

[DeddyH]

Die Objektliste gibt nur die in ihr enthaltenen Objekte frei. Enthalten diese wiederum selbst erstellte Ressourcen o.ä., so ist es deren Aufgabe, sich um das korrekte Abräumen zu kümmern.

[EWeiss]

Zitat:

Zitat von DeddyH (Beitrag 1374503)

Die Objektliste gibt nur die in ihr enthaltenen Objekte frei. Enthalten diese wiederum selbst erstellte Ressourcen o.ä., so ist es deren Aufgabe, sich um das korrekte Abräumen zu kümmern.

Jo mach ich ja aber ohne Destructor.
Und es geht nicht weil nicht definiert.
Also der Record soll als solcher Sichtbar erhalten bleiben (Auch wenn es hier niemand verstehen will ist halt meine Art) LOL
Wichtig ist das die Resourcen frei gegeben werden.

gruss

[DeddyH]

Ja, Du machst es von außen. Besser wäre es aber, wenn die Sprite-Objekte das selbst in die Hand nehmen. Und Du hast keinen Record mehr, finde Dich damit ab ;). Mal abgesehen von etwas mehr Overhead sollte man meiner persönlichen Meinung nach Klassen eh den Vorzug geben.

[EWeiss]

Zitat:

Zitat von DeddyH (Beitrag 1374505)

Ja, Du machst es von außen. Besser wäre es aber, wenn die Sprite-Objekte das selbst in die Hand nehmen. Und Du hast keinen Record mehr, finde Dich damit ab ;). Mal abgesehen von etwas mehr Overhead sollte man meiner persönlichen Meinung nach Klassen eh den Vorzug geben.

OK!
Werde ihn definieren habe mich damit abgefunden.
Danke euch. :)

Zitat:

Mal abgesehen von etwas mehr Overhead sollte man meiner persönlichen Meinung nach Klassen eh den Vorzug geben.

Das Klassen in einer NON VCL ein Overhead darstellen ist dir aber schon klar oder?

gruss

[EWeiss]

Habe es jetzt mal gemacht.
Und so wie gedacht wird TSprite Destroy nun doppelt aufgerufen.

Einmal von TSprite und einmal von TObjectList.
Verwende ich nur TSprites.Free(TObjectList) dann sind alle TSprite schon NIL bevor ich irgendetwas aufräumen kann.
Sehe jetzt nicht wirklich den Vorteil davon das Destroy nun zweimal aufgerufen wird.

Nun gut wie dem auch sei.

Delphi-Quellcode:

      SPrite.Free;
      Sprites.Free;

gruss