Variablen
Objekte
Bei Programmieren werden oft Objekte verwendet.
Ein Objekt ist ein Speicher mit einem bestimmten Datentyp.
Ein Objekt kann man sich auch als einen Behälter für einen Wert vorstellen. Etwa so wie einen Plastikbecher für Lottokugeln, in dem immer genau eine bestimmte Kugel liegt.
Objekt als Behaelter fuer einen Wert. .
| _____ Wert | Objekt
| .-' '-. |
| .' # ## '. |
| / ## # # \ |
| ; # # # ; |
| | # # | |
| ; # # ; |
| \ # # / |
' '. ### ######.' '
\ '-._____.-' /
'-------------------'
Zu jedem Zeitpunkt ist dem Objekt als sein Wert (Zustand, Inhalt) ein bestimmter Wert des Datentyps zugeordnet. Zu einem anderen Zeitpunkt, kann es wieder einen anderer Wert des gleichen Datentyps sein.
Die Abhängigkeit von einem bestimmten Laufzeitpunkt ist in dem folgenden Diagramm durch den nachgestellten Text "(t)" gekennzeichnet.
Objekt [UML, modified static structure diagram].------------.
1 | Typ |
.----->| |
| | |
| '------------'
|
.---------. | .------------.
| Objekt |------' 1(t)| Wert(t) |
| |------------>| |
| |------. | |
'---------' | '------------'
|
| .-----------.
| 1 | Eigen- |
'----->| schaft- |
| ten |
'-----------'
Variablen
Wenn man einen Bezeichner als ein Objekt definiert, so spricht man von einer Variablen.
Eine Variable ist ein benanntes Objekt.
Eine Variable hat also einen Namen (Bezeichner) und ein Objekt. Daneben hat eine Variable manchmal noch spezielle Eigenschaften.
Wenn der Wert eines Objektes einer Zahlenvariablen beispielsweise der Wert "12" ist, dann müßte man etwas sagen wie „Der Wert des Objektes der Variablen ist 12“, aber stattdessen sagt man dafür meisten etwas abkürzend „Der Wert der Variablen ist 12“. Allerdings faßt man in vielen Programmiersprachen als Wert einer Variablen mal das Objekt und mal dessen Wert auf, je nachdem in welchem Zusammenhang die Variable verwendet wird.
Genauso wird auch statt „das Objekt mit dem Namen "x"“ oft einfach nur gesagt „das Objekt "x"“, wenn "x" der Namen einer Variablen mit diesem Objekt ist.
Variable [UML, static structure diagram].----------. .---------. .---------.
| Variable | * 1 | Name | 1 | Typ |
| |--------------| | .------| |
| | | | | | |
| | '---------' | '---------'
| | .---------. | .---------.
| | * 1 | Objekt |-------' 1(t)| Wert(t) |
| |--------------| |--------------| |
| | | |-------. | |
| | '---------' | '---------'
| | .---------. | .---------.
| | * 1 | Eigen- | | 1 | Eigen- |
| |--------------| schaf- | '------| schaf- |
| | | ten | | ten |
'----------' '---------' '---------'
Man kann sich eine Variable auch als ein Objekt vorstellen, auf das man ein Etikett mit einem Namen geklebt hat. Speicher eine bestimmte Variable die Zeile, in der etwas ausgegeben wird, so würde man dafür beispielsweise eine Variable mit dem Namen "Zeile" verwenden.
Variable als benannter Behaelter fuer einen Wert. .
|-------. _____ Wert | Objekt
| Zeile |' '-. |
|-------'# ## '. |
| / ## # # \ |
| ; # # # ; |
| | # # | |
| ; # # ; |
| \ # # / |
' '. ### ######.' '
\ '-._____.-' /
'-------------------'
Deklaration
Bei der Deklaration einer Variablen wird dem Namen der Variablen ein Datentyp zugeordnet und es werden eventuell einige weitere Eigenschaften der Variablen festgelegt.
Da eine Variable ohne Objekt nutzlos ist, ist eine Deklaration nur sinnvoll, wenn der Variablen auf anderem Wege ein Objekt zugeordnet wird.
Variable zum Zeitpunkt 0.----------. .---------.
| Variable | * 1 | Name |
| |--------------| |
| | | |
| | '---------'
| | .---------.
| | * 1 | Eigen- |
| |--------------| schaf- |
| | | ten(Typ)|
'----------' '---------'
Definition
Bei der Definition einer Variablen wird dieser ein Objekt vom Datentyp der Variablen zugeordnet.
Der im Objekt gespeicherte Wert ist durch eine Variablendefinition im Allgemeinen nicht bestimmt. Daher kann man sich fragen, warum man von einer Definition spricht, wenn doch der Wert gerade nicht definiert wird. „Definition“ bezieht sich hier aber darauf, daß das Objekt der Variablen definiert ist, nicht darauf, daß der Wert des Objektes definiert wurde.
Variable "zahl" mit Typ "int" nach Definition.----------. .---------. .---------.
| Variable | * 1 |zahl:Name| 1 | int:Typ |
| |--------------| ------- | .------| ------ |
| | | | | | (z.B) |
| | '---------' | '---------'
| | .---------. | .---------.
| | * 1 | Objekt |-------' 1(t)| Wert(t) |
| |--------------| (defi- |--------------| (unbe- |
| | | niert) |-------. | stimmt) |
| | '---------' | '---------'
| | .---------. | .---------.
| | * 1 | Eigen- | | 1 | Eigen- |
| |--------------| schaf- | '------| schaf- |
| | | ten | | ten |
'----------' '---------' '---------'
Initialisierung
Bei der Initialisierung einer Variablen wird ein bestimmter Anfangszustand des Objektes der Variablen festgelegt. Die Initialisierung kann bei der Definition der Variablen erfolgen.
Ohne Initialisierung ist der Wert des Objektes unbestimmt. Das bedeutet aber nicht, daß das Objekt keinen Wert hat. Es ist nur nicht bestimmt, welchen Wert es hat.
Variable "zahl" mit Typ "int" und Initialisierung mit 12.----------. .---------. .---------.
| Variable | * 1 | zahl | 1 | int:Typ |
| |<>------------| ---- | .------| ------ |
| | | | | | (z.B) |
| | '---------' | '---------'
| | .---------. | .---------.
| | * 1 | Objekt |-------' 1(t)| 12:Wert |
| |--------------| |--------------| ------- |
| | | |-------. | |
| | '---------' | '---------'
| | .---------. | .---------.
| | * 1 | Eigen- | | 1 | Eigen- |
| |<>------------| schaf- | '------| schaf- |
| | | ten | | ten |
'----------' '---------' '---------'
Zuweisung
Durch die Zuweisung wird der Wert des Objektes einer Variablen neu festgelegt.
Der vorherige Wert der Variablen geht dabei verloren. Insofern ist eine Zuweisung immer auch eine Löschoperation. Man sagt auch, eine Zuweisung überschreibe den vorherigen Wert.
Der Unterschied zwischen Initialisierung und Zuweisung besteht darin, daß bei einer Initialisierung eines neuen Objektes das Objekt gleich mit dem durch die Initialisierung bestimmten neuen Wert geschaffen wird. Ohne Initialisierung wird es mit einem unbestimmten Wert geschaffen, der aber später durch eine Zuweisung verändert werden kann.
Für das folgende Beispiel einer Zuweisung wird angenommen, eine Variable habe vor der Zuweisung den Wert "12".
Variable "zahl" mit Typ "int" und Initialisierung mit 12.----------. .---------. .---------.
| Variable | * 1 |zahl:Name| 1 | int:Typ |
| |<>------------| ------- | .------| ------ |
| | | | | | (z.B) |
| | '---------' | '---------'
| | .---------. | .---------.
| | * 1 | Objekt |-------'1(t=0)| 12:Wert |
| |--------------| |--------------| ------- |
| | | |-------. | |
| | '---------' | '---------'
| | .---------. | .---------.
| | * 1 | Eigen- | | 1 | Eigen- |
| |<>------------| schaf- | '------| schaf- |
| | | ten | | ten |
'----------' '---------' '---------'
Der Wert des Objektes werde nun durch eine Zuweisung auf 24 gesetzt.
Variable nach Zuweisung von 24.----------. .---------. .---------.
| Variable | * 1 |zahl:Name| 1 | int:Typ |
| |<>------------| ------- | .------| ------ |
| | | | | | (z.B) |
| | '---------' | '---------'
| | .---------. | .---------.
| | * 1 | Objekt |-------'1(t=1)| 24:Wert |
| |--------------| |--------------| ------- |
| | | |-------. | |
| | '---------' | '---------'
| | .---------. | .---------.
| | * 1 | Eigen- | | 1 | Eigen- |
| |<>------------| schaf- | '------| schaf- |
| | | ten | | ten |
'----------' '---------' '---------'
Verwendung
In vielen Programmiersprachen wird verlangt, daß eine Variable vor ihrer ersten Verwendung definiert (oder wenigstens deklariert) wurde. Dadurch kann der Parser Fehler des Autors leichter entdecken. Einige Programmiersprachen erlauben es auch Variablen ohne Definition zu verwenden, wobei dann ein Typ geraten oder ein sehr allgemeiner Typ für die Variable festgelegt wird. Dies dient der Bequemlichkeit des Autors, aber ist für größere Projekte nicht geeignet, weil es Fehler fördert und die Effizienz mindert.
Bei der Verwendung einer Variablen, d.h. beim Auftreten ihres Namens (z.B. "zahl") in einem Text, steht der Name in der Regel für den Wert des Objektes.
Variable "zahl" mit dem Wert 24.----------------------------.
| (R-)Wert des Namens > |
| |
.----------. .---------. .---------. |
| Variable | * 1 |zahl:Name| 1 | int:Typ | |
| |-----------| ------- | .----| ------ | |
| | | | | | (z.B) | |
| | '---------' | '---------' |
| | .---------. | .---------. |
| | * 1 | Objekt |-----'1(t)| 24:Wert | |
| |-----------| |----------| ------- |--'
| | | |-----. | |
| | '---------' | '---------'
| | .---------. | .---------.
| | * 1 | Eigen- | | 1 | Eigen- |
| |-----------| schaf- | '----| schaf- |
| | | ten | | ten |
'----------' '---------' '---------'
Manchmal steht der Name einer Variablen jedoch für das Objekt der Variablen.
Um das zu verdeutlichen betrachten wir das Ausgaben und das Einlesen einer Variablen „x “, die zunächst den Wert "12" hat.
In dem Kommando „Gib x aus!“ steht „x “ für den Wert des Objektes, daher bedeutet das Kommando in diesem Fall „Gib 12 aus!“
Das Kommando „Lies x ein!“ soll eine Zahl einlesen und diese in dem Objekt der Variablen „x “ speichern. Hier macht es aber kein Sinn den Namen der Variablen durch den Wert des Objektes zu ersetzen, denn dann erhielte man „Lies 12 ein!“, was aber nicht den gewünschten Sinn ergibt. Das Kommando „Lies x ein!“ kann nur richtig interpretiert werden, wenn man versteht, daß der Name der Variablen „x “ hier für das Objekt steht und nicht für den Wert des Objektes. Der Programmteil zum Einlesen muß ja auch wissen, in welches Objekt der eingelesene Wert gespeichert werden soll.
Schreibweise der Zuweisung
Eine Zuweisung wird in vielen Programmiersprachen geschrieben wie z,B. "x = z".
Diese Schreibweise erinnert auch an eine mathematische Gleichung oder Definition. Doch eine Zuweisung ist etwas anderes.
Die mathematischen Gleichung „x = z “ ist die Notation der Aussage, daß der Wert „x “ dem Wert „z “ gleicht. Je nach Redezusammenhang wird diese Aussage entweder als wahr postuliert oder als eine Aussage verwendet, die wahr oder falsch sein kann.
Eine Zuweisung "x = z" ist aber keine Aussage, sondern eine Operation, mit dem Ziel eine bestimmte Veränderung zu bewirken.
Die mathematischen Definitionen „x := 1. x := 2.“ wären ein Verstoß gegen die Regeln einer verständlichen mathematischen Schreibweise. Denn in der Mathematik kann ein Bezeichner innerhalb eines Zusammenhangs nur einmal definiert werden. Man wüßte nicht, ob die Variable „x “ nun gleich 1 oder gleich 2 sein soll.
Die Folge von Zuweisungen "x = 1; x = 2; " sind in einer prozeduralen Programmiersprache aber so vollkommen sinnvoll. Hier kommt nämlich der Objektbegriff und damit der Zeitbegriff ins Spiel, den es so in der Mathematik nicht gibt: Das Objekt "x" wird eben zuerst auf den Wert "1" gesetzt und danach auf den Wert "2" ohne daß hierdurch ein Widerspruch entsteht.
In manchen Programmiersprachen wird versucht, den Unterschied einer Zuweisung zu ähnlichen Schreibweisen aus der Mathematik deutlich zu machen, so werden in BASIC Zuweisungen mit durch das vorangestellte Schlüsselwort "LET" gekennzeichnet.
Interpretation der Zuweisung
Bei der Zuweisung "x = z" wird der Wert (des Objektes) der Variablen "z" (dem Objekte) der Variablen "x" zugewiesen. Das bedeute, daß der Wert (des Objektes) der Variablen "x" so verändert wird, daß er der Wert (des Objektes) der Variablen "z" wird.
Bei der Zuweisung "x = z" steht der Name der Variablen auf der linken Seite für ihr Objekt, der Name der Variablen auf der rechten Seite für den Wert ihres Objektes.
In manchen Programmiersprachen wird dieser Sachverhalt auch ausgedrückt, indem man sagt die Variable "x" sei ein „Linkswert“ (L-value ) oder habe einen „Linkswert“ und von der Variable "z" werde in diesem Fall der „Rechtswert“ (R-value ) verwendet. Ein „Linkswert“ ist etwas, das sinnvollerweise auf der linken Seite einer Zuweisung stehen kann, also ein Objekt. Umgekehrt ausgedrückt ergibt das dann die Regel „Auf der linken Seite einer Zuweisung muß ein Linkswert stehen.“
Würde der Name auf beiden Seiten für den Wert des Objektes stehen und hätte die Variable "x" vor der Zuweisung den Wert "12" und die Variable "z" vor der Zuweisung den Wert "9", so ergäbe sich nämlich die Zuweisung "12 = 9", was offensichtlich keinen Sinn ergibt. Dies wird manchmal auch ausgedrückt, indem man sagt der Wert "12" sei kein Linkswert, er kann also nicht sinnvollerweise auf der linken Seite einer Zuweisung stehen.
Berücksichtigt man aber, daß der Name der Variablen auf der linken Seite für das Objekt der Variablen steht, so erhält man hingegen die sinnvolle Zuweisung "x = 9".
Bei einer Zuweisung wie "x = 1 + 2" erfolgen zwei Schritte entgegen der Leserichtung: Zuerst wird der Wert des rechts vom Gleichheitszeichen stehenden Ausdrucks "1 + 2" ermittelt und dann wird dieser dem links stehenden Objekt als Wert zugewiesen.
Schritte bei der Zuweisung2. Schritt: Zuweisung des Wertes an das
durch die linke Seite bestimmte Objekt
.-----------.
| |
| .---+---. 1. Schritt: Auswertung
v ^ ^ der rechten Seite
x = 1 + 2
Löschen eines Objektes
Laien haben oft die irrige Vorstellung, eine numerische Variable sei „gelöscht“, wenn man dieser den Wert "0" zugewiesen habe. Doch tatsächlich hat der Wert "0" keine besondere Bedeutung. Man könnte also genauso gut sagen, eine Variable sei „gelöscht“, wenn man ihr den Wert "22" zugewiesen habe. Aber eine Variable, die unzweifelhaft einen bestimmten Wert, wie den Wert "22", speichert als „gelöscht“ zu bezeichnen, erscheint als unpassend.
Tatsächlich ist es richtig zu sagen, daß mit jeder Zuweisung an eine Variable, der vorherige Wert gelöscht wird. Eine Variable ist also nie gelöscht, aber eine bestimmte Information, die früher einmal in einer Variablen war, kann inzwischen gelöscht worden sein. Will man also den derzeitigen Wert einer Variablen löschen, so kann dies dadurch erfolgen, daß man der Variablen einen beliebigen neuen Wert zuweist, aus dem kein Rückschluß mehr auf den vorherigen Wert gezogen werden kann.
Gebrauch von Variablen*
Bei Rechnungen mit Zwischenergebnissen kann für jeden Bedeutung eine eigene Variable verwendet werden. Es ist aber auch möglich eine Variable mehrfach für verschiedene Werte und daher auch mit verschiedenen Bedeutungen zu verwenden.
Übungsfrage Welches der folgenen Struktogramme gehört zu welcher der eben geschilderten Möglichkeiten? (Das Zeichenpaar ":=" steht für eine Konstantendefinition, das Zeichen "=" ohne vorangehendes Zeichen ":" für eine Zuweisung.
Rechnung B1.--------------------------------------------------------.
| betrag := 1,95; |
|--------------------------------------------------------|
| rabattfaktor := 0.97; |
|--------------------------------------------------------|
| mwstfaktor := 1.16; |
|--------------------------------------------------------|
| rabattierterbetrag := betrag * rabattfaktor; |
|--------------------------------------------------------|
| bruttobetrag := rabattierterbetrag * mwstfaktor; |
|--------------------------------------------------------|
| forderung := bruttobetrag; |
'--------------------------------------------------------'Rechnung B2.--------------------------------------------------------.
| betrag := 1,95; |
|--------------------------------------------------------|
| rabattfaktor := 0.97; |
|--------------------------------------------------------|
| mwstfaktor := 1.16; |
|--------------------------------------------------------|
| speicher = betrag * rabattfaktor; |
|--------------------------------------------------------|
| speicher = speicher * mwstfaktor; |
|--------------------------------------------------------|
| forderung := speicher; |
'--------------------------------------------------------'
Übungsfrage Welcher Stil gefällt Ihnen besser?
Die erste Rechnung verwendet nur Konstanten. Daher könnte man den Stil als wertorientiert oder mathematisch bezeichnen. Die zweite Rechnung kann als objektverwendend bezeichnet werden, weil sie von der typischen zeitlichen Veränderbarkeit von Objekten Gebrauch macht.