Alter Classe neue zuweisen

[Uwe Raabe]

Zitat von ISurf:

Wenn zwei Objekte im Array vertauscht werden sollen, dann müsste es eigentlich folgendermaßen funktionieren:

Delphi-Quellcode:

function Swap(gs:TNegativArray; Index1, Index2:integer);
var
  lTemp: TObject;
begin
  lTemp:=gs[Index1];
  gs[Index1]:=gs[Index2];
  gs[Index2]:=lTemp;
end;

Sehe ich auch so. Damit werden aber streng genommen die Instanzen ausgetauscht und nicht der Inhalt der beiden Instanzen. Ob das so gewollt ist oder nicht entzieht sich unserer Kenntnis.

Ich würde diese Methode auch direkt in der Klasse TNegativArray implementieren - zwecks Konsistenz mit TList aber unter dem Namen Exchange:

Delphi-Quellcode:

  TNegativeArray = class(TObject)
  private
    Fdata : array of TSprite;
    FMaxValue: Integer;
    function getData(index : Integer) : TSprite; inline;
    procedure setData(index : Integer; aData : TSprite); inline;
    function GetMaxValue: Integer;
    procedure SetMaxValue(const Value: Integer);
  public
    Constructor Create(aLenght : Integer);
    Destructor Destroy; override;
    procedure Exchange(Index1, Index2: Integer);

    property Data[index: Integer]: TSprite read getData write setData; default;
    property MaxValue: Integer read GetMaxValue write SetMaxValue;
  end;

...

procedure TNegativeArray.Exchange(Index1, Index2: Integer);
var
  lTemp: TSprite;
begin
  lTemp := Data[Index1];
  Data[Index1] := Data[Index2];
  Data[Index2] := lTemp;
end;

[Aviator]

Oder man löst das alles direkt über Interfaces und hält sich nicht unnötig mit irgendwelchen Klassen oder deren Ableitungen auf. Hier mal nur ein Beispiel wie man das evtl. machen könnte. Geht bestimmt noch einfacher bzw. lässt sich erweitern. Also jetzt nicht festnageln, wenn das evtl. umständlich gelöst wäre. Es soll nur ein Ansatz wie man es auch noch lösen kann.

Delphi-Quellcode:

program SwapSample;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils;

type
  ISwapable = interface
  ['{57064C48-8737-4A57-937D-64654F1F897C}']
    procedure SetA(Value: Integer);
    procedure SetB(Value: Integer);
    procedure SwapWith(var AnotherObject: ISwapable);
    function GetA: Integer;
    function GetB: Integer;
    property A: Integer read GetA write SetA;
    property B: Integer read GetB write SetB;
  end;

  TSprite = class(TInterfacedObject, ISwapable)
  private
    FIntA: Integer;
    FIntB: Integer;
  public
    constructor Create;
    function GetA: Integer;
    function GetB: Integer;
    procedure SetA(Value: Integer);
    procedure SetB(Value: Integer);
    procedure SwapWith(var AnotherObject: ISwapable);
  end;

  TOtherClass = class(TInterfacedObject, ISwapable)
  private
    FIntA: Integer;
    FIntB: Integer;
  public
    constructor Create;
    function GetA: Integer;
    function GetB: Integer;
    procedure SetA(Value: Integer);
    procedure SetB(Value: Integer);
    procedure SwapWith(var AnotherObject: ISwapable);
  end;

{ TSprite }

constructor TSprite.Create;
begin
  FIntA := Random(100);
  FIntB := Random(250);
end;

function TSprite.GetA: Integer;
begin
  Result := FIntA;
end;

function TSprite.GetB: Integer;
begin
  Result := FIntB;
end;

procedure TSprite.SetA(Value: Integer);
begin
  if (FIntA <> Value) then
    FIntA := Value;
end;

procedure TSprite.SetB(Value: Integer);
begin
  if (FIntB <> Value) then
    FIntB := Value;
end;

procedure TSprite.SwapWith(var AnotherObject: ISwapable);
var
  tmpA, tmpB: Integer;
begin
  tmpA := Self.FIntA;
  tmpB := Self.FIntB;

  Self.FIntA := AnotherObject.A;
  Self.FIntB := AnotherObject.B;

  AnotherObject.A := tmpA;
  AnotherObject.B := tmpB;
end;

{ TOtherClass }

constructor TOtherClass.Create;
begin
  FIntA := Random(100) div 2;
  FIntB := Random(250) div 2;
end;

function TOtherClass.GetA: Integer;
begin
  Result := FIntA * 2;
end;

function TOtherClass.GetB: Integer;
begin
  Result := FIntB * 2;
end;

procedure TOtherClass.SetA(Value: Integer);
var
  tmp: Integer;
begin
  tmp := Value div 2;

  if (FIntA <> tmp) then
    FIntA := tmp;
end;

procedure TOtherClass.SetB(Value: Integer);
var
  tmp: Integer;
begin
  tmp := Value div 2;

  if (FIntB <> tmp) then
    FIntB := tmp;
end;

procedure TOtherClass.SwapWith(var AnotherObject: ISwapable);
var
  tmpA, tmpB: Integer;
begin
  tmpA := Self.FIntA;
  tmpB := Self.FIntB;

  Self.FIntA := AnotherObject.A div 2;
  Self.FIntB := AnotherObject.B div 2;

  AnotherObject.A := tmpA;
  AnotherObject.B := tmpB;
end;


var
  MySprite, MyOtherObject: ISwapable;

begin
  try
    Randomize;

    MySprite := TSprite.Create;
    MyOtherObject := TOtherClass.Create;

    Writeln(Format('MySprite A: %d', [MySprite.A]));
    Writeln(Format('MySprite B: %d', [MySprite.B]));
    Writeln(Format('MyOtherObject A: %d', [MyOtherObject.A]));
    Writeln(Format('MyOtherObject B: %d', [MyOtherObject.B]));

    Writeln;
    Writeln('Swapping Objects ...');

    MySprite.SwapWith(MyOtherObject);

    Writeln;
    Writeln('Objects swapped ...');
    Writeln;

    Writeln(Format('MySprite A: %d', [MySprite.A]));
    Writeln(Format('MySprite B: %d', [MySprite.B]));
    Writeln(Format('MyOtherObject A: %d', [MyOtherObject.A]));
    Writeln(Format('MyOtherObject B: %d', [MyOtherObject.B]));

    Readln;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

Ergibt bei mir folgendes Ergebnis:

[EWeiss]

Ich habe es jetzt mal so umgesetzt und werde es beobachten ob es das ist was ich mir vorstelle.

Delphi-Quellcode:

if Item <> FlagFound then
begin
  gS.Swap(FlagFound, Item);
  //gS[FlagFound] := gS[Item];
  FlagFound := Item;
end;

Ob damit der komplette Inhalt von TSprite ausgetauscht wird muss ich erst noch prüfen.
Wenn jetzt gS[FlagFound] den kompletten Inhalt vom bsp. Papierkorb enthält und gS[Item] den vom Computer
dann muss anschließend FlagFound den Inhalt des Computer beinhalten.

Hab mal 2 Pics angehängt. (nur als Beispiel)

gruss

[Medium]

Zitat von EWeiss:

Es sind keine Objekte im Array sondern 2 Klassen\Classen wie auch immer.

Nur als Ergänzung bzw. Begriffsklärung:

Es sind definitiv Objekte in deinem Array. Eine Klasse ist immer nur ein Typ. Ein Objekt ist eine konkrete, mit Werten "befüllte" Instanz dieses Typs.

Von daher:
TSprite => Klasse
wenn gs: array of TSprite; dann
gs[Index] => Objekt vom Typ TSprite

Ein Objekt ist immer das, wo man auch Werte zuweisen kann. Eine Klasse ist das, womit man TSprite.Create() schreibt. (Vereinfacht gesagt.) Und TSprite.Create() erzeugt ein Objekt vom Typ TSprite.

Mit einer Klasse definierst du lediglich welche Werte mit was für Namen und mit welchen Funktionen eine Einheit ergeben sollen. Aber in einer Klasse stehen noch keine Werte drin. Sie ist nur ein Stempel sozusagen, mit dem du nachher beliebig viele Objekte des Typs TSprite stempeln kannst, wo dann auch Werte rein geschrieben werden können.

Das ist zumindest, wie die Begriffe praktisch überall verwendet werden.

[EWeiss]

Zitat:

Das ist zumindest, wie die Begriffe praktisch überall verwendet werden.

Ich tue mich manchmal schwer mit den ganzen versuchen etwas zu erklären (Informatik mäßig)
Bitte bedenke das bin ich nicht.

Von daher danke für die Richtigstellung, versuche es beim nächsten mal etwas genauer zu beschreiben.

Am ende war die Lösung von Uwe Raabe das richtige
Danke nochmal dafür.

gruss