Globale Variablen und OOP

[TankWart]

Hallo zusammen,
meine Kenntnisse was OOP angeht sind ziemlich eingeschrenkt,
daher meine Frage, wie geht man richtig vor um Globale Variablen zu vermeiden?

z.B. Über einem Button wird einer Variablen ein Wert zugewießen und später wird der Wert abgefragt.

Hat da jemand ein kurzes, Beispiel?
Oder ein Tutorial?

Möglichkeiten wo man da gerne Globale Variablen einsetzen würde, gibt es ja bestimmt tausende.

Zudem suche ich ein gutes Buch (sollte auch leicht verständlich sein) über OOP am besten im Zusammenhang mit Delphi, falls möglich in Deutsch.

Auserdem bin ich auf der Suche nach Bücher, Tutorials, Scripte, Webseiten,... über Datenbanken mit Delphi 7 und Firebird.

Vielleicht hat ja jemand einen Tipp


Ich danke schon mal im Voraus

Gruß

Tankwart

[Phoenix]

Im Prinzip ist das Vorgehen recht einfach:

Du machst Dir vorher genaue Gedanken darüber, WO Du diesen Wert überall brauchst. Und dann wirst Du ziemlich schnell sehen, dass das meist nur an zwei, drei Stellen ist, die alle irgendwie zusammenhängen. Dann suchst Du Dir das Objekt aus, zu welchem dieser Wert am ehesten passt und deklarierst den Wert als Property dieses Objektes.

That's it.

[sirius]

Im allgemeinen gehören (nicht lokale) Variablen zu irgendeiner Klasse. Und genau da solltest du sie auch definieren.
Für dein Beispeil wahrscheinlich:

Delphi-Quellcode:

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
    meine_variable1:integer;
    meine_variable2:string; 
  public
    { Public-Deklarationen }
    function get_meine_variable1:integer;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  meine_variable1:=0;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  inc(meine_variable1);
end;

function TForm1.get_meine_variable1:integer;
begin
  result:=meine_variable1;
end;

Damit hast du gesichert, dass bei jeder neuen Instanz von TForm1 eine neue Variable (meine_variable1) existiert.

[TankWart]

Danke für die schnellen Antworten,
das hat mir schon mal weiter geholfen.

Habt ihr noch einen Tipp für ein Buch über OOP mit Delphi,
oder ein Buch das allgemein das Thema OOP beschreibt.
Wo auch beschrieben ist, wie Vernünftig programmiert wird wenn Sourcecode
auch in anderen Programmen wieder verwendet werden soll.

Irgendwie habe ich in solchen Sachen nicht so recht den Plan, wie ich da vorgehen soll,
das der Quellcode nicht jedes mal mortz umgeschrieben werden muss.

Tutorials, Scirpte und alles andere sind naklar auch erwünscht.

Gruß

Tankwart

[Pfoto]

Hi!

Ich war mir früher auch unsicher, wo ich am sinnvollsten meine eigentlich
Objekt-unabhängigen Variablen (oder globalen Objekte) zuordnen soll.

Du kannst z.B. dafür ein schlankes Objekt (oder nur eine Klasse) kreieren,
über die du auf diese Variablen zugreifst. Beim Initialisieren kannst
du so vorab gültige Werte einstellen. Dieses Objekte würde ich dann in
einer allgemeinen Unit zugänglich machen. So trennst du - zumindest ein
wenig - die Controls und die Daten-Klassen.
Beim Initialisieren kannst du dann Deine Objekte darin erstellen lassen
und auch später wieder ordentlich zerstören.

Wenn Du - wie du schreibst - eine Variable global ablegen willst, würde
ich dafür vielleicht sogar ein Extra-Objekt kreieren, dass für die
Verwaltung und Weiterverarbeitung dieses Wertes zuständig ist. So hast
du alles rund um diese Sache übersichtlich in einem Objekt.
Also z.B. so:

Delphi-Quellcode:

TDataContainer = class
private
  fValue: integer;
  procedure SetValue(aValue: integer);
public
  property Value: integer read fValue write SetValue;
  function WriteToFile(aFilename: string): Boolean;
  function ReadFromFile(aFilename: string): Boolean;
end;

Hier sind als Beispiel Datei-Funktionen vorhanden...


Ich empfehle dir unbedingt, dich mehr mit dem Thema "Patterns", also "Muster"
zu beschäftigen. Wenn du schon dabei bist, OOP zu lernen, dann ist das
gleich ein sinnvoller Weg, zukünftige Aufgaben etwas flexibler und
eleganter zu lösen.
Im Internet gibt es einige Artikel auf im Bezug auf Delphi, aber viel mehr
mit Hilfe von Java und C++/C#. Genauso sieht's bei den Büchern aus.

z.B. hier habe ich einiges gefunden: www.Delphi3000.com (Patterns)
Hier als Tipp das Command-, Singleton- und Observer-Pattern


Das eigentliche Prinzip der OOP ist jedoch in jeder Programmiersprache gleich.


Gruß
Pfoto

[IngoD7]

Zitat von Phoenix:

Dann suchst Du Dir das Objekt aus, zu welchem dieser Wert am ehesten passt und deklarierst den Wert als Property dieses Objektes.

Und notfalls baut man sich ein Objekt, dass alle Variablen als Property aufnimmt.

Dann hat man keine globalen Variablen mehr, aber ein globales Objekt mit globalen Eigenschaften. Wenn's denn hilft ...

Ich verstehe nach wie vor die angeblich vorhandene Notwendigkeit zur Vermeidung von globalen Variablen nicht.

[sirius]

[quote="IngoD7
Ich verstehe nach wie vor die angeblich vorhandene Notwendigkeit zur Vermeidung von globalen Variablen nicht.[/quote]

1. Durch globale Variablen kann man sich in einem ansonsten objekt-belasteten Programm sehr schnell Fehlerquellen bauen. Deswegen ist immer zuerst zu prüfen, ob die Variable nicht zu einer Klasse zugehörig ist.

2. Ein Datencontainer ist günstig, da du dadurch mehrere Instanzen dieses Containers initialisieren kannst, und dadurch mehrere "globale" Variablen gleichen Namens hast, die du dann auch brauchst. Aber eben nicht immer.

3. Für den Fall der Fälle, dass du ein und dieselbe Variable über mehrere Instanzen deiner Klasse haben willst gibt es Klassenvariablen

4. Wenn das alles nicht hilft, nimm eine gloabel Variable.

[Elvis]

Zitat von IngoD7:

Und notfalls baut man sich ein Objekt, dass alle Variablen als Property aufnimmt.
Dann hat man keine globalen Variablen mehr, aber ein globales Objekt mit globalen Eigenschaften. Wenn's denn hilft ...

Au weia...
Du musst dir überlegen wann und wo du welche Werte brauchst. Und ob bzw. wie sich diese Werte intuitiv in Klassen modellieren lassen.
Nach dem du jetzt weißt wo du sie brauchst musst du dir nur einen oder mehrere Instanzen wählen, die für die eine Referenz darauf halten, und denen man zum Bleistift im Konstruktor diesen Wert übergeben kann. (Muss nicht sein, read/write Properties sind auch OK )

Zitat:

Ich verstehe nach wie vor die angeblich vorhandene Notwendigkeit zur Vermeidung von globalen Variablen nicht.

Skalierbarkeit.
Globale Variablen sind so ziemlich das übelste was dir passieren kann.
Denn sie sind

1. von überall beschreibbar
2. Es gibt keinen Setter, der dich über Änderungen informieren kann
3. Müllen Code completion sinnlos zu, weshalb dich wohl jeder Benutzer deiner Units verfluchen wird.

Aber auch class properties und Singletons fallen unter "beschissen zu Skalieren oder wiederverwenden".
Du verzwirbelst deinen Code so sehr untereinander, dass du einzelne Teile nicht für etwas anderes benutzen kannst. Außer durch Copy'n Waste mit anschließendem Ändern. (wodurch Bug fixes an dem einen nicht zu Bug fixes am anderen werden -> D'oh! )

[IngoD7]

Vorab:
Der Fragesteller fängt - wie es aussieht - doch gerade erst an mit Delphi und OOP; und da würde ich ihm niemals anraten wollen, krampfhaft auf globale Variablen zu verzichten. Für einen Anfänger ist das nämlich ein Krampf (Datenmodule, eigene Klassen, etc.). Deshalb schrieb ich ja auch von meinem fehlenden Verständnis für eine Notwendigkeit, auf globale Variablen zu verzichten. Es gibt diese absolute Notwendigkeit nicht.

Zitat von sirius:

1. Durch globale Variablen kann man sich in einem ansonsten objekt-belasteten Programm sehr schnell Fehlerquellen bauen. Deswegen ist immer zuerst zu prüfen, ob die Variable nicht zu einer Klasse zugehörig ist.
2. Ein Datencontainer ist günstig, da du dadurch mehrere Instanzen dieses Containers initialisieren kannst, und dadurch mehrere "globale" Variablen gleichen Namens hast, die du dann auch brauchst. Aber eben nicht immer.
3. Für den Fall der Fälle, dass du ein und dieselbe Variable über mehrere Instanzen deiner Klasse haben willst gibt es Klassenvariablen

Alles korrekt.

Zitat von sirius:

4. Wenn das alles nicht hilft, nimm eine gloabel Variable.

Eben!

Zitat von Elvis:

Au weia...
Du musst dir überlegen wann und wo du welche Werte brauchst. Und ob bzw. wie sich diese Werte intuitiv in Klassen modellieren lassen.
Nach dem du jetzt weißt wo du sie brauchst musst du dir nur einen oder mehrere Instanzen wählen, die für die eine Referenz darauf halten, und denen man zum Bleistift im Konstruktor diesen Wert übergeben kann. (Muss nicht sein, read/write Properties sind auch OK )

Dein "Au weia" kannst du dir sparen, es sei denn, du kannst beweisen, die alleinige Weisheit gepachtet zu haben.

Wieso ist ständig von mehreren Instanzen die Rede??? Dass das alles fein geht, bestreitet doch niemand. Aber wer von mehreren Instanzen spricht, denkt eh nicht mehr an globale Variablen, oder?

Zitat von Elvis:

Denn sie sind

1. von überall beschreibbar
2. Es gibt keinen Setter, der dich über Änderungen informieren kann
3. Müllen Code completion sinnlos zu, weshalb dich wohl jeder Benutzer deiner Units verfluchen wird.

Aber auch class properties und Singletons fallen unter "beschissen zu Skalieren oder wiederverwenden".
Du verzwirbelst deinen Code so sehr untereinander, dass du einzelne Teile nicht für etwas anderes benutzen kannst. Außer durch Copy'n Waste mit anschließendem Ändern.

Ist ja alles nicht falsch. Es ist aber für die meisten kleinen Projekte eines Newbies irrelevant. Der Fragesteller hier wird deine Erklärungen wahrscheinlich nicht einmal verstehen können.

Ich möchte den sehen, der angefangen ist zu programmieren, ohne globale Variablen benutzt zu haben.
Es ist m.E. unnötig (gerade am Anfang auch nahezu unmöglich), krampfhaft auf sie zu verzichten. Man kann es natürlich gerne versuchen, und das Begehren, gleich am Anfang der Karriere das "alles richtig" zu machen, ist ja auch lobenswert, aber es ist nicht zwingend notwendig. Mehr wollte ich nicht ausdrücken. Früher oder später wird sowieso jeder den Verzicht auf globale Variablen zu schätzen wissen und sie nach Möglichkeit vermeiden ... aber meistens nicht um jeden Preis.

[marabu]

Hallo Leute,

globale Variablen sind nicht böse per se. Um genau zu sein sollte man auch eher vom scope (Sichtbarkeitsbereich) einer Variable sprechen. Das Thema wird in der DP sehr oft angeschnitten und ich lese immer wieder bekannte pauschale Ratschläge - deshalb:

Als Informatiker wird man auf das Programmieren-im-Großen vorbereitet, die Mehrheit der DP-Mitglieder kommt aber über das Programmieren-im-Kleinen und dass (nicht nur dort) Variablen sehr schnell mal mit maximalem Scope deklariert werden, ist nachvollziehbar - eine Form von Bequemlichkeit. Das Problem sind die später häufig auftretenden Seiteneffekte, wenn ein Wert benutzt wird, der zwischenzeitlich von einer anderen Prozedur verändert wurde.

Formale Vorbildung und praktische Erfahrung führen früher oder später zur einer Disziplin: Eine Variable wird anhand der eigenen Erfahrung mit der minimalen Sichtbarkeit ausgestattet, die den aktuellen Anforderungen genügt. Ändern sich diese Anforderungen, dann ist der Scope der Variablen anzupassen.

Es ist ein langer Weg hin zur Programmierung nach den Regeln der Kunst und der Weg hat Schleifen und Sackgassen, aber der erste Schritt ist unzweifelbar: Informiert euch gewissenhaft über die sprachlichen Möglichkeiten (scope rules) der Programmiersprache. Wer die verstanden hat, der ahnt auch schon wie er diese Möglichkeiten zu seinem Vorteil nutzen kann. Danach gilt "Übung macht den Meister".

Freundliche Grüße