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?

[Chewie]

Lass dir einfach mal, so wie ich es gemacht habe, die Adressen ausgeben, und du siehst 100%ig, ob es sich um das gleiche Array handelt oder nicht.

[dizzy]

Zitat:

Zitat von Nonsense

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;

Würde bei dieser Zuweisung wirklich eine Kopie erstellt werden?

Bei dieser Zuweisung wird tatsächlich das Element in Array[SourceX/Y] kopiert. Bei:

Delphi-Quellcode:

  BufferArray := WorldArray;

also ohne Indezes wird der Pointer übergeben, und es entsteht das von dir beschriebene Szenario. Schau mal, ob du irgendwo im Code sowas wie oben drin hast. Dann ist alles klaro.

gruss,
dizzy

\edit: Nen Plural zum Singular degradiert :)

[Nonsense]

Zitat:

Zitat von Chewie

Lass dir einfach mal, so wie ich es gemacht habe, die Adressen ausgeben, und du siehst 100%ig, ob es sich um das gleiche Array handelt oder nicht.

Ok, gewonnen. Es sind unterschiedliche Adressen. Und ich war mir so sicher, dass es der Fehler sein muss. Dann mal wieder rein in die lustige Suche...

Danke! :dp:

Ich kombiniere mal: Wenn ich ein Objekt (Instanz) von ArrayA nach ArrayB kopieren will, spuckt der Destructor beim beenden ein EInvalidPointer aus. Wenn ich auf dem ArrayB aber ein neues Objekt erstelle (TMeineKlasse.Create) funktioniert alles wunderbar. D.h. es wird nur der Pointer übergeben.
Demnach muss es der Zuweisung liegen:

Delphi-Quellcode:

procedure TWorld.BufferCreature(SourceX, SourceY, TargetX, TargetY: Integer;
  World: TWorld);
begin
  World.FBufferArray[TargetX][TargetY] := World.FWorldArray[SourceX][SourceY];
end;

Hatte mir sowas schon gedacht. Wie kann ich denn ein Objekt von ArrayA nach ArrayB kopieren? Ich habe da keinen blassen Schimmer, deswegen auch die Zuweisung.

Hat sich erledigt! Danke an Chewie!