2 Arrays definiert - im Endeffekt aber ein und das selbe?

[Nonsense]

Hallo,
ich habe 2 Arrays definiert:

Delphi-Quellcode:

  TWorldArray  = array of array of TCreature;

  TWorld = class(TObject)
  private
    [...]
    FBufferArray: TWorldArray;
    FWorldArray : TWorldArray;
    [...]
  end;

Durch auftauchende Zugriffsverletzungen habe ich aber das Gefühl, dass es sich hierbei um ein und das selbe handelt (FBufferArray = FWorldArray).
Stimmt das?

[Chewie]

Eigentlich sollten es beide Zeiger auf verschiedene Arrays sein... :gruebel:

[gekmihesg]

vielleicht beachtest du ja irgendwo nicht das es dynamische arrays sind...

[Nonsense]

@Chewie: Das dachte ich mir auch. Wenn ich jetzt aber eine Instanz (von TCreature) von meinem FWorldArray in das FBufferArray kopiere, z.B.:

Delphi-Quellcode:

FBufferArray[X + 1][Y + 1] := FWorldArray[X][Y];

und dann FWorldArray (!) grafisch ausgebe, wird auch die Kopie bei X+1 und Y+1 ausgeben.
Der Destruktor gibt zum Schluß dann auch eine AV aus.

@gekmihesg: Die beiden Arrays sind genau gleich, d.h. sie haben die gleiche Größe, welche sich auch nicht ändert.

[Nonsense]

Das Problem ist jetzt, dass ich es wissen muss, ob FWorldArray und FBufferArray auf das gleiche Array zeigen. Wenn dem so ist, müsste ich alle Prozeduren umschreiben, da ja dann TWorldArray != TBufferArray wäre.

[Nonsense]

Ich habe noch einmal ein Bisschen rumgespielt und kann jetzt sagen, dass beide definitiv auf das selbe Array zeigen. Hat jemand eine Idee, wie ich das umgehen kann? Bleibt mit da nur die Möglichkeit, ein 2. Array zu erstellen? Bsp:

Delphi-Quellcode:

  TBufferArray  = array of array of TCreature;
  TWorldArray  = array of array of TCreature;

  TWorld = class(TObject)
  private
    [...]
    FBufferArray: TBufferArray;
    FWorldArray : TWorldArray;
    [...]
  end;

Das muss doch einfacher gehen, verdammte Sche*ße. :evil: :evil: :evil:

[Pseudemys Nelsoni]

auf seine eigenen antworten sollte man innerhalb von 24 nicht antworten, editier doch deinen beitrag nächstes mal. So sind hier eben die Regeln :thuimb:

zum thema kann ich leider auch nichts sagen :\

[Nonsense]

Zitat:

Zitat von Pseudemys Nelsoni

auf seine eigenen antworten sollte man innerhalb von 24 nicht antworten, editier doch deinen beitrag nächstes mal. So sind hier eben die Regeln :thuimb:

zum thema kann ich leider auch nichts sagen :\

War einfach zu faul. :wink:
Ich merk's mir.

[Chewie]

Ich hab das jetzt auch mal ausprobiert, ausgehend von deiner ersten Deklaration:

Delphi-Quellcode:

with TWorld.Create do
  begin
    //uninitialisiert
    ShowMessage(Format('FBufferArray: %p, FWorldArray: %p', [FBufferArray, FWorldArray]));

    //auf Länge 1
    SetLength(FBufferArray, 1);
    SetLength(FWorldArray,  1);
    ShowMessage(Format('FBufferArray: %p, FWorldArray: %p', [FBufferArray, FWorldArray]));

    Free;
  end;

Ergebnis: Ist das Array noch nicht initialisiert, zeigen beiden wirklich auf die selbe Adresse, nämlich 0! Klar, sind ja auch nil-Pointer. Erst nach dem Festlegen der Länge zeigen sie wirklich auf verschiedene Adressen, zumindest bei mir (D5).

[Nonsense]

Mehr als komisch, mein Contructor:

Delphi-Quellcode:

  TWorldArray  = array of array of TCreature;

  TWorld = class(TObject)
  private
    FBufferArray: TWorldArray;
    FWorldArray : TWorldArray;
  public
    constructor Create(BlockNumX, BlockNumY, BlockHeight, BlockWidth: Integer);
    destructor Destroy; override;
    [...]
    procedure BufferCreature(SourceX, SourceY, TargetX, TargetY: Integer;
      BufferArray, WorldArray: TWorldArray);
    [...]
    property BufferArray: TWorldArray read FWorldArray;
    property WorldArray: TWorldArray read FWorldArray;
  end;

[...]

constructor TWorld.Create(BlockNumX, BlockNumY, BlockHeight,
  BlockWidth: Integer);
var
  i: Integer;
  j: Integer;
begin
  [ ... ]

  SetLength(FBufferArray, BlockNumX, BlockNumY);
  SetLength(FWorldArray, BlockNumX, BlockNumY);

  for i := 0 to FBlockNumX - 1 do
    for j := 0 to FBlockNumY - 1 do
    begin
      FBufferArray[i][j] := TSand.Create(i, j);
      FWorldArray[i][j]  := TSand.Create(i, j);
    end;
end;

Vielleicht liegt es an der Zuweisung?

Delphi-Quellcode:

procedure TWorld.BufferCreature(SourceX, SourceY, TargetX, TargetY: Integer;
  BufferArray, WorldArray: TWorldArray);
begin
  BufferArray[TargetX][TargetY] := WorldArray[SourceX][SourceY];
end;

(Ich wollte jetzt zu 100% sicher gehen und habe die Arrays mit übergeben. Es ist natürlich klar, dass ich nur die Instanz der Klasse übergeben müsste, da ich ja per properties auf die Arrays zugreifen könnte.)
Würde bei dieser Zuweisung wirklich eine Kopie erstellt werden?