Zugriffsverletzung bei TObjectlist.delete

[Gruber_Hans_12345]

Zitat:

Zitat von Luckie

Zitat:

Zitat von Kedariodakon

2. Wäre eine rückwärts laufende For-Sschleife bei weitem schneller...

Das optimiert Delphi von alleine. ;)

auch wenns etwas offtopic ist ... aber bist dir sicher, das delphi sowas optimieren kann?

immerhin muß der bei der while schleife doch immer den count abrufen da das ja eine funktion ist.
Bie der for schleife werden die start und end werte ja nur einmal abgefragt, von daher müßte sich schon ein unterscheid ergeben ... :gruebel:

[Kedariodakon]

würd ich auch behaupten... Auch wegen deinem angesprochenen Grund, ich denke sobald da ne Funktion im Spiel ist, wird da Delphi nicht mehr viel optimieren =p

Bye Christian

[IngoD7]

Zitat:

Zitat von Hawkeye219

TWinControls geben im Destruktor alle Controls frei, deren Parent sie sind.

Yepp - und ausserdem: TComponents geben bei ihrer eigenen Freigabe alle Components frei, deren Owner sie sind.

[Jelly]

Zitat:

Zitat von IngoD7

Zitat:

Zitat von ozz

@Jelly
Du hast natürich Recht. Kleiner Schnitzer.

Soooo natürlich ist das nun auch wieder nicht. Warum sollte eine Ableitung einer Liste nicht noch eine weitere Liste besitzen?

Natürlich geht das. Die Frage ist ob das in diesem Fall wirklich beabsichtigt war.

[ozz]

Hallo Leute,
herzlichen Dank für die vielen Tips. Ich bin gerade noch dabei, diese durchzutesten. Bisher nur mit wenig Erfolg. Damit gehe sehr stark davon aus, das das Problem wo anders ist. Da ich es bis noch nicht geblickt habe, poste ich einfach mal den restlichen Code. Ist echt Mist, wenn man den Wald vor lauter Bäumen nicht mehr sieht.
Besten Dank!

Delphi-Quellcode:

type TStreamlist= class (TObject)
private
   FStreamObjectList:TObjectlist;
   function Get(Index: Integer): TStringstream;
   procedure Put(Index: Integer; const Value: TStringstream);

public
   constructor Create;
   destructor Destroy;override;
   function add: integer;
   function Additem(Item:TStringstream):integer;
   property items[Index: Integer]: TStringstream read Get write Put;
   function count: integer;
   procedure delete (index:integer);
   procedure clear;
end;

implementation

constructor TStreamlist.create;
begin;
  inherited create;
  FStreamObjectList:=TObjectList.Create(true);
end;

destructor TStreamlist.destroy;
var i:Integer;
begin;
  for i:= 1 to FStreamObjectList.Count do
    begin
        FStreamObjectList.Items[i-1].free // jedes einzelne Objekt expl. freigeben
    end;
  FStreamObjectList.Clear(); // jetzt duerften nur noch nils da sein
  inherited Destroy; // und zum Schluss noch das Basisdestroy
end;

function TStreamlist.add: integer;
var TagType: TStringstream;
begin
   TagType:=TStringstream.Create('');
   Result:= FStreamObjectList.add(TagType);
end;

function TStreamlist.Additem(Item: TStringstream): Integer;
var TagType: TStringstream;
begin
    TagType:=TStringstream.Create('');
    TagType:=Item;
    Result:= FStreamObjectList.add(TagType);
end;

function TStreamlist.Get(Index: Integer):TStringstream;
begin;
    result:= TStringstream(FStreamObjectList.Items[Index]);
end;

procedure TStreamlist.Put(Index: Integer; const Value: TStringstream);
begin
    FStreamObjectList[Index]:=Value;
end;

function TStreamlist.count: integer;
begin
    result:=FStreamObjectList.count;
end;

procedure TStreamlist.Delete(index:integer);
begin
    FStreamObjectList.Delete(index);
    FStreamObjectList.Capacity := FStreamObjectList.Count; //Speicher Freigeben
end;

procedure TStreamlist.clear;
begin
 while FStreamObjectList.Count >0 do
 begin
   FStreamObjectList.Delete(0);
 end;
end;


end.

[Luckie]

Zitat:

Zitat von Kedariodakon

würd ich auch behaupten... Auch wegen deinem angesprochenen Grund, ich denke sobald da ne Funktion im Spiel ist, wird da Delphi nicht mehr viel optimieren =p

Ups, ich dachte, das wäre eine for-Schleife gewesen.

[ozz]

*push*

[Jelly]

Also wenn das wirklich die gesamte Klasse ist, behaupte ich weiterhin dass, dass die Ableitung von TObjectList schon fast alles löst was Du versuchst komplitziert nachzubasteln. Hier mal ein ähnliches Beispiel:

Delphi-Quellcode:

unit untLieferschein;

interface
uses classes,  windows, contnrs, sysutils ;

type
  TLieferschein = class 
  TLieferscheine = class (TObjectList)
  private
    function GetItem(Index: Integer): TLieferschein;
    procedure SetItem(Index: Integer; const Value: TLieferschein);
  public
     constructor Create (AConnection : TADOConnection) ; overload ;
     property Items[Index: Integer]: TLieferschein read GetItem write SetItem; default;
  end;

implementation

function TLieferscheine.GetItem(Index: Integer): TLieferSchein;
begin
     Result := (inherited Items[Index]) as TLieferSchein ;
end;

procedure TLieferscheine.SetItem(Index: Integer; const Value: TLieferSchein);
begin
     inherited Items[Index] := Value ;
end;

end.

[Jelly]

Zitat:

Zitat von ozz

*push*

Lass bitte nach wenigen Stunden das Pushen. Das wird hier nicht sehr geschätzt.

[IngoD7]

Zur Erinnerung:

1.) FStreamObjectList freigeben!

Zitat:

Zitat von IngoD7

In jedem Falle sollte dein TStreamlist-Destruktor die Liste FStreamObjectList selbst überhaupt auch mal freigeben.

2.) Mache es dir einfach:

Zitat:

Zitat von IngoD7

Diese Anforderung, gemeinsam mit der Tatsache, dass OwnsObjects TRUE ist, sollte folgendes ausreichen lassen:

Delphi-Quellcode:

destructor TStreamlist.destroy; 
begin 
    FStreamObjectList.Free;
    inherited Destroy; 
end;