Gambas: Variablen

zurück zu Gambas

Variablen

Was sind Variablen?

Eine Variable ist eine Größe, die verschiedene Werte annehmen kann. Sie ist also in ihrer Größe veränderlich. Variablen werden auch Platzhalter oder Unbekannte genannt. Sie kommen in Formeln und Termen vor.

Das Gegenteil einer Variablen ist die Konstante, also ein fester, unveränderlicher Wert. Die Kreiszahl Pi = 3,14... ist beispielsweise keine Variable, sondern eine Konstante.

Beispiele für Variable:

• x,y,z im kartesischen Koordinatensystem
• y = x^2
• Temperatur t
• Satz B

Für den Programmierer ist eine Variable ein Speicherbereich, auf den er (unter Beachtung des Datentyps) über einen eindeutigen Bezeichner (Namen) zugreifen kann. Das Variablen-Konzept ist der Kern der Imperativen Programmierung. Eine Variable muss in Gambas ausdrücklich deklariert werden.

Deklaration (Dimensionierung, Zuweisung des Datentyps)

Es gibt zwei Haupttypen von Information, die in einer Variablen gespeichert werden kann: Zahlen und Text. Bevor eine Variable benutzt werden kann, muß sie zuerst erstellt werden. Das erfolgt mit dem Befehl DIM AS .

Beispiele für die Deklaration von Variablen:

DIM x AS integer
DIM y AS float
DIM z AS String

Man kann in einem Unterprogramm nicht dieselbe Bezeichnung für 2 verschiedene Variablen heranziehen.

Man kann Dim auch einfach weglassen:

x AS integer
y AS float
z AS String

Es gibt bisher keine Möglichkeit mehr als eine Variable in einer Zeile zu deklarieren:

intA, intB, intC AS Integer

Ist leider nicht möglich. Außerdem erfolgen die Deklarationen immer am Anfang eines Unterprogammes und nicht irgendwo wild im Code. Benoit ist da ganz streng. Die korrekte Deklaration von Variablen zeigt folgendes Miniprogramm

PUBLIC SUB Button1_Click()
'Deklaration
x AS integer
y AS float
z AS String
'Zuweisung von Werten 
x = 2
y = 2.378
z = "Das ist eine korrekte Deklaration"
'Benutzung der Variablen  
print x,y,z
END

Folgendes Programm dagegen ergibt eine Fehlermeldung: x already declared

PUBLIC SUB Button1_Click()
DIM x AS integer
DIM x AS float
DIM x AS String
x = 2
x = 2.378
y = "Das ist keine korrekte Deklaration"
print x,x,x
END

Auch im folgenden Programm gibt es Ärger, da zwischen kleinen und großen Buchstaben nicht unterschieden wird:

PUBLIC SUB Button1_Click()
DIM x AS integer
DIM X AS float
DIM x$ AS String
x = 2
X = 2.378
x$ = "Das ist eine korrekte Deklaration"
print x,X,x$
END

Die Deklaration von x$ ist korrekt.

Assignment (Wertzuweisung)

Sobald eine neue Variable erstellt worden ist, kann ihr ein Wert zum Speichern zugewiesen werden. Um dies zu tun wird der Befehl = verwendet. Die Wertzuweisung wird im Englischen Assignment genannt.

Das Beispiel weist einer Variable die als Gewicht bezeichnet einen Wert zu.

Beispiel :

Gewicht = 80

Bei der Wertzuweisung muss man eine bestimmte Reihenfolge einhalten. Erst werden die Variablen deklariert, dann kann Ihnen ein Wert zugewiesen werden:

Variablen müssen am Anfang einer Klasse, Methode oder Funktion festgelegt werden.

Beispiel korrekt:

PUBLIC SUB bla()
  gewicht AS Integer
  groesse AS Integer
  gewicht = 75
  groesse = 176
END

Beispiel FALSCH !! (falsche Reihenfolge)

PUBLIC SUB bla()
  gewicht AS Integer
  gewicht = 75
  groesse AS Integer
  groesse = 176
END

Das letzte Beispiel ergibt die Fehlermeldung: Unknown identifier,groesse Zeile: xx in Form1.class

Wie kann man Variablen begrenzen

Public, Private, Static

Globale Variablen soll es nicht geben. Optional wird nur bei der Methoden Deklaration verwendet.

Public - Private

Geben Sie folgendes kleine Programm ein und schauen Sie zu, was passiert, wenn Sie auf den Button1 clicken:

PRIVATE SUB Button1_Click()
  DIM Zahl AS Integer 
  'Erstellen einer privaten lokalen Variable
  Zahl = Zahl + 1
  Textbox1.Text = Textbox1.Text & Zahl
END

Erstaunlicherweise wird in der Textbox kein Wert ausgegeben. Das liegt an der Kennzeichnung des Unterprogrammes mit PRIVATE. Tauschen Sie den Begriff PRIVATE mit PUBLIC aus und versuchen Sie Ihr Glück noch einmal:

PUBLIC SUB Button1_Click()
  DIM Zahl AS Integer 
  'Erstellen einer oeffentlichen lokalen Variable
  Zahl = Zahl + 1
  Textbox1.Text = Textbox1.Text & Zahl
END

Jetzt wird eine 1 in der Textbox ausgegeben. Wenn Sie mehrmals den Button anklicken, erscheint die 1 mehrfach.

Variablen allgemein definieren

Variablen lassen sich auch außerhalb von Funktionen deklarieren, hier ein Beispiel:

PUBLIC meldung AS String
PUBLIC SUB Form_Open()
 meldung = "Dies ist ein Test"
END SUB
PUBLIC SUB Button1_Click()
 Message.Info(meldung)
END

Sie brauchen einen Commandbutton auf Ihrer Form, um das Beispiel in Gang zu bringen.

Form_Open ist ein Ereignis wie Button1_Click. Der Code zu diesem Ereignis wird bereits beim Programmstart aufgerufen, wenn die Form geladen und geöffnet wird. Hier wird die Variable mit Public außerhalb eines Unterprogrammes deklariert. Diese Variable ist also so lange verfügbar, wie die Formular geladen ist.

Ersetzen Sie den Begriff PUBLIC durch den Begriff PRIVATE und probieren Sie das Ergebnis aus.

PRIVATE meldung AS String
PRIVATE SUB Form_Open()
 meldung = "Dies ist ein Test"
END SUB
PRIVATE SUB Button1_Click()
 Message.Info(meldung)
END

Static (Statische Variable)

Manchmal soll der Wert einer Variablen erhalten bleiben. Ruft man die Variable wieder auf, kann mit dem gemerkten Wert der Variablen weiter gearbeitet werden. Um dies zu ermöglichen gibt es den Deklarationsbefehl Static.

Wie er funktioniert zeigt folgendes Beispiel. Sie brauchen einen Befehlsknopf auf Ihrer Form um es in Gang zu bringen.

Static Public x As integer 
Public Sub Button1_Click()
 x = x + 1
 print x
End

Drückt man den Befehlsknopf wird erst x als 0 definiert. Dann wird in der Zeile x = x + 1 zur 0 die 1 dazugezählt. Mit Print x wird das Ganze im Direktfenster ausgegeben. Drückt man den Befehlsknopf mehrfach, dann erkennt man, daß das Programm sich den Wert für x gemerkt hat.

Ausgabe im Direktfenster:

1
2
3
4
5

Das Wort Static sorgt dafür, daß der Wert einer Variablen nicht einfach verschwindet. Wird sie ein zweites Mal aufgerufen, steht automatisch der alte Wert wieder zur Verfügung.

Versuchen Sie folgende Variante:

Public Sub Button1_Click()
 x As integer 
 x = x + 1
 print x
End

Drücken Sie den Befehlsknopf mehrfach. Welche Ausgabe ergibt sich?

1
1
1
1

Die Unterfunktion setzt den Wert der Variablen immer wieder auf Null zurück. Beachten Sie das die statische Variable im Gegensatz zu Visual Basic außerhalb des Unterprogrammes definiert werden muß.

Wären Sie enttäuscht, wenn das ganze auch ohne Static und Public funktioniert? Probieren Sie folgenden Code aus:

x As integer 
Public Sub Button1_Click()
 x = x + 1
 print x
End

Globale Variablen in Gambas

Benoit Minsini mag sie nicht. Aber sie sind möglich und m.E. auch ganz praktisch.

Siehe Gambas:_Form#Globale_Variablen_in_Gambas

Eine andere Möglichkeit über den Umgang mit globalen Variablen zeigen die nachstehenden Beispiele:

In einem umfangreichen Gambas Projekt werden mehrere Formen und Module verwendet. Globale Variablen, die für das gesamte Projekt gelten, gibt es in Gambas nicht. Es ist jedoch sinnvoll von Formen oder Modulen auf die Variablen anderer Formen oder Module zugreifen zu können. Wie das funktioniert wird nachstehend gezeigt. Wir benötigen eine Form mit einem Befehlsknopf und einem Textfeld als Ergebnisanzeige. Des weiteren benötigen wir ein Modul, in dem mit den Variablen aus der Form gerechnet wird.

Auslesen von öffentlichen Variablen in einer Form1 aus einer Prozedur in einem Modul.

Programmcode der Form1:

PUBLIC a AS Float
PUBLIC b AS Float
' Die Variablen sind öffentlich und sind gültig in allen Prozeduren und Funktionen in der Form1. 
PUBLIC SUB Button1_Click()
 DIM c AS Float
 ME.Text ="Beispiele"
 a = 3.2
 b = 7.4
 c = Module1.RechnenVariable()
  textbox1.Text = Str(c)
END
 

Programmcode von Module1:

PUBLIC FUNCTION  RechnenVariable() AS Float
 DIM c AS Float  
 c = form1.a  + form1.b 
 RETURN c 
END

Bei Betätigung der Befehlsschaltfläche werden zunächst den Variablen a und b Werte zugewiesen. Mit dem Aufruf der Function RechenVariable in Module1 werden die Werte der Variablen a und b der Form1 ausgelesen, dann addiert und als Rückgabewert der Function wieder an die aufrufende Prozedur Sub Button1 zurückgegeben. Das Ergebnis wird in der Textbox1 als Float-Variable ausgegeben.

Genau so einfach wie das Auslesen der Variablen ist das Zuweisen von Werten für die Variablen a und b der Form1 über eine Prozedur von Module1.

Programmcode der Form1:

PUBLIC a AS Float
PUBLIC b AS Float
PUBLIC SUB Button1_Click()
 ME.Text ="Beispiele"
 Module1.RechnenVariable()
 textbox1.Text = Str(a + b)
END

Programmcode von Module1

PUBLIC SUB RechnenVariable()
 form1.a = 10.2
 form1.b = 2.5
END

Etwas komplizierter ist das Auslesen von Variablen aus einem Array, da das Ansprechen der Arrayvariable aus dem Modul mit dem Code c = form1.a[5] nicht funktioniert. Daher wird in Form1 eine öffentliche Prozedur programmiert, die auf das Array zugreifen kann. Zum Auslesen des Array wird von dem Modul auf diese öffentliche Prozedur zugegriffen. Hier ist der Code für die Form1:

d[10] AS Float
' das Array wird ohne PUBLIC deklariert. Mit Public d[10] AS Float gibt Gambas eine Fehlermeldung aus.
' ein Array kann nur im Kopf von Formen deklariert werden. Bei der Deklaration im Kopf von  'Modulen gibt Gambas ebenfalls eine Fehlermeldung aus.
' Die Zählung für den Arrayinhalt beginnt bei 0 (d[0] = ..), während die Zählung für die Deklaration bei 1 beginnt
' Das Array ist öffentlich und ist gültig in allen Prozeduren und Funktionen der Form1.
PUBLIC SUB Form_Open()
 DIM i AS Integer
 ME.Text ="Beispiele"
 FOR i = 0 TO 9
   d[i] = i * 1.2    'Array wird mit willkürlichen Werten gefüllt.
 NEXT  
END
PUBLIC FUNCTION d_aus (x AS Integer) AS Float
 DIM wert AS Float
 wert = d[x]
 RETURN wert
END  
PUBLIC SUB Button1_Click()
 DIM c AS Float
 c = Module1.RechnenArray()
 textbox1.Text = Str(c)
END

Programmcode von Module1:

PUBLIC FUNCTION  RechnenArray() AS Float
 DIM c AS Float  
 c = form1.d_aus(2)  + form1.d_aus(5)
 RETURN c 
END

Zunächst wird in der Prozedur Open() das Array mit Werten gefüllt. Mit dem Aufruf der Function RechenArray in Module1 wird zweimal die Function d_aus in der Form 1 aufgerufen und die Inhalte von d[2] bzw. d[5] ermittelt und an die Funktion Rechenarray zurückgegeben. Dort werden sie dann adddiert und als Rückgabewert der Function Rechenarray wieder an die aufrufende Prozedur Sub Button1 zurückgegeben. Das Ergebnis wird in der Textbox1 als Float-Variable ausgegeben.

Das Zuweisen von Werten für das Array erfolgt ähnlich. Anstatt Funktionen werden in diesem Beispiel Prozeduren benötigt, da die Werte übergeben und nicht ausgelesen werden. Der dafür erforderliche Code für die Form1 lautet:

d[10] AS Float
PUBLIC SUB Form_Open()
 DIM i AS Integer
 ME.Text ="Beispiele"
 FOR i = 0 TO 9
   d[i] = i * 1.2       'Array wird mit willkürlichen Werten gefüllt.
 NEXT  
END
PUBLIC SUB d_ein (wert AS Float, x AS Integer) 
  d[x] = wert
END  
PUBLIC SUB Button1_Click()
 DIM c AS Float
 Module1.RechnenArray()
 textbox1.Text = Str(d[5])
END

Programmcode von Module1:

PUBLIC SUB  RechnenArray() 
 DIM wert AS Float
 wert = 12.7
 form1.d_ein (wert, 5) '5 ist willkürlich gewählt
END

Bei einem zweidimensionalen Array lautet der Code der Form1 für das Auslesen von Werten:

d[10,5] AS Float
PUBLIC SUB Form_Open()
 DIM i AS Integer
 DIM j AS Integer
 ME.Text ="Beispiele"
 FOR i = 0 TO 9
   FOR  j = 0 TO 4
     d[i,j] = i * 1.2 + j    'Array wird mit willkürlichen Werten gefüllt.
   NEXT  
 NEXT  
END
PUBLIC FUNCTION d_aus (x AS Integer, y AS Integer) AS Float
 DIM wert AS Float
 wert = d[x,y]
 RETURN wert
END  
PUBLIC SUB Button1_Click()
 DIM c AS Float
 c = Module1.RechnenArray()
 textbox1.Text = Str(c)
END

Programmcode von Module1:

PUBLIC FUNCTION  RechnenArray() AS Float
 DIM c AS Float  
 c = form1.d_aus(5,2)  + form1.d_aus(8,4)
 RETURN c 
END

Bei einem zweidimensionalen Array lautet der Code der Form1 für die Übergabe von Werten:

d[10,5] AS Float
PUBLIC SUB Form_Open()
 DIM i AS Integer
 DIM j AS Integer
 ME.Text ="Beispiele"
 FOR i = 0 TO 9
   FOR  j = 0 TO 4
     d[i,j] = i * 1.2 + j    'Array wird mit willkürlichen Werten gefüllt.
   NEXT  
 NEXT  
END
PUBLIC SUB d_ein (wert AS Float, x AS Integer, y AS Integer) 
  d[x,y] = wert
END  
PUBLIC SUB Button1_Click()
 Module1.RechnenArray()
 textbox1.Text = Str(d[5,2])
END

Programmcode von Module1:

PUBLIC SUB  RechnenArray() 
 DIM wert AS Float
 wert = 12.7
 form1.d_ein (wert, 5,2) '5 und 2 sind willkürlich gewählt
END

In allen Beispielen wurde mit Fließkommazahlen experimentiert. Durch geringfügige Änderungen der Prozeduren und Funktionen kann natürlich auch mit Integervariablen, mit Strings, mit Datevariablen oder auch mit Booleanvariablen gearbeitet werden. Es ist auch nicht kompliziert auf die Inhalte von Textboxen zuzugreifen, die Textboxen mit Inhalten zu füllen oder auch Labeltexte auszulesen oder zu ändern.