Globale Variablen!

[tmode00]

Hi Leuts.

ich habe wiedereinmal ein kleines Problemchen!
Also:

Wie mache ich das, wenn man keine Globalen Variablen verwenden sollte, aber man möchte das z.b.alle Objekte (Forschungsfabrik, Panzer, Mine..... irgendwas) auf ein Feld von Spieler zugreifen können z.B. Geld, denn wenn ich eine Mine baue dann kostet das ja was ! Wenn ich nun also eine Klasse erstelle

Delphi-Quellcode:

type
TSpieler = class

public
Geld:Integer;
end;

Und dann Im OnCreate Bereich des Forms:

Delphi-Quellcode:

var Spieler: TSpieler;
begin
Spieler:= TSpieler.Create;
Spieler.Geld:= 10000
end;

halt Geld zuweise dann ist das ja nur für das Formular bzw. für die OnCreate Ereignisroutine gültig und wenn ich das nun irgendwo anders verwenden will dann ist zwar die dekleration gültig aber nicht die Implementation da das Objekt ja Quasi 2 mal erstellt wird!

[r2c2]

Zitat:

Zitat von tmode00

halt Geld zuweise dann ist das ja nur für das Formular bzw. für die OnCreate Ereignisroutine gültig und wenn ich das nun irgendwo anders verwenden will dann ist zwar die dekleration gültig aber nicht die Implementation da das Objekt ja Quasi 2 mal erstellt wird!

Was machst du dir das denn hier so kompliziert? Mach den spieler einfach zu feld einer Klasse(von mir aus zum Feld der Form). Besser ist du erstellst dir ne "Rahmenklasse", die alle Objekte instanziert und wieder freigibt. Die kannst du IMHO auch ausnahmsweise global machen(Die Formvariable is ja auch Global; Wichtig is IMHO nur, dass du nicht alles, was Feld sein soll Global machst, dann hast du nämlich Chaos).

mfg
Christian

[BlackJack]

Zitat:

Zitat von tmode00

halt Geld zuweise dann ist das ja nur für das Formular bzw. für die OnCreate Ereignisroutine gültig und wenn ich das nun irgendwo anders verwenden will dann ist zwar die dekleration gültig aber nicht die Implementation da das Objekt ja Quasi 2 mal erstellt wird!

wie was wo? jetzt erklär nochmal genau wo die variablen stehen, wo die klassen erzeugt werden etc.

und ansonsten: die anderen klassen wie z.b. TSpieler müssen einfach eine variable vom typ TGeld haben, und wenn du einen TSpieler createst, bekommt er entweder sein eigenes Geld (das eigene TGeld wird created) oder er bekommt das geld von anderen, dann musst du nur dem TGeld des TSpielers eine bereits erzeugte variable vom typ TGeld zuweisen.

[Khabarakh]

Zitat:

Zitat von r2c2

Die Formvariable is ja auch Global

Dass Borland das so macht, heißt nicht, dass es auch gute OOP ist :wink: .
Aber ich denke auch, dass man bei einer Instanz, die wirklich überall benötigt wird, eine Ausnahme machen kann.

[tmode00]

Also,

Im Interface Teil:

Delphi-Quellcode:

Type
TSpieler = class(TObject) //Spielerklasse

private
Geld:Integer;  //Feld von Spieler was das gesamte Geld des Spielers beinhalten soll

end;

Im Implementationsteil (in irgeneiner Routine):

Delphi-Quellcode:

var Spieler: TSpieler
begin
Spieler := TSpieler.create;
Spieler.Geld := 1000;
Spieler.free;
end;

So nun hat der Spieler innerhalb der Routine 1000 Geld. Aber von überall soll man Geld verwenden können z.B.:

Button1.Click:

Delphi-Quellcode:

var Wasgeldkostet: TSpieler;
begin
Wasgeldkostet := TSpieler.Create;

Label1.caption := InToSTR(Wasgeldkostet.Geld) //würde nichts ergeben!
end;

Nun möchte ich aber das wasgeldkostet auf das Spielergeld zugreift! Ich weis nicht wie ichs genauer erklären soll was ich meine....

[SirThornberry]

dann musst du den Spieler eben in Private declarieren bzw. in Public (je nach dem wie sichtbar das werden soll.
Also wird das

Delphi-Quellcode:

var Spieler: TSpieler 
begin 
  Spieler := TSpieler.create; 
  Spieler.Geld := 1000; 
  Spieler.free; 
end;

zu

Delphi-Quellcode:

TForm1 = class(TForm)
[...]
public
  Spieler: TSpieler
[...]

procedure TForm1.FormCreate(Sender: TObject);
begin
  Spieler := TSpieler.Create;
end;
[...]
procedure TForm1.OneOfYourMoneyProcedures;
begin
  Spielder.Geld := 1000;
end;
[...]
procedure TForm1.FormDestroy(Sender: TObject);
begin
  Spielder.Free;
end;

somit ist Spieler nicht Global und kann doch noch von überall genutzt werden.
Somit können auch andere Objekte über Form1.Spieler darauf zugreifen

[tmode00]

Vielen vielen Dank, jetzt hab ich das prinzip verstanden :idea: Ich hab das nämlich nie ganz kapiert wie das gemeint ist mit den ,,Rahmenklassen" usw...

Ihr habt mir sehr geholfen!

[tmode00]

Noch eine kurze Frage,

wie würde das ganze aussehen wenn ich nicht Form1 als Rahmenklasse verwenden will, sondern eine extra Klasse welche alles zusammenfasst,also Spieler, Gebäude....usw. auf dem Heap erstellt und freigibt?

Wäre ganz toll wenn wieder so ein hochverständlicher Quelltext als Antwort käme !

[Die Muhkuh]

Na,

machs doch dann einfach so:

Delphi-Quellcode:

TRahmenklasse = class
private

public
  Spieler1: TSpieler;
  Haus: TGebaeude;
  ...

  constructor Create;
  destructor Destroy; override;
end;

procedure TRahmenklasse.Create;
begin
  Spieler1 := TSpieler.Create;
  Haus := TGebaeude.Create;
end;

procedure TRahmenklasse.Destroy;
begin
  Spieler1.Free;
  Haus.Free;
end;

[Robert_G]

Hmm, was ist effektiv der Unterschied zwischen SirTs Lösung und einer globalen Vatriablen?... :gruebel:

Um dich nicht mit Interfaces zuzuschütten empfehle ich dir erstmal ein Singleton welches aus einer absrtakten öffentlichen Klasse und einer versteckten Klasse besteht, die die seine Member implementiert.
Um zu verhindern, dass die Instanz zerstört wird, wird eine Exception im Destructor ausgelöst.

Delphi-Quellcode:

interface

type
   TSingletonMoneyDings = class
   private
      function getMoney: Currency; virtual; abstract;
      procedure setMoney(const aValue: Currency); virtual; abstract;
   public
      property Money: Currency read getMoney write setMoney;
      class function Instance: TSingletonMoneyDings;
   end;


implementation
uses
   SysUtils;

type
   TRichtigesMoneyDings = class(TSingletonMoneyDings)
   private
      fMoney: Currency;
      fAllowDestruction: Boolean;
      function getMoney: Currency; override;
      procedure setMoney(const aValue: Currency); override;
   public
      destructor Destroy; override;
   end;

   InvalidSingletonDestructionException = class(Exception)
   public
      constructor Create;
   end;

var
   staticMoneyDings     : TRichtigesMoneyDings;

{ TSingletonMoneyDings }

class function TSingletonMoneyDings.Instance: TSingletonMoneyDings;
begin
   Result := staticMoneyDings;
end;

{ TRichtigesMoneyDings }

destructor TRichtigesMoneyDings.Destroy;
begin
   if fAllowDestruction then
      inherited
   else
      raise InvalidSingletonDestructionException.Create();
end;

function TRichtigesMoneyDings.getMoney: Currency;
begin
   Result := fMoney;
end;

procedure TRichtigesMoneyDings.setMoney(const aValue: Currency);
begin
   fMoney := aValue;
end;

{ InvalidSingletonDestructionException }

constructor InvalidSingletonDestructionException.Create;
begin
   inherited CreateFmt('%s can not be destroyed at this time.', [TMoneyDings.ClassName]);
end;

initialization
   staticMoneyDings := TRichtigesMoneyDings.Create();
   staticMoneyDings.fAllowDestruction := False;
finalization
   staticMoneyDings.fAllowDestruction := True;
   staticMoneyDings.Free();
end.

Benutzen kannst du sie von überall aus über Instanz:

Delphi-Quellcode:

TSingletonMoneyDings.Instance.Money := 1