TObjectList sauber an function übergeben und wieder zurück

[norwegen60]

Zunächst Danke für die schnellen Antworten

Zitat von DeddyH:

Das stimmt so nicht. Das Objekt (genauer: die Instanz) selbst wird ohne Angabe von const, var oder out als Call by Value übergeben.

Dass Objekte kein var brauchen dachte ich anfangs auch habe aber eben festgestellt, dass es unterschiedlich reagiert.
Um es sicher zu stellen:

• Wenn das Objekt in der Funktion erzeugt wird, muss ein var dazu
• Wenn man verhindern will, dass eine neue Instanz erzeugt wird (Create), kann man das mit const verhindern

Zitat von DeddyH:

Ich würde aber in Routinen ohne triftigen Grund keine Instanzen erzeugen, da man sonst sehr schnell durcheinanderkommt und sich entweder Speicherlecks oder wilde Zeiger fabriziert.

Dem stimme ich zu. Grund dafür hier mal anzufragen. Um Sicherheit zu gewinnen

Zitat von DeddyH:

[edit] Mist, zu langsam [/edit]

Das verunsichert mich etwas. Deine Vorredner haben doch was anderes gezeigt. Nämlich wie die Instanzen in der Routine erzeugt werden.

Zitat von samso:

Diese Konstruktion produziert ein Memoryleak, weil DestList durch den Aufrufer nicht freigegeben werden kann. Denn die Referenz der neu erzeugten Liste wird so nicht an den Aufrufer zurückgegeben.

Das hatte ich festgestellt. Jetzt weiß ich warum.

Letzte Frage:
Könnte Aufbau lTempList := DoAdding(DestList) Vorteile bieten? Was muss da beachtet werden bzw. stimmt das hier?

Delphi-Quellcode:

function PrePareList(SourceList: TTestList): TTestList;
// ------------------------------------------------------------------------------------------
// Erstellt Liste und kopiert Werte von SourceList dort hin
var
  i: Integer;
  lTest: TTest;
begin
  Result.Clear;

  for i := 0 to SourceList.Count - 1 do
  begin
    lTest := TTest.Create;
    Result.Add(lTest);
    lTest.Value := SourceList[i].Value;
  end;
end;

function DoAddition(SourceList: TTestList): TTestList;
// ------------------------------------------------------------------------------------------
// Führe rechenfunktion durch, die auch auf vorige Werte in der Liste zurückgreift. 
// Wenn SourceList und Result auf selbem Objekt liegen, wurden die vorigen Werte durch den Loop schon verändert => Zuerst zusätzliche Instanz schaffen. Oder gibt es andere Möglichkeit?
var
  i: Integer;
  lTest: TTest;
  lTempList:TTestList;
begin
  lTempList := lTempList.Create(true);
  lTempList := PrePareList(SourceList);


  for i := 0 to SourceList.Count - 1 do
  begin
    if i>0 then
      Result.Value := lTempList[i].Value + lTempList[i-1].Value
    else
      Result.Value := lTempList[i].Value;
  end;

  lTempList.Free;
end;

Procedure Start;
// ------------------------------------------------------------------------------------------
// Vorbereitung der Liste und Aufruf der Funktionen
var
  lStartList, lResultList:TTestList;
begin
  lStartList := TTestList.Create(true);
  lResultList := TTestList.Create(true);

  ...

  lResultList := PrePareList(SourceList);
  
  // Und hier mein Problem. Da die Berechnungen aufeinander aufbauen sollen, ist Result-Objekt = Übergabe-Objekt. Wenn jeder Eintrag für sich geändert wird kein Problem. 
  // Wenn die Funktion aber auf vorige Einträge zugreift, wären die schon verändert. Jetzt müsste ich in der Funktion zuerst eine Kopie erzeugen. Korrekt?

  lResultList := DoAddition(lResultList);

  ...

  lStartList.Free;
  lResultList := TTestList.Create(true);

[DeddyH]

Wo soll das Funktionsergebnis (also die Instanz) denn herkommen, wenn sie nicht innerhalb der Funktion erzeugt wird? Was spricht denn dagegen, beide Instanzen in der aufrufenden Routine zu erzeugen und als Konstanten-Parameter zu übergeben?

[norwegen60]

Zitat von DeddyH:

Wo soll das Funktionsergebnis (also die Instanz) denn herkommen, wenn sie nicht innerhalb der Funktion erzeugt wird? Was spricht denn dagegen, beide Instanzen in der aufrufenden Routine zu erzeugen und als Konstanten-Parameter zu übergeben?

Es spricht nichts dagegen. Es geht mir ums Verständnis. Und da frage ich mich, wie das Konstrukt aussehen müsste, wenn man die Liste als function zurück gibt.

Doch ein kleines Problem habe ich doch. Wie muss das dann aussehen?

Delphi-Quellcode:

procedure TuAlles(const SourList, DestList:TTestList);
begin
  TuWas1(SourceList, DestList);
  // Wie gehe ich vor, dass mit dem nächsten Aufruf die vorige DestList als SourceList übergeben wird
  TuWas2(SourceList, DestList);
end;

// Das hier funktioniert nicht mehr, da ja als const hereingegeben und damit die Zuweisung DestList := lTempList; fehl schlägt

procedure TuAlles(const SourList, DestList:TTestList);
var
  lTempList:TTestList;
begin
  PrepareDestList(SourceList, DestList);

  lTempList:=TTestList.Create;
  PrepareDestList(SourceList, lTempList);

  if TuWas1(DestList, lTempList)then
  begin
    DestList.Free;  // Jetzt muss ich die ja freigeben um danach meine neue Ergebnisse dran zu hängen
    DestList := lTempList;
    lTempList:= nil;
  end;
    
  lTempList:=TTestList.Create;
  PrepareDestList(SourceList, lTempList);

  if TuWas2(DestList, lTempList)then
  begin
    DestList.Free;
    DestList := lTempList;
    lTempList:= nil;
  end;
end;

[DeddyH]

Ich würde ohne Grund nicht an den Instanzen herumspielen, sondern nur an den enthaltenen Daten.

Delphi-Quellcode:

procedure Tuwas(sonst Src, Dest: TSomeList);
begin
  // Mit den Daten der Listen arbeiten
end;

procedure TuAlles;
var
  List1: TSomeList;
  List2: TSomeList;
  List3: TSomeList;
begin
  List3 := nil;
  List2 := nil;
  List1 := TSomeList.Create;
  try
    List2 := TSomeList.Create;
    TuWas(List1, List2);
    List3 := TSomeList.Create;
    TuWas(List2, List3);
  finally
    List1.Free;
    List2.Free;
    List3.Free;
  end;
end;

[norwegen60]

In der Art hatte ich es ursprünglich. Da die Berechnungen zum Teil aufwändig sind, führe ich sie nur noch aus, wenn sie auch benötigt wird

Delphi-Quellcode:

  if FlagTuWas1 then
    TuWas1(List1, List2);

  if FlagTuWas2 then
    TuWas2(List2, List3);

was so dann natürlich nicht geht. Wenn TuWas1 nicht ausgeführt würde müsste ich List1 statt List2 in TuWas2 eingeben

Und der Ansatz

Delphi-Quellcode:

var
  lTempList:TTempList;
begin
  PrepareDestList(SourceList, DestList);

  lTempList:= TAbsBaseList.Create(true);
  try
    // -------------------------------------------------------------------------------------------------------------------------------------
    if FlagTuWas1 then
      if TuWas1(DestList, lTempList) then     // Wenn erfolgreich ausgeführt 
        PrepareDestList(lTempList, DestList); // Ergebnis in Weitergabe-/Rückgabeliste kopieren

    // -------------------------------------------------------------------------------------------------------------------------------------
    if FlagTuWas2 then
      if TuWas2(DestList, lTempList) then
        PrepareDestList(lTempList, DestList); // Ergebnis in Weitergabe-/Rückgabeliste kopieren
  finally
    lTempList.Free;
  end;
end;

erscheint mir aufwändig, da das neue Ergbnis immer wieder in lTempList kopiert wird um es dann wieder dem nächsten Aufruf übergeben zu können

[DeddyH]

Benötigst Du denn wirklich mehrere Instanzen? Was genau hast Du eigentlich vor?

[norwegen60]

Ich weiß keinen Weg, wie ich um 3 Instanzen rum komme
Was ich machen muss sind diverse Rechenschritte Wie z.B.

1. Korrektur um einen zu berechnenden Wert
2. Averaging über die X rechts und links liegenden Werte in der Liste
3. Ableitung nach Savitzky/Golay

Instanz 1 enthält die Ausgangsdaten die nicht verändert werden sollen
Instanz 2 enthält die zuletzt berechneten Werte
Instanz 3 enthält die aktuell berechneten Werte

Bei 1. ist es keine Problem zu sagen Instanz2[i].Value := Instanz2[i].Value + 6 (hier reichen 2 Instanzen)
Bei 2. und 3. gibt es aber das Problem, dass ich z.B. sage Instanz3[i].Value := (Instanz2[i-1].Value + Instanz2[i].Value + Instanz2[i+1].Value)/3 (Mittelwert über drei Werte)

Würde ich nur mit Instanz2 arbeiten, wäre der Wert Instanz2[i-1] im vorigen Loop schon geändert.
Instanz1 funktioniert auch nicht, da Instanz2 in Berechnung 1. schon geändert wurde somit auf Instanz2 weitergemachet werden muss
Ich hoffe es ist jetzt etwas klarer