Delphi-PRAXiS

Delphi-PRAXiS (https://www.delphipraxis.net/forum.php)
-   Programmieren allgemein (https://www.delphipraxis.net/40-programmieren-allgemein/)
-   -   Delphi Alter Classe neue zuweisen (https://www.delphipraxis.net/192654-alter-classe-neue-zuweisen.html)

EWeiss 8. Mai 2017 23:23


Alter Classe neue zuweisen
 
Ich möchte zwei Classen miteinander vertauschen.

Abhängig von Items.

Delphi-Quellcode:
procedure SWAP(var Value1, Value2: Integer);
var
  lTemp: integer;
begin
  lTemp := Value1;
  Value1 := Value2;
  Value2 := lTemp;
end;
Delphi-Quellcode:
// SWAP ITEM
if Item <> FlagFound then
begin
  SWAP(gS[FlagFound], gS[Item]);

  FlagFound := Item;
end;
Das geht natürlich nicht weil meine SWAP Function integer erwartet.

gs aber ein Classe ist.
Mit Assign geht's auch nicht .. noch andere Möglichkeiten?
Bin mir jetzt nicht sicher ob das der richtige weg wäre. Zumindest meckert der Compiler nicht.

Delphi-Quellcode:
gS[FlagFound] := gS[Item];


gruss

Uwe Raabe 9. Mai 2017 00:00

AW: Alter Classe neue zuweisen
 
Dann deklarier doch einfach ein Swap für den Klassentyp (hier TMyClass):
Delphi-Quellcode:
procedure SwapMyClass(var Value1, Value2: TMyClass);
var
  lTemp: TMyClass;
begin
  lTemp := Value1;
  Value1 := Value2;
  Value2 := lTemp;
end;

nahpets 9. Mai 2017 00:07

AW: Alter Classe neue zuweisen
 
Es ist schon spät, von daher weiß ich nicht, ob ich gerade um die Ecke denke (wenn überhaupt noch ;-))
Delphi-Quellcode:
procedure SWAP(var Value1, Value2: TBasisKlasseDerZuTauschendenClassen); // eventuell TObject?
var
  lTemp: TBasisKlasseDerZuTauschendenClassen;
begin
  lTemp := Value1;
  Value1 := Value2;
  Value2 := lTemp;
end;
Aber vermutlich möchtest Du die Inhalte von gS[?] tauschen.

Was genau ist in gS[?] zu finden?
FlagFound und Item sind (vermutlich) Angaben für den Index von gS.

Würde es mal so probieren:
Delphi-Quellcode:
procedure SWAP(var Value1, Value2: TKlasse_Oder_Typ_gS[Item]);
var
  lTemp: TKlasse_Oder_Typ_gS[Item];
begin
  lTemp := Value1;
  Value1 := Value2;
  Value2 := lTemp;
end;

EWeiss 9. Mai 2017 00:21

AW: Alter Classe neue zuweisen
 
Zitat:

Was genau ist in gS[?] zu finden?
http://www.delphipraxis.net/1369617-post1.html

Delphi-Quellcode:
procedure SWAP(var Value1: TNegativeArray; var Value2: TNegativeArray);
var
   lTemp: TNegativeArray;
begin
   lTemp := Value1;
   Value1 := Value2;
   Value2 := lTemp;
end;
Delphi-Quellcode:
SWAP(gS[FlagFound], gS[Item]);

Zitat:

[DCC Fehler] uMain.pas(1588): E2033 Die Typen der tatsächlichen und formalen Var-Parameter müssen übereinstimmen

Zitat:

FlagFound und Item sind (vermutlich) Angaben für den Index von gS.
Korrekt.

Zitat:

Aber vermutlich möchtest Du die Inhalte von gS[?] tauschen.
Richtig!
gS[FlagFound] soll alle Eigenschaften inklusive der werte von gS[Item] erhalten.
Danch wird FlagFound der Index von Item zugewiesen.

Zitat:

Dann deklarier doch einfach ein Swap für den Klassentyp (hier TMyClass):
Wenn es so einfach ist warum geht es dann nicht?


gruss

nahpets 9. Mai 2017 00:31

AW: Alter Classe neue zuweisen
 
Wenn ich das richtig sehe ist gS[Item] vom Typ TSprite.

Lass bitte bei Swap mal das var weg.

Also eher sowas:
Delphi-Quellcode:
procedure SWAP(Value1, Value2: TSprite);
var
   lTemp: TSprite;
begin
   lTemp := Value1;
   Value1 := Value2;
   Value2 := lTemp;
end;
Aufruf dann so:

Delphi-Quellcode:
SWAP(gS[FlagFound], gS[Item]);


Wenn's das auch nicht ist, sollte ich den Rechner ausschalten und mich auf's Ohr hauen ;-)

EWeiss 9. Mai 2017 00:37

AW: Alter Classe neue zuweisen
 
Zitat:

Zitat von nahpets (Beitrag 1370637)
Wenn ich das richtig sehe ist gS[Item] vom Typ TSprite.

Lass bitte bei Swap mal das var weg.

Also eher sowas:
Delphi-Quellcode:
procedure SWAP(Value1, Value2: TSprite);
var
   lTemp: TSprite;
begin
   lTemp := Value1;
   Value1 := Value2;
   Value2 := lTemp;
end;
Aufruf dann so:

Delphi-Quellcode:
SWAP(gS[FlagFound], gS[Item]);


Wenn's das auch nicht ist, sollte ich den Rechner ausschalten und mich auf's Ohr hauen ;-)

Ohne Var gibt es zumindest keinen Fehler muss das mal im Auge behalten.
Eigentlich ist gs schon vom Type TNegativeArray die TSprite Classe wird dort erst generiert.

Delphi-Quellcode:
    Fdata : array of TSprite;

jetzt meldet er aber hier ohne Var Parameter
Zitat:

[DCC Hinweis] uGlobal.pas(144): H2077 Auf 'Value2' zugewiesener Wert wird niemals benutzt
[DCC Hinweis] uGlobal.pas(143): H2077 Auf 'Value1' zugewiesener Wert wird niemals benutzt
Ist auch logisch da nichts zurück gegeben wird.

Delphi-Quellcode:
procedure SWAP(Value1, Value2: TSprite);
var
   lTemp: TSprite;
begin
   lTemp := Value1;
   Value1 := Value2;
   Value2 := lTemp;
end;
Schalte ich den Var Parameter wieder ein kommt diese Meldung
Zitat:

[DCC Fehler] uMain.pas(1588): E2197 Konstantenobjekt kann nicht als Var-Parameter weitergegeben werden
usw..


gruss

nahpets 9. Mai 2017 00:44

AW: Alter Classe neue zuweisen
 
Du willst aber doch zwei Elemente aus gS vertauschen (die Elemente mit Index FlagFound und Index Item), also zwei TSprite und nicht zwei TNegativeArray.

In gS[FlagFound] soll sich anschließend gS[Item] befinden und in gS[Item] soll sich gS[FlagFound] befinden.

Oder hab' ich da was noch nicht recht verstanden.

Liege ich falsch, beschreib' bitte mal verbal, was Du erledigen möchtest. Eventuell kommen wir dann weiter.

EWeiss 9. Mai 2017 00:50

AW: Alter Classe neue zuweisen
 
Nein Zwei identische classen TNegativeArray

definiert als
Delphi-Quellcode:
gs: TNegativeArray;


die TSprite Classen werden in der Classe TNegativeArray erstellt.

Delphi-Quellcode:
Fdata : array of TSprite;


ich möchte jetzt gs einen neuen Index "Item" zu weisen von der Classe TSprite.
Die dann alle Eigenschaften von der Classe TNegativeArray und des Arrays von TSprite enthält.

gruss

nahpets 9. Mai 2017 01:04

AW: Alter Classe neue zuweisen
 
Du definierst
Delphi-Quellcode:
var
  gs: TNegativeArray;
Im Eingangspost schriebst Du
Delphi-Quellcode:
gS[FlagFound] := gS[Item];

Das bedeutet meiner Meinung nach, dass Du zwei Elemente des TNegativeArray gS vertauschen möchtest.

Stimmt das, oder bin ich gerade auf dem Holzweg?

TNegativeArray enthält doch (glaub' ich) 1 bis n Elemente der Klasse TSprite.

Oder ist es andersherum, dass TSprite eine Array ist, dass Elemente der Klasse TNegativeArray enthält?

EWeiss 9. Mai 2017 01:16

AW: Alter Classe neue zuweisen
 
Zitat:

TNegativeArray enthält doch (glaub' ich) 1 bis n Elemente der Klasse TSprite.
Richtig so ist es.

Delphi-Quellcode:
gS[FlagFound] := gS[Item];


gs soll vertauscht werden damit der Inhalt von gs[Item] im gS[FlagFound] enthalten ist.
vorher kann ich den Index FlagFound nicht durch den von Item ersetzen.

gruss

nahpets 9. Mai 2017 01:26

AW: Alter Classe neue zuweisen
 
Das TSprite aus gS[FlagFound] soll sich also nachher in gS[Item] befinden und das aus gS[Item] in gS[FlagFound].

Meiner Meinung nach müsste das mit dem Vorschlag aus Post #5 funktionieren.

EWeiss 9. Mai 2017 01:33

AW: Alter Classe neue zuweisen
 
Zitat:

Zitat von nahpets (Beitrag 1370643)
Das TSprite aus gS[FlagFound] soll sich also nachher in gS[Item] befinden und das aus gS[Item] in gS[FlagFound].

Meiner Meinung nach müsste das mit dem Vorschlag aus Post #5 funktionieren.

Alle Informationen aus gS[Item] (TSprite) sollen sich dann im gS[FlagFound] befinden
und gS[FlagFound] bekommt den Index von Item zugewiesen.

Es geht nicht mit der Version im Beitrag 5 warum habe ich daraufhin geantwortet ;)

Delphi-Quellcode:
                  // SWAP Item
                  if Item <> FlagFound then
                  begin
                    //SWAP(gS[FlagFound], gS[Item]);
                    gS[FlagFound] := gS[Item];
                    FlagFound := Item;
                  end;

gruss

nahpets 9. Mai 2017 01:41

AW: Alter Classe neue zuweisen
 
Irgendwie verstehe ich das nicht und hab' momentan auch keine Idee, was da jetzt nicht funktioniert und warum :-(

Ärgerlich.

EWeiss 9. Mai 2017 01:53

AW: Alter Classe neue zuweisen
 
Zitat:

Zitat von nahpets (Beitrag 1370645)
Irgendwie verstehe ich das nicht und hab' momentan auch keine Idee, was da jetzt nicht funktioniert und warum :-(

Ärgerlich.

Es geht deshalb nicht!
Zitat:

[DCC Fehler] uMain.pas(1590): E2197 Konstantenobjekt kann nicht als Var-Parameter weitergegeben werden
Delphi-Quellcode:
SWAP(gS[FlagFound], gS[Item]);


wirft den Fehler.
Und den Var-Parameter brauche ich weil sonst nichts zurückgegeben wird.

Vielleicht ist ja ein direkter Cast möglich kann es jetzt nur noch nicht testen.
Delphi-Quellcode:
gS[FlagFound] := gS[Item];


gruss

nahpets 9. Mai 2017 01:56

AW: Alter Classe neue zuweisen
 
Das sind doch garkeine Var-Parameter drinne:
Delphi-Quellcode:
procedure SWAP(Value1, Value2: TSprite);
var
   lTemp: TSprite;
begin
   lTemp := Value1;
   Value1 := Value2;
   Value2 := lTemp;
end;
Hm, was verstehe ich denn hier jetzt nicht?

Ist wohl doch zu spät oder noch zu früh? ;-)

EWeiss 9. Mai 2017 02:10

AW: Alter Classe neue zuweisen
 
Zitat:

Zitat von nahpets (Beitrag 1370647)
Das sind doch garkeine Var-Parameter drinne:
Delphi-Quellcode:
procedure SWAP(Value1, Value2: TSprite);
var
   lTemp: TSprite;
begin
   lTemp := Value1;
   Value1 := Value2;
   Value2 := lTemp;
end;
Hm, was verstehe ich denn hier jetzt nicht?

Ist wohl doch zu spät oder noch zu früh? ;-)

Ich sagte doch ich musste sie wieder hinzufügen weil sonst diese Fehler kommen. ;)
Zitat:

[DCC Hinweis] uGlobal.pas(144): H2077 Auf 'Value2' zugewiesener Wert wird niemals benutzt
[DCC Hinweis] uGlobal.pas(143): H2077 Auf 'Value1' zugewiesener Wert wird niemals benutzt
Wenn diese Werte nicht zurückgegeben werden über "Var" dann funktioniert das nicht.
Ach spät :) Ist meine normale Arbeitszeit.

gruss

nahpets 9. Mai 2017 02:19

AW: Alter Classe neue zuweisen
 
Hab' mal etwas gesucht, da mir nix einfällt.

Swap 2 objects - how?

Hilft das irgendwie weiter?

EWeiss 9. Mai 2017 02:23

AW: Alter Classe neue zuweisen
 
Zitat:

Zitat von nahpets (Beitrag 1370649)
Hab' mal etwas gesucht, da mir nix einfällt.

Swap 2 objects - how?

Hilft das irgendwie weiter?

Danke dir für das Suchen ;)
Werde mich damit mal befassen vielleicht ist was brauchbares dabei.

gruss

hoika 9. Mai 2017 07:05

AW: Alter Classe neue zuweisen
 
Hallo,
das ist hier ein Stochern im Nebel.
Viel zu wenig Quellcode, mindestens die Definition von TSprite ist hier noch notwendig ...

procedure SWAP(Value1, Value2: TSprite);

Was ist TSprite, Klasse oder ein Record?

Wenn es eine Record ist, muss das var davor, bei einer Klasse nicht,
solange in der Methode selbst keine neue Klasse erzeugt wird (Tauschen ist nicht "neu erzeugen")

procedure SWAP(var Value1, Value2: TSprite);

Die Meldung des Compilers ist genau richtig

procedure SWAP(Value1, Value2: TSprite);
Value1 und Value2 werden auf dem Stack neu angelegt (Achtung, nicht mit dem Erzeugen von Klassen verwechseln),
dann wird der Inhalt der übergebenen Werte in die beiden Stack-Variablen reinkopiert

var
lTemp: TSprite;
begin
lTemp := Value1;
Value1 := Value2;
Value2 := lTemp;
end;

[DCC Hinweis] uGlobal.pas(144): H2077 Auf 'Value2' zugewiesener Wert wird niemals benutzt
[DCC Hinweis] uGlobal.pas(143): H2077 Auf 'Value1' zugewiesener Wert wird niemals benutzt

lTemp: noch ein Variable
Value1 := Value2;
Value2 := lTemp;

Wertezuweisung ohne Sinn

end;
Hier werden Value1,Value2,lTemp wider freigegeben,
der Inhalt der Ursprungsvariablen, die an Swap übergeben worden sind, bliebt erhalten.

Lösung bei Records
procedure SWAP(var Value1, Value2: TSprite);

EWeiss 9. Mai 2017 07:16

AW: Alter Classe neue zuweisen
 
Zitat:

das ist hier ein Stochern im Nebel.
Entschuldige bitte. ;)
Ich habe hier in der ersten Zeile die komplette classe gepostete. (die aufzurufende funktion wurde vom linker entfernt)
Mehr geht beim besten willen nicht.

gruss

Ghostwalker 9. Mai 2017 07:21

AW: Alter Classe neue zuweisen
 
Zitat:

Zitat von EWeiss (Beitrag 1370644)
Zitat:

Zitat von nahpets (Beitrag 1370643)
Das TSprite aus gS[FlagFound] soll sich also nachher in gS[Item] befinden und das aus gS[Item] in gS[FlagFound].

Meiner Meinung nach müsste das mit dem Vorschlag aus Post #5 funktionieren.

Alle Informationen aus gS[Item] (TSprite) sollen sich dann im gS[FlagFound] befinden
und gS[FlagFound] bekommt den Index von Item zugewiesen.

Es geht nicht mit der Version im Beitrag 5 warum habe ich daraufhin geantwortet ;)

Delphi-Quellcode:
                  // SWAP Item
                  if Item <> FlagFound then
                  begin
                    //SWAP(gS[FlagFound], gS[Item]);
                    gS[FlagFound] := gS[Item];
                    FlagFound := Item;
                  end;

gruss

Öhm.......reicht da nicht einfach

Delphi-Quellcode:
function MySwap(var gs:TNegativArray; var FlagFound,Item:integer);
begin
gS[FlagFound].assign(gs[item]);
FlagFound := Item;
end;
?

EWeiss 9. Mai 2017 07:22

AW: Alter Classe neue zuweisen
 
Werde ich mal versuchen.. Danke Uwe

gruss

EWeiss 9. Mai 2017 07:26

AW: Alter Classe neue zuweisen
 
Delphi-Quellcode:
 gS[FlagFound].assign(gs[item]);


assign gibt es ja nicht in der Classe.

Delphi-Quellcode:
procedure Swap(var gs: TNegativeArray; var FlagFound, Item: integer);
gruss

Ghostwalker 9. Mai 2017 07:37

AW: Alter Classe neue zuweisen
 
Dann ergänz doch einfach die TSprite-Klasse um diese Methode :)

Da werden letzt endlich ja nur die Eigenschaften und Felder zugewiesen.

Muster:

Delphi-Quellcode:
procedure TSprite.Assign(source:TPersistent);
begin
  if (source is TSprite) then
  begin
    field1 := source.field1;
    :
    Property1 = source.property1;
    :
  end;
end;

EWeiss 9. Mai 2017 07:43

AW: Alter Classe neue zuweisen
 
Zitat:

Zitat von Ghostwalker (Beitrag 1370668)
Dann ergänz doch einfach die TSprite-Klasse um diese Methode :)

Da werden letzt endlich ja nur die Eigenschaften und Felder zugewiesen.

Muster:

Delphi-Quellcode:
procedure TSprite.Assign(source:TPersistent);
begin
  if (source is TSprite) then
  begin
    field1 := source.field1;
    :
    Property1 = source.property1;
    :
  end;
end;

sorry aber was ist da field1 und Property1
Muss da jetzt leider Raten ;)

Für dich ist das alles einfach..

gruss

Ghostwalker 9. Mai 2017 07:47

AW: Alter Classe neue zuweisen
 
Das is nur ein Beispiel, da ich ja die genauen Felder bzw. Eigenschaften der TSprite-Klasse nicht kenne ;)

ISurf 9. Mai 2017 08:19

AW: Alter Classe neue zuweisen
 
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;

EWeiss 9. Mai 2017 15:11

AW: Alter Classe neue zuweisen
 
Zitat:

Zitat von ISurf (Beitrag 1370687)
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;

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

gruss

nahpets 9. Mai 2017 15:20

AW: Alter Classe neue zuweisen
 
Da es sich bei Dir um TSprite handelt, sollte auch dashier ok sein:
Delphi-Quellcode:
lTemp: TSprite;
Prinzipiell müsste es gehen, wenn man den kleinsten gemeinsamen Nenner an Stelle von TObject angibt.
Wenn Deine Klassen als Vorfahren alle z. B. von TComponent abgeleitet sind, direkt oder auch über mehrere Zwischenstufen, dann könntest Du für lTemp TComponent nehmen.

Die Swap-Routine könntest Du dann für den Tausch aller Klassen vom Typ TComponent und deren Nachfolger verwenden.

TSprite ist ein Nachfolger von TObject, damit müsste der Tausch eigentlich mit der Routine gelingen.

himitsu 9. Mai 2017 15:30

AW: Alter Classe neue zuweisen
 
Zitat:

Wenn es eine Record ist, muss das var davor, bei einer Klasse nicht,
kommt drauf an

1) wenn man die Objektzeiger tauschen will, dann mit VAR
2) und will man die Objektinhalte tauschen, dann OHNE, da sich ja die Zeiger nicht ändern

Allerdings braucht man beim 2. eventuell einen kompletten zwischen Speicher (z.B. ein drittes Objekt oder ein Stream, in den der Zustand des ganzen Objektes rein serialisiert wird)
* entweder man kopiert vom kompletten Objekt die Property/Felder in ein 3. Objekte
und dann Objekt 2 in 1 und anschließend Temp in 2
(am Besten wäre es, wenn die Objekte das Assign ordentlich implementiert haben, oder sich serialisieren lassen)
* oder man kopiert jedes Property/Feld einzeln und nacheinander, z.B. über eine Swap-Methode

Uwe Raabe 9. Mai 2017 15:31

AW: Alter Classe neue zuweisen
 
Zitat:

Zitat von ISurf (Beitrag 1370687)
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 9. Mai 2017 15:57

AW: Alter Classe neue zuweisen
 
Liste der Anhänge anzeigen (Anzahl: 2)
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:

Anhang 47288

EWeiss 9. Mai 2017 15:59

AW: Alter Classe neue zuweisen
 
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 11. Mai 2017 23:49

AW: Alter Classe neue zuweisen
 
Zitat:

Zitat von EWeiss (Beitrag 1370759)
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 11. Mai 2017 23:56

AW: Alter Classe neue zuweisen
 
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


Alle Zeitangaben in WEZ +1. Es ist jetzt 22:15 Uhr.

Powered by vBulletin® Copyright ©2000 - 2022, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2021 by Daniel R. Wolf