Erste Schritte mit Klassen - Wer hilft?

[Nonsense]

Hallo Community,
ich würde mich jetzt gerne in das Thema Klassen einarbeiten, aber diese Thematik ist so komplex, dass man davon fast erschlagen wird. :wink:

Ich möchte gerne eine Klasse TSquare erstellen. Nach einem Ereignis (z.B. OnKeyDown oder ButtonClick) wird jeweils ein Ableger erstellt (Ich glaube die heißen Instanzen, bin mir aber nicht sicher).
Wenn sie, wie in meinem Beispiel, einen bestimmten Punkt überqueren, sollen sie sich automatisch löschen (Destroy\Free).

Ich habe keine Ahnung, wo ich anfangen soll, da ich nicht so recht weiß, welche Befehle hierfür angebracht sind. Ich habe mir schon das Tutorial von Delphi-Source durchgelesen, bin aber noch sehr unsicher.

Kann mir jemand bei diesem Thema ein paar Einstiegshilfen geben?

Danke.

MfG

[Nonsense]

Kann mir keiner ein paar Anhaltspunkte geben?
:cry: :cry: :cry:

[Basic-Master]

ich kann mir nich richtig was darunter vorstellen.. mach doch unter jedem ereignis wo das erstellt wird ne überprüfung ob der wert left + width deines ablegers höher als der wert left + width von deiner linie ist, wenn ja dann lösch das ganze doch... das kannste ja mit free machen (destroy geht auch, aber free is besser).

[Christian Seehase]

Moin Nonsense,

findest Du es nicht auch ein klein wenig übertrieben (um es mal nett zu formulieren), nach einer (!!) Stunde (!!) nachzufragen?
Nach einem Tag, ok, aber nach einer Stunde...

[Nonsense]

@Christian Seehase: Ok, ich hab wohl die Dimensionen des DP überschätzt :wink: Sorry.

Ok, also, ich war ja nicht untätig und hab ein bissel was probiert.
Seid bitte so nett und korrigiert mich, wenn ich was falsch verstanden habe.

Mit:

Delphi-Quellcode:

type
  TSquare = class(TObject)
  private
   FTest: integer;
  public
 end;

kann ich eine Klasse erzeugen.
Wie kann ich jetzt einen Ableger erstellen?
Ich habe was von

Delphi-Quellcode:

 constructor Create(Test: Integer);

gelesen.

Demnach müsste ich nur noch des Konstruktor schreiben:

Delphi-Quellcode:

constructor TSquare.Create(X: integer; Y: integer);
begin
 inherited Create;

 FTest := Test;
end;

und aufrufen:

Delphi-Quellcode:

Square1 := TSquare.Create(12345);

Klappt aber irgendwie nicht. Oder habe ich da was komplett falsch verstanden?
:?:

[Christian Seehase]

Moin Nonsense,

die Deklaration des Konstruktors muss natürlich mit der der Implementierung übereinstimmen:

Delphi-Quellcode:

type
  TSquare = class(TObject)
  private
   FTest: integer;
  public
    constructor Create(Test: Integer);
  end;

implementation

constructor TSquare.Create(Test: Integer);
begin
  inherited Create;
  FTest := Test;
end;
 
// an einer Stelle, wo die Klasse benutzt wird

var
  Square1 : TSquare;

begin
  Square1 := TSquare.Create(12345);
  //...
end;

So sollte es gehen, auch wenn so eine Klasse noch nicht viel Sinn macht, und nur als Beispiel dient.

[Nonsense]

@Christian Seehase: Hab's genauso wie du, der Fehler lag woanders. Es klappt jedenfalls.
Wie kann ich jetzt beliebig viele Ableger der Klasse erstellen? Ich meine ohne das ich diese immer extra deklarieren muss ("Square1", "Square2", etc.)?
Hab dazu noch gar nix gefunden (weder in meinen Büchern nochunter Delphi-Source).

[Christian Seehase]

Moin Nonsense,

wenn Du eine Klasse erstellst, die keinen Owner hat, wie z.B. von TComponent abgeleitete Klassen, musst Du Dich zwingend auch selber wieder um die Freigabe der durch die Instanzen der Klasse belegten Resourcen kümmern.
Ausserdem:
Um mit den Instanzen der Klasse arbeiten zu können, musst Du sie irgendwo speichern, mal unabhängig davon, ob sie nun einen Owner haben oder nicht.
Dazu könntest Du z.B. auch eine Tabelle (array) oder ein TList Objekt verwenden.
Dann müsstest Du zumindest nicht je eine Variable deklarieren.

[Nonsense]

Meine ganz Denkweise kommt daher, dass ich mal vor Ewigkeiten (gute 3 Jahre :wink: ) in DelphiX programmiert habe. Dort gab es einen 2D-Shooter, bei dem man, wieder der Name schon sagt, auch schießen konnte. Ich glaube mich zu erinnern, dass die Schüsse Instanzen einer Klasse waren.

Ist ja auch egal, es geht mir ja mehr um die Theorie als um grafische Spielereien.

Deshalb dachte ich, dass man einfach unendlich viele Instanzen erstellen kann. Da ist es ja egal, dass ich die Resourcen selbst freigeben muss, da sie ja sowieso nach ein paar Pixeln wieder gelöscht werden.

Also ist direkt nicht möglich, wie ich es mir vorgestellt habe?

[Christian Seehase]

Moin Nonsense,

Du kannst natürlich einer Variablen beliebig oft ein Objekt zuweisen.
Du musst halt nur daran denken, vor einer erneuten Zuweisund das jeweils enthaltenen Objekt wieder freizugeben.

[Nonsense]

Mhh, dann würde ja mein Beispiel gar nicht funktionieren. Immerhin sollen sich ja mehrer Objekte gleichzeitig und an unterschiedlichen Positionen bewegen.
Und funktioniert denn kein

Delphi-Quellcode:

constructor Create(AParent: TObject);

?

Das ganze kombiniert mit

Delphi-Quellcode:

constructor TSquare.Create(AParent: TObject);
begin
 inherited Create();
 [...]
end;

Hab es jetzt nicht getestet, ich geh ja sowieso nur vom theoretischen Standpunkt aus.

Edit: Habs nochmal überarbeitet. Er gibt mir jedenfalls keine Fehler mehr aus.

[Christian Seehase]

Moin Nonsense,

wenn Du verschiedene Objekte gleichzeitig benötigst, und ansprechen willst, musst Du diese auch alle irgendwo speichern.
Sei es nun in einzelnen Variablen, in einem Array, einer TList, oder was einem sonst noch so einfällt.

Delphi-Quellcode:

constructor Create(AParent: TObject);

kannst Du natürlich schreiben, die Frage ist jetzt halt, was Du damit bezweckst.

[Nonsense]

Dass wird so nix, wie ich mir das vorstelle.
Irgendwie hatte das damals geklappt, wie gesagt, aber mit DelphiX.
Hatte den Code mal von einer alten Sicherungs-CD rausgekramt, und:

Delphi-Quellcode:

 
TPlayer = class(TImageSprite)
private
 Mode: Integer;
 [...]
protected
 procedure Collision(Sprite: TSprite; var Done: Boolean); override;
 procedure Move(MoveCount: Integer); override;
public
 constructor Create(AParent: TSprite ); override;
end;

TPlayerShoot = class(TImageSprite)
private
 Player: TPlayer;
protected
 procedure Collision(Sprite: TSprite; var Done: Boolean); override;
 procedure Move(MoveCount: Integer); override;
public
 constructor Create(AParent: TSprite); override;
 destructor Destroy; override;
end;

Naja, irgendwie wird das mit meinem Wischwasch nix. :wink:

[MrSpock]

Hallo Nonsense,

Christian hat dir doch schon einige Hinweise gegeben, wie es funktioniert.
Was ist denn genau dein Problem?

Du kannst beliebig viele Instanzen eines Klasse erstellen. Lediglich der verfügbare Speicherplatz ist eine Grenze. Wenn du auf diese Objekte zugreifen willst, benötigst du eine Struktur (z.B. ein Array oder eine Liste), um auf die Objekte ansprechen zu können. Du willst ja z.B. die Position ändern oder den Zustand. Das mit dem Freigeben hat Christian ja auch schon erklärt. Grundsätzlich bist du selbst dafür verantwortlich (auch dazu benötigst du ein Zugriff auf das freizugebende Objekt).

Bestimmte Basisklassen haben aber bereits eine Eigenschaft Owner (z.B. TComponent), diese kannst du setzen, dann kümmert sich der Owner um die Freigabe. TObject kennt einen solchen Mechanismus noch nicht. Was du dir also als erstes überlegen musst, ist, von welcher Basisklasse du deine neue Klasse ableiten willst. Benötigst du kein Windowshandle, solltest du TGraphicControl nutzen.

Code:

TNonsenseSeineShooterClass = Class(TGraphiControl)
...

Jetzt müsstest du doch schon einen Schritt weiter kommen, oder?

[Nonsense]

Danke @ MrSpock:
Ja, eigentlich schon. Ich hatte mir die ganze Beschreibung auf Delphi-Source mittlerweile schon ein viertes mal durchgelesen und langsam kommt Licht in die Sache.
Irgendwie klammere ich mich aber noch zu sehr an die Umsetzung von DelphiX.
Um mal wieder auf mein Beispiel zurück zu kommen: Nehmen wir an, ich speichere jetzt die einzelnen Daten in einem Array, kann ich dann eigentlich allg. überprüfen ob irgendeine Instanz der Klasse die rote Linie überquert hat?
Ich meine, es wäre ja umständlich jede einzelne Instanz abzufragen.
Oder geht das auch nicht?

[Motzi]

Alternativ zu Delphi-Source kann ich dir noch meine Ausarbeitung zu OOP mit Delphi anbieten - vielleicht hift sie dir ein bisschen weiter: www.x-spy.net/personal

[MrSpock]

Hallo Nonsense,

wenn du Objekte bewegen willst, musst du ja für jede zu bewegende Instanz eine Methode z.B. Move aufrufen. Diese hätte die Aufgabe, die neue Position zu errechnen und dabei auch zu prüfen, ob die rote Linie überschritten wird.

[Nonsense]

@Motzi: Der Server scheint down zu sein.

@MrSpock: Ja, so habe ich mir das ja auch von Anfang an gedacht. So das die jeweilige Instanz die procedure erbt. Sprich: Die Instanz wird erstellt und per procedure bewegt.

[Motzi]

Zitat:

Zitat von Nonsense

@Motzi: Der Server scheint down zu sein.

Also bei mir funktioniert es problemlos..! :gruebel: