Result: TDynFloatArrayOfArray

[Bjoerk]

Ist das so eigentlich korrekt (***) . Ich meine, wenn man diesen Result jetzt zuweist, ist dann sichergestellt, daß sich der Pointer geändert hat oder sollte man da besser Copy verwenden? Ich meine, wenn A <> nil und B <> nil kann man auch nicht schreiben A:= B ? Ein Test verlief erfolgreich, nur ich versteh nicht wieso ? :gruebel:

Delphi-Quellcode:

type
  TDynDoubleArrayOfArray = array of array of double;

  TDynFloatArrayOfArray = record
    Items: TDynDoubleArrayOfArray;
    RowCount, ColCount: integer;
    procedure Clear;
    procedure Null;
    procedure Dim(const Rows, Cols: integer);
    procedure Assign(const A: TDynDoubleArrayOfArray);
  end;

procedure TDynFloatArrayOfArray.Clear;
begin
  SetLength(Items, 0);
  RowCount := 0;
  ColCount := 0;
end;

procedure TDynFloatArrayOfArray.Null;
var
  I, J: integer;
begin
  for I := 0 to RowCount - 1 do
    for J := 0 to ColCount - 1 do
      Items[I, J] := 0;
end;

procedure TDynFloatArrayOfArray.Dim(const Rows, Cols: integer);
begin
  RowCount := Rows;
  ColCount := Cols;
  SetLength(Items, RowCount, ColCount);
end;

procedure TDynFloatArrayOfArray.Assign(const A: TDynDoubleArrayOfArray);
var
  I, J: integer;
begin
  Clear;
  if (Length(A) > 0) and (Length(A[0]) > 0) then
  begin
    RowCount := Length(A);
    ColCount := Length(A[0]);
    Dim(RowCount, ColCount);
    for I := 0 to RowCount - 1 do
      for J := 0 to ColCount - 1 do
        Items[I, J] := A[I, J];
  end;
end;

function DoSomething: TDynFloatArrayOfArray;
var
  I, J: integer;
begin
  Result.Dim(Random(3) + 2 , Random(3) + 2);
  for I := 0 to Result.RowCount - 1 do
    for J := 0 to Result.ColCount - 1 do
      Result.Items[I, J] := Random(999);
end;

procedure DynFloatArrayOfArrayToMemo(Memo: TMemo; const A: TDynFloatArrayOfArray);
var
  I, J: integer;
  S: string;
begin
  Memo.Lines.BeginUpdate;
  try
    Memo.Clear;
    for I := 0 to A.RowCount - 1 do
    begin
      S := '';
      for J := 0 to A.ColCount - 1 do
        S := S + Format('%10.2f', [A.Items[I, J]]);
      Memo.Lines.Add(S);
    end;
  finally
    Memo.Lines.EndUpdate;
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  A, B: TDynFloatArrayOfArray;
begin
  A := DoSomething; // ***
  B := DoSomething; // ***
  DynFloatArrayOfArrayToMemo(Memo1, A);
  DynFloatArrayOfArrayToMemo(Memo2, B);
end;

[Blup]

In deiner Assign-Methode gehst du davon aus das jedes Element A[0] .. A[RowCount - 1] genau die selbe Anzahl Unterelemente hat.
Das muss aber nicht sein (A[0] könnte z.B. 5 Elemente haben, A[1] 10 Elemente, A[2] keine Elemente).

Beim Eintritt in die Methode Button1Click werden die beiden Records A und B z.T. automatisch initialisiert.
Items wird auf Nil gesetzt, RowCount und ColCount behalten ihren mehr oder weniger zufälligen Wert.
Der Rückgabewert Result der Funktion DoSomething ist eigentlich ein versteckter Parameter, der jeweils auf A oder B verweist.
Tatsächlich arbeitet DoSomething einmal mit dem Speicher der Variablen A und einmal mit B.
Ein nachfolgendes Copy ist in diesem Fall überflüssig.

[Bjoerk]

Zitat:

In deiner Assign-Methode gehst du davon aus das jedes Element A[0] .. A[RowCount - 1] genau die selbe Anzahl Unterelemente hat.
Das muss aber nicht sein (A[0] könnte z.B. 5 Elemente haben, A[1] 10 Elemente, A[2] keine Elemente).

Logo, deshlab ja das Dim (Anlehnung an Basic)

Zitat:

Tatsächlich arbeitet DoSomething einmal mit dem Speicher der Variablen A und einmal mit B.

Sicher? Also wie bei einer Property? Was passiert denn dann intern bei einem Aufruf von DoSomething ohne Zuweisung?