Benannte Wertspeicher
Ein Wertspeicher kann in den meisten Programmiersprachen benannt werden.
Ein Name des Quelltextes wird dabei dauerhaft oder vorübergehend an den Wertspeicher gebunden.
Benannter WertspeicherQuelltext | Laufzeitumgebung
|
| . .
| | _____ Wert | Wertspeicher
| | .-' '-. |
| | .' # ## '. |
Bezeichner, ----------------| / ## # # \ |
z.B. "i" gebunden an > | ; # # # ; |
| | | # # | |
| | ; # # ; |
| | \ # # / |
| ' '. ### ######.' '
| \ '-._____.-' /
| '-------------------'
|
Der Wertspeicher eines Bezeichners 〈w 〉 wird auch „Wertspeicher 〈w 〉“ genannt, der Wert darin auch der „Wert 〈w 〉“, so daß man beispielsweise von dem „Wertspeicher "i"“ sprechen kann, wenn der Bezeichner "i" an einen Wertspeicher gebunden ist und dann mit „Wert "i"“ der in dem Wertspeicher "i" enthaltene Wert gemeint ist. Man sagt auch der Bezeichner "i" sei ein Name des Wertspeichers "i".
Die Definition eines Bezeichners für einen Wertspeicher wird oft gemeinsam mit der Zuordnung eines bisher nicht verwendeten Wertspeichers vorgenommen.
Bei der Initialisierung eines Wertspeichers wird ein neuer Wertspeicher zusammen mit einem bestimmten Anfangswert erzeugt, der Begriff Initialisierung wird also nur dann verwendet, wenn auch ein Anfangswert für den Wertspeicher festgelegt ist.
Das Schreiben eines Wertes in einen benannten Wertspeicher wird in vielen Programmiersprachen durch die Zuweisung geschrieben, in der der Wertspeicher und dessen neuen Wert vorkommt. Benennt der Bezeichner "i" einen Wertspeicher, bewirkt die Zuweisung "i = 7", daß der Wert "7" in den Wertspeicher geschrieben wird, der an den Bezeichner "i" gebunden ist.
Die Wirkung der Zuweisung "i = 7"Quelltext | Laufzeitumgebung
|
| _____ Wert
| .-' '-.
| .' ######## '.
| / # \
| ; # ;
| | # |
| ; # ;
| \ # /
| '. # .'
| '-._____.-'
|
| |
| . | .
| | | | Wertspeicher
| | | |
| | | |
Bezeichner, ----------------| V |
z.B. "i" gebunden an > | |
| | |
| | |
| | |
| ' '
| \ /
| '-------------------'
|
In einigen Programmiersprachen ist es möglich, einen Wertspeicher zu verwenden, der nicht mit einem Anfangswert initialisiert wurde und dem auch noch kein Wert zugewiesen wurden. In manchen Programmiersprachen ist der Wert in dem Wertspeicher dann undefiniert, also nicht weiter festgelegt: Dann enthält der Wertspeicher zwar irgendeinen Wert, aber es ist nicht bestimmt, welcher Wert das ist. Es ist auch nicht festgelegt, daß dieser Wert „zufällig“ ist, denn ein zufallsverteilte Werte, müssen über einem bestimmten Bereich in bestimmter Weise gleichmäßig verteilt sein—bei einem undefinierten Wert ist es aber auch möglich, daß sich immer der gleiche Wert ergibt.
Innerhalb eines Quelltextes steht ein Wertspeicher oft für den enthaltenen Wert. So bewirkt eine Ausgabeanweisung "print i" die Ausgabe einer Textdarstellung des Wertes in dem von dem Bezeichner "i" benannten Wertspeicher. Falls in dem Wertspeicher "i" der Wert "7" enthalten ist, so ist die Wirkung von "print i" die Wirkung von "print 7". Werden andere Anweisungen außer acht gelassen, so kann man also die Anweisungsfolge "i = 7; print i;" durch "print 7" ersetzen.
Gleichheit von Wertspeichern
Es kommt manchmal zu Mißverständnissen hinsichtlich des Begriffs der Gleichheit durch verschiedene Bezeichner gegebenen Wertspeicher. Daß zwei Bezeichner gleich sind, ist von geringem Interesse, da es offensichtlich ist. Es gibt die Situation, in der zwei verschiedene Bezeichner an den gleichen Wertspeicher gebunden sind.
Verschiedene Bezeichner fuer den gleichen WertspeicherQuelltext | Laufzeitumgebung
|
| . .
| | _____ Wert | Wertspeicher
| | .-' '-. |
Bezeichner, ------------------| .' # ## '. |
z.B. "i" gebunden an > | / ## # # \ |
| | ; # # # ; |
Bezeichner, ------------------| | # # | |
z.B. "j" gebunden an > | ; # # ; |
| | \ # # / |
| ' '. ### ######.' '
| \ '-._____.-' /
| '-------------------'
|
Die Situation, in der ein Wertspeicher mehrere Namen hat, wird auch als Aliasierung (“aliasing ”) bezeichnet. Sie ist nicht in allen formalen Sprachen möglich. Ein Wertspeicher-Bezeichner kann dann als ein Alias für einen anderen Wertspeicher-Bezeichner aufgefaßt werden, der an den gleichen Wertspeicher gebunden ist.
Es ist auch möglich, daß zwei verschiedene Wertspeicher, den gleichen Wert enthalten.
Verschiedene Wertspeicher mit dem gleichen WertQuelltext | Laufzeitumgebung
|
| . .
| | _____ Wert | Wertspeicher 0
| | .-' '-. |
| | .' # ## '. |
Bezeichner, ------------------| / ## # # \ |
z.B. "i" gebunden an > | ; # # # ; |
| | | # # | |
| | ; # # ; |
| | \ # # / |
| ' '. ### ######.' '
| \ '-._____.-' /
| '-------------------'
|
|
|
| . .
| | _____ Wert | Wertspeicher 1
| | .-' '-. |
| | .' # ## '. |
Bezeichner, ------------------| / ## # # \ |
z.B. "j" gebunden an > | ; # # # ; |
| | | # # | |
| | ; # # ; |
| | \ # # / |
| ' '. ### ######.' '
| \ '-._____.-' /
| '-------------------'
|
Manchmal sagt man, das von zwei verschiedene Bezeichner Bezeichnete, sei „identisch“, wenn die beiden Bezeichner den gleichen Wertspeicher bezeichnen, und (nur) „gleich“, wenn die beiden Bezeichner Wertspeicher mit dem gleichen Wert bezeichnen. Hier wird auch manchmal gesagt, es seien „dieselben“ Wertspeicher und nicht nur „die gleichen“ Werte. (Alle Zuweisungen unterschiedlicher Bedeutungen an die Begriffe „identisch“ und „gleich“ oder „dieselben“ und „die gleichen“ sind allerdings ad-hoc -Konstruktionen. Es darf nicht als selbstverständlich vorausgesetzt werden, daß sie eine bestimmte allgemeine Bedeutung hätten, deswegen müssen sie bei ihrer ersten Verwendung in einem bestimmten Zusammenhang definiert werden.)
Nun ist es zunächst nicht ganz klar, was die Aussage "i == j" (also „i ist gleich j“) bedeuten soll: Gilt die Aussage "i == j" nur dann, wenn der Wertspeicher "i" gleich dem Wertspeicher "j" ist, oder auch, wenn nur der Wert "i" gleich dem Wert "j" ist, aber die Wertspeicher sich unterscheiden? Diese Frage betrifft also die Identität von Wertspeichern: Sind zwei Wertspeicher einander gleich, wenn sie die gleichen Werte enthalten oder nur, wenn sie auch die gleichen Wertspeicher sind?
Diese Frage wird in verschiedenen Programmiersprachen und verschiedenen Situationen unterschiedlich beantwortet.
Referenzen
Ob ein an einen Wertspeicher gebundener Bezeichner diesen Wertspeicher oder den darin enthaltenen Wert bezeichnet, hängt von dem Zusammenhang ab.
Das klassische Beispiel dafür ist eine Zuweisung "i = j", wobei der Bezeichner "i" und der Bezeichner "j" jeweils einen Zahlen-Wertspeicher bezeichnen sollen. Hier soll der Wert des Wertspeichers "j" in den Wertspeicher "i" kopiert werden. Daher steht der Bezeichner "i" auf der linken Seite für den Wertspeicher "i" und der Bezeichner "j" auf der rechten Seite für den Wert "j" (also für den Wert im Wertspeicher "j"). Der Wert "j" soll in den Wertspeicher "i" geschrieben werden.
Da auf der linken Seite einer Zuweisung ein Wertspeicher stehen muß, wird jeder Wert eines Ausdruck, der einen Wertspeicher bezeichnen kann, in manchen Programmiersprachen auch Linkswert (“l-value ”) genannt. Ein Wert eines Ausdrucks, der einen Wert bezeichnen kann, wird auch Rechtswert (“r-value ”) genannt. Der Quelltext "5 = i" ist beispielsweise keine mögliche Zuweisung, da der Ausdruck "5" keinen Linkswert (keinen Wertspeicher) bezeichnet.
In einer Situation, in der der Bezeichner "i" und der Bezeichner "j" an unterschiedliche Wertspeicher gebunden sind, die die gleichen Werte enthalten, wird oft erwartet, daß der Vergleich "i == j" wahr ist. Dieser Vergleich soll die Aussage notieren, daß das von dem Bezeichner "i" Bezeichnete dem von dem Bezeichner "j" Bezeichnetem gleich ist. Aber was ist das von dem Bezeichner "i" (bzw. "j") bezeichnete? Ist es der Wertspeicher oder der Wert ? Oft wird erwartet, daß nach der Anweisungsfolge "i = 12; j = 12;" die Aussage "i == j" wahr ist. Wenn die Wertspeicher statt der in ihnen enthaltenen Werte verglichen werden, dann kann diese Aussage aber falsch sein. (In der Programmiersprache Java werden beispielsweise bei einem Vergleich zweier Wertspeicher-Bezeichner tatsächlich die beiden Wertspeicher miteinander verglichen und nicht die Werte, aber nur falls es sich nicht um Wertspeicher für Zahlen handelt.)
Eine andere Situation, in der es eine Rolle spielt und unterschiedlich gehandhabt wird, ob ein an einen Wertspeicher gebundener Bezeichner nun den Wertspeicher oder den darin enthaltenen Wert bezeichnet, ist eine Anwendung, wie beispielsweise die Anwendung "f( i )". Wenn der Wertspeicher-Bezeichner "i" dabei seinen Wertspeicher bezeichnet, dann kann das Anwendbare "f" den Inhalt des Wertspeichers verändern (es hat Schreibzugriff auf den Wertspeicher). Bezeichnet der Bezeichner "i" darin aber nur den Wert im Wertspeicher "i", dann „erfährt“ das Anwendbare "f" den Wertspeicher gar nicht und kann ihn daher auch nicht verändern (es hat nur einen einmaligen Lesezugriff gehabt). Welche der beiden Möglichkeiten zutrifft, hängt von der verwendeten Programmiersprache und manchmal auch von dem Anwendbarem ab.
Call by reference, call by value und call by name
Wenn ein Unterprogramm in einen als Argument angegebenen Wertspeicher schreiben können soll, dann muß es also erfahren, wo sich dieser Wertspeicher befindet. Dazu dienen interne Kennzeichnungen der Wertspeicher, die einen Wertspeicher eindeutig kennzeichnen und den Zugriff auf diesen Wertspeicher erlauben. Solch eine Kennzeichnung wird manchmal auch eine Referenz (auf den Wertspeicher) genannt. Wenn in einer Anwendung "f( i )", der Bezeichner "i" für den Wertspeicher steht, so wird dies also dadurch realisiert, daß der Wert von "i" in diesem Fall einen Referenz auf den Wertspeicher ist, die dann verwendet werden kann, um auf diesen zuzugreifen. Das Anwendbare "f" erfährt in diesem Falle die Referenz und kann dadurch auf den Wertspeicher "i" zugreifen. Solch eine Anwendung wird daher auch “call by reference ” genannt. Wird nur der Wert bezeichnet, so spricht man von “call by value ”. Selten, aber eine weitere Möglichkeit, ist das “call by name ”, wo das Anwendbare den Namen des Arguments, also den in der Anwendung verwendeten Bezeichner, erfährt.
Wertsemantik und Referenzsemantik
Soll ein Bezeichner eines Wertspeichers den darin enthaltenen Wert ausdrücken, so spricht man auch von Wertsemantik oder sagt, der Bezeichner werde als R-Wert verwendet. Soll er den an ihn gebundenen Wertspeicher ausdrücken, dann nennt man dies Referenzsemantik oder sagt, der Bezeichner werde als L-Wert verwendet.
Konstanten und Variable
In einigen Fällen kann in einem Programm ein benannter Wert (eine Konstante) oder auch ein benannter Wertspeicher verwendet werden, um einen bestimmten Wert zu repräsentieren. Konstanten sind aber besser verständlich, da sich ihr Wert nicht verändern kann. Daher sollten Konstanten gegenüber veränderlichen benannten Wertspeichern immer bevorzugt verwendet werden.
Wenn ein benannter Wert oder ein benannter Wertspeicher für einen bestimmten Zweck verwendet werden kann, dann sollte ein benannter Wert verwendet werden.