Lokale Variablen

"Denn wie's da drinnen aussieht, geht niemand was an."

Quelle: HP48G Advanced User's Reference Manual (HP-Nr. 00048-90136)

Die hier verwendete Notation ist in einem gesonderten Beitrag zusammengestellt.

Inhalt

Einleitung

Vorteile von lokalen Variablen

Erzeugen von lokalen Variablen

Auswertung von Variablen während des Programmlaufs

Unterprogramme

Kompilierte Variablen

Übergabe der Argumente durch kompilierte Variablen

Einschränkungen

Zur Beitragsübersicht

Einleitung

Beim Programmieren des HP 49G werden Variablen verwendet, welche die Eingabewerte, Werte von Zwischenberechnungen und Ergebniswerte enthalten.

Variablen sind namentlich festgelegte Speicherbereiche, in denen Objekte gespeichert werden können.

Bei der Benennung von Variablen muß die im Handbuch festgelegte Namenskonvention eingehalten werden. Die Namen von reservierten Variablen dürfen nicht frei verwendet werden.

Bei Variablen werden zwei Typen unterschieden:

Globale Variablen, deren Namen als Menüpunkte in den Verzeichnissen angezeigt werden, sind für den Benutzer und für die Programme frei zugänglich.

Lokale Variablen, sind Variablen, deren Namen nur innerhalb des Programmes gültig sind, in dem sie definiert worden sind. Ein Ausnahme bilden die kompilierten Variablen, die ebenfalls zu den lokalen Variablen gerechnet werden.

In diesem Beitrag wird die Erzeugung und Handhabung von lokalen Variablen einschließlich der kompilierten Variablen beschrieben. Vorausgesetzt wird der Betrieb des Rechners im RPN-Modus.

Vorteile von lokalen Variablen

Globale Variablen müssen nach Beendigung des Programms gelöscht werden, wenn man sie anschließend nicht mehr braucht. Dies kann am Schluß des Programms vom Programm selbst erfolgen oder muß manuell erledigt werden. Außerdem müssen diese Variablen eigens vor dem Programmlauf oder vom Programm selbst unter einem bestimmten Namen im Menü angelegt werden. Die Inhalte werden mit STO dort gespeichert. Dabei muß beachtet werden, daß vorhandene Variablen gleichen Namens nicht überschrieben oder gelöscht werden.

Lokale Variablen haben diese Nachteile nicht, sie

sind temporäre Variablen, die vom Programm erzeugt und mit Inhalten (Objekten) belegt werden.

sind nur innerhalb des Programms, in dem sie definiert sind, gültig.

existieren nur während des Programmablaufs und können nicht außerhalb des Programms benutzt werden.

erscheinen nicht im VAR-Menü (= Menü des aktuellen Verzeichnisses, das durch die Taste [VAR] aufgerufen wird).

Außerdem erfolgt der Zugriff auf diese Variablen wesentlich schneller als bei globalen Variablen.

Eine kompilierte lokale Variable ist eine bestimmte Form der lokalen Variablen. Sie hat alle oben beschriebenen Vorteile von lokalen Variablen und kann außerdem auch außerhalb des Programms, in dem sie definiert worden ist, verwendet werden.

Erzeugen von lokalen Variablen

Achtung:
Man vermeide gleichlautende Namen für globale und lokale Variablen in demselben Programm. Der Rechner kann den Unterschied eindeutig erkennen, nur der Programmierer kommt dann leicht durcheinander.

Die Programmklammern « » sind als Begrenzung des Programms einzugeben.

Dann ist der Pfeil -> mit [rightshift][0] einzugeben (Rechtspfeil = ASCII-Code 141).

Dann folgt eine Reihe von Namen für die lokalen Variablen.

Zum Schluß wird die definierende Prozedur (ein algebraischer Ausdruck oder ein Programmobjekt) eingegeben, die die Namen benutzen kann.

« -> name₁ name₂ ... name_n 'algebraischer Ausdruck' » oder
« -> name₁ name₂ ... name_n « programm » »

Innerhalb des in Punkt 4 eingegebenen inneren Programms können wieder Programme mit weiteren lokalen Variablen angeordnet werden (mehrstufige Verschachtelung).

Vor der Programmausführung müssen die Objekte für die lokalen Variablen im Stack vorhanden sein, sonst wird die Fehlermeldung " -> Error: Too Few Arguments" ausgegeben.

Während der Programmausführung werden n Objekte vom Stack geholt und den Variablen name₁ name₂ ... name_n zugewiesen, wobei das Objekt der Stackebene n der Variablen name₁ und absteigend die anderen Objekte den folgenden Variablen zugewiesen werden. Das Objekt der Stackebene 1 wird der Variablen name_n zugewiesen.

Beispiel 1:

Die Objekte (Zahlen) des im Bild 1 gezeigten Stacks werden wie folgt zugewiesen:

-> a erzeugt a = 20

-> a b erzeugt a = 6 und b = 20

-> a b c erzeugt a = 10, b = 6 und c = 20

In der definierenden Prozedur können die Namen der lokalen Variablen benutzt werden.

Das im Bild 2 gezeigte Beispielprogramm erzeugt aus obigen Stackwerten die im rechten Bild 3 gezeigte Ausgabe:

Auswertung von Variablen während des Programmlaufs

Lokale Variablen werden während des Programmlaufs etwas anders als die globalen Variablen ausgewertet.

Globale Variablen werden durch den Aufruf des Namens direkt gestartet und in dem Speicherbereich, in dem sie gespeichert sind, automatisch ausgeführt, wenn es sich um ein Programmobjekt handelt.

Wird eine globale Variable als Unterprogramm innerhalb eines anderen Programms durch Namen aufgerufen, so läuft erst dieses Unterprogramm im gesonderten Speicherbereich ab und übergibt das Ergebnis im Stack, dann wird das aufrufende Programm mit dem auf den globalen Namen folgenden Programmbefehl fortgeführt. Eine globale Variable, die eine Zahl enthält, stellt diese Zahl nach Aufruf in den Stack.

Beim Aufruf eines lokalen Namens innerhalb eines Programms wird der vorher aus dem Stack geholte und in der lokalen Variablen gespeicherte Inhalt (Objekt) in den Stack zurückgeholt, aber nicht automatisch ausgeführt. Ist der Inhalt der lokalen Variablen ein Programmobjekt, der Name einer globalen Variablen oder ein algebraisches Objekt, dann muß der Befehl EVAL nachfolgen, um den Inhalt auszuführen. Ist in der lokalen Variablen eine Zahl gespeichert, wird diese, wie bei globalen Variablen, in den Stack gestellt.

Lokale Variablen können überall im Innern der definierenden Prozedur, auch in den weiteren Verschachtelungen, aufgerufen werden, während die in den inneren Verschachtelungen definierten lokalen Variablen in den äußeren, sie aufrufenden Prozeduren nicht gelten.

Beispiel 2:

Bei dem in Bild 4 gezeigten Programm kann die innere Prozedur die in der äußeren Prozedur definierten lokalen Variablen a, b und c und die eigene lokale Variable d aufrufen, während die äußere Prozedur die lokale Variable d der inneren Prozedur nicht aufrufen kann.

Unterprogramme

Ein Unterprogramm hat den Zweck, gleichartige Programmabläufe zusammenzufassen und als aufrufbares Programm anderen Programmen zur Verfügung zu stellen. Der Programmcode muß nicht in die Hauptprogramme eingebunden werden, sondern es müssen nur die Namen der Unterprogramme aufgerufen und die Argumente (aktuelle Parameter) übergeben werden. Auf diese Weise werden die Hauptprogramme kürzer und übersichtlicher.

Wie oben gezeigt, können beim HP 49G in globalen Variablen gespeicherte Programme von anderen Programmen als Unterprogramme benutzt und mit Namen aufgerufen werden. Sie werden dann automatisch in ihrem eigenen Speicherbereich ausgeführt, so als wären sie manuell per Tastendruck im Menü aufgerufen worden. Nachteilig ist, daß sie keine Werte aus lokalen Variablen übernehmen können, die Argumente müssen ebenfalls in globalen Variablen oder im Stack gespeichert werden.

Beispiel 3: (wie man's nicht machen sollte!)

« a b + SQ »

Dieses Programm berechnet (a+b)² und ist in der globalen Variablen Q gespeichert. Es soll als Unterprogramm verwendet werden und die Werte a und b vom Hauptprogramm übergeben bekommen. Das nachfolgend gezeigte Hauptprogramm

« -> a b « Q "Q" ->TAG » »

holt die Werte a und b vom Stack, definiert sie als lokale Variablen und ruft das Unterprogramm Q auf. Dieses soll aus den Werten a und b den Wert Q=(a+b)² berechnen und an das Hauptprogramm liefern. Dieses soll das Ergebnis dann ausgeben.

Leider funktioniert die im Beispiel gezeigte Übergabe der Argumente nicht.

Warum nicht? Weil das Hauptprogramm und das Untergrogramm als globale Variablen jeweils im eigenen Speicherbereich ausgeführt werden, weiß das Unterprogramm Q nichts von den lokalen Variablen a und b des Hauptprogramms. Es erwartet globale Variablen a und b und würde nach seinem Ablauf nur das berechnete Ergebnis über den Stack an das Hauptprogramm übergeben, wenn es Eingabewerte zur Verfügung gehabt hätte. Beide Programme sind vor dem Ablauf bereits beim Speichern lauffähig kompiliert worden und wissen nichts voneinander. Das Hauptprogramm weiß nicht, was das Unterprogramm Q tut.

Das im obigen Beispiel 3 gezeigte Unterprogramm funktioniert nur, wenn die Werte a und b in globalen Variablen verfügbar sind. Die lokalen Variablen haben keinen Einfluß auf das Unterprogramm.

Der Umweg, über globale Variablen Argumente (aktuelle Parameter) an Unterprogramme zu übergeben, ist aber eine sehr umständliche Methode. Deshalb gibt es beim HP 49G (wie auch schon beim HP 48G) kompilierte lokale Variablen.

Kompilierte Variablen

Beim HP 49G verwendet man bei den kompilierten Variablen das bei höheren Programmiersprachen übliche Prinzip des gemeinsamen Speicherbereichs für Haupt- und Unterprogramme. Bei FORTRAN nennt man diesen Speicherbereich COMMON und die Variablen heißen COMMON-Variablen.

Bereits bei der Erstellung der Programme auf dem HP 49G werden die gemeinsam von Haupt- und Unterprogrammen zu benutzenden lokalen Variablen festgelegt und beim Abspeichern des Programms kompiliert. Beim Programmablauf stellt das Hauptprogramm die Inhalte in einem benannten (gemeinsamen) Speicherbereich zur Verfügung. Das Unterprogramm kennt diese namentlich festgelegten Speicherbereiche und holt sich dort die Inhalte. Diese Übergabe der Argumente ist wesentlich schneller als über globale Variablen.

Die Variableninhalte (Objekte) sind nur während der Programmausführung des Hauptprogramms temporär vorhanden. Das Unterprogramm, obwohl es als Programm in einer globalen Variablen gespeichert ist, ist für sich allein nicht lauffähig, weil die notwendigen aktuellen Parameter außerhalb des laufenden Hauptprogramms nicht existieren. Ein Aufruf eines solchen Unterprogramms per Tastatur liefert die Fehlermeldung "Error: Undefined Local Name".

Namen von kompilierten Variablen

Der Name einer kompilierten Variablen hat als erstes Zeichen den Links-Pfeil (ASCII-Code 142). Zwischen Linkspfeil und dem nächsten Zeichen darf kein Leerzeichen stehen.
Der Linkspfeil ist Teil des Namens.

Das erste Zeichen kann durch den Befehl 142 CHR erzeugt oder über [rightshift][CHARS] ausgewählt werden. Die weiteren Zeichen müssen der Namenskonvention des HP 49G entsprechen.

Ansonsten werden die kompilierten Variablen genau so erzeugt und gehandhabt wie lokale Variablen.

Das Programm des Beispiels 3 wird im Beispiel 4 mit kompilierten Variablen gezeigt.

Übergabe der Argumente durch kompilierte Variablen

Beispiel 4:

Das linke Bild zeigt das Hauptprogramm QA (= Q-Ausgabe) und das rechte Bild das Unterprogramm Q mit den kompilierten lokalen Variablen.

Hauptprogramm
Unterprogramm

Das Programm QA liest z. B. die Stackwerte 4 und 6 in die kompilierten Variablen (<-a) und (<-b) ein, das Unterprogramm verwendet diese Werte und berechnet damit (4 + 6)² und das Hauptprogramm gibt das Ergebnis Q: 100 im Stack aus. Die Inhalte der beiden kompilierten Variablen werden also ordnungsgemäß an das Unterprogramm Q übergeben. Das Programm Q kann als Unterprogramm von verschiedenen Hauptprogrammen aufgerufen werden.

Einschränkungen

Ein Programm mit Aufrufen von kompilierten Variablen (wie hier das Programm Q) kann nicht als selbständiges Programm verwendet werden, es muß immer als Unterprogramm in einem Hauptprogramm verwendet werden, das die Namen der beteiligten kompilierten Variablen (Common-Variablen) definiert und die Inhalte dafür zur Verfügung stellt.

Die Namen der kompilierten Variablen (mit Linkspfeil als erstem Zeichen) können nicht für globale Variablen verwendet werden. Ein Versuch, eine globale Variable mit einem solchen Namen zu erzeugen, endet mit der Fehlermeldung "STO Error: Undefined Local Name".

Zum Beginn dieser Seite
Zur Beitragsübersicht