2.2.2. Für Umsteiger: Vergleich TI-85 BASIC mit Turbo Pascal

 Nächste Seite

Sowohl Turbo Pascal als auch das TI-85 BASIC sind imperative Programmiersprachen. Demnach beruhen beide Sprachen auf dem Variablenkonzept. Sie kennen die gleichen Strukturen wie Schleifen und Verzweigungen oder Ein- und Ausgabeanweisungen, weswegen es auch möglich ist beide Sprachen miteinander zu vergleichen. Wer eine von ihnen relativ gut beherrscht und wirklich verstanden hat, der wird generell kaum Probleme haben sich in die Programmierung der anderen hineindenken zu können. Die Syntax ist zwar anders, aber das Grundprinzip ist das Gleiche. Es gilt der Grundsatz: Wer einmal programmiert hat, dem wird es leicht fallen sich eine andere Programmiersprache anzueignen.

Turbo Pascal und BASIC gelten als die typischen Sprachen für Programmieranfänger. BASIC hat eine gut verständliche, einfache Syntax und die Anzahl der verfügbaren Befehle und Funktionen hält sich noch in einem überschaubaren Rahmen. Pascal bietet zwar mehr Möglichkeiten und ist es mächtiger als BASIC, bietet sich aber auf Grund des übersichtlichen Programmaufbaus und der nachvollziehbaren Struktur geradezu an, um die Technik des Programmierens verstehen und erlernen zu können.

2.2.2.1. Allgemeine Unterschiede zwischen TI-85 BASIC und Turbo Pascal

Beim Umstieg von Turbo Pascal zu TI-85 BASIC gibt es ein paar wichtige Unterschiede zu beachten um effektiv programmieren zu können.
Generell sollte man sich darauf gefasst machen mit einer anderen als der gewohnten übersichtlichen und praktischen Programmierumgebung von Turbo Pascal arbeiten zu müssen. Der Programmeditor des TI-85 ist zwar für einen Taschenrechner wirklich gut, aber schon allein wegen der gewöhnungsbedürftigen Tastatur recht anstrengend zu bedienen. Glücklicherweise bieten im Internet erhältliche Programme dazu eine sehr gute Alternative.

Die wichtigsten Unterschiede unmittelbar in der Programmiersprache sind folgende:

2.2.2.2. Vergleich der Kommandos von Turbo Pascal und TI-85 BASIC

  Turbo Pascal TI-85 BASIC Beschreibung
       
Variablen var [Bezeichner]:int;
[Variable]:=[Wert];
 :[Wert]®[Bezeichner] Der Variablen wird ein ganzzahliger Wert zugewiesen
  var [Bezeichner]:string;
[Variable]:='[Text]';
 :"[Text]"®[Bezeichner] Der Variablen wird ein String zugewiesen
Boolesche Operatoren and, or, not, xor
 and, or, not, xor And, or, xor und not können sowohl logisch, als auch bitweise verwendet werden
Vergleichsoperatoren <,>,=,<>,<=,>=
 <,>,==,¹,£,³ Operatoren zum Vergleichen von Werten oder Ausdrücken
Verzweigungen If [Bedingung] then
Begin
  [Anweisungen]
End
Else
Begin
  [Anweisungen]
End;
 :If [Bedingung]
:Then
:[Anweisungen]
:Else
:[Anweisungen]
:End		 Wenn die Bedingung wahr ist (1 ergibt), werden die Anweisungen hinter "then" ausgeführt. Ist die Bedingung nicht erfüllt (0) werden die Anweisungen im Else-Zweig ausgeführt.
  Case [Variable] of
Wert1: Begin
  [Anweisungen] End;
Wert2: Begin
  [Anweisungen] End;
Else Begin
  [Anweisungen] End
End;		 :Menu(1,"Option1",Marke1, 2,"Option2",Marke2)
:..
:Lbl Marke1
:[Anweisungen]
:..
:Lbl Marke2
:[Anweisungen]		 Die Menu- Anweisung ist kein direktes Equivalent zur Case- Struktur in Turbo Pascal. Dennoch ist sie die TI-85 BASIC Variante der Mehrfachauswahl. Ein Menü wird auf dem Display angezeigt und der Nutzer kann zwischen bis zu 5 Optionen wählen. Daraufhin springt der Interpreter zur   Stelle im Quelltext, die durch die entsprechend der Option gewählten Sprungmarke entspricht.
Schleifen For [Zählvariable]:=[Startwert] to [Endwert] do
Begin
  [Anweisungen]
End;		 :For([Zählvariable],
[Startwert],[Endwert], [Inkrement])
:[Anweisungen]
:End		 Im Gegensatz zu Turbo Pascal, kann das Inkrement der For- Schleife selbst festgelegt werden. Die Schleife wird so oft ausgeführt, und bei jeder Durchführung inkrementiert (um den Wert des Inkrements erhöht), bis die Zählvariable den Endwert überschreitet.
  Repeat
  [Anweisungen];
until [Bedingung];		 :Repeat [Bedingung]
:[Anweisungen]
:End		 Die Anweisungen werden so oft ausgeführt, bis die Bedingung erfüllt ist.
  While [Bedingung] do
Begin
  [Anweisungen]
End;		 :While [Bedingung]
:[Anweisungen]
:End		 Solange die Bedingung erfüllt ist, werden die Anweisungen immer wieder ausgeführt.
Inkrementieren
inc([Variable]);
if (Variable <= Wert) then
  [Anweisungen];
...		 :IS>([Variable],[Wert])
:[Anweisung1, wenn Variable £ Wert]
:...		 Erhöht die Variable um 1 und vergleicht anschließend mit dem gegebenem Wert. Ist die Variable größer als der Vergleichswert wird die direkt folgende Anweisung übersprungen.
Dekrementieren dec([Variable]);
if (Variable >= Wert) then
  [Anweisungen];
...		 :DS<([Variable],[Wert])
:[Anweisung1, wenn Variable ³ Wert]
:...		 Vermindert die Variable um 1. Nur wenn die Variable danach größer oder gleich dem Wert ist, wird die darauf folgende Anweisung ausgeführt, sonst übersprungen.
Eingabeanweisungen var [Bezeichner]:integer;
readln([Variable]);		 :Input [Bezeichner]
        ODER
:Prompt Bezeichner1, Bezeichner2...		 Der eingegebene Wert wird in einer Variablen gespeichert. Bei dem Prompt Befehl werden beliebig viele Werte abgefragt und gespeichert.
  var [Bezeichner]:integer;
write('Wert eingeben!');
readln([Variable]);		 :Input "Wert eingeben!",[Bezeichner] Der User wird durch eine beliebige Zeichenkette aufgefordert, den Wert einzugeben.
  var [Bezeichner]:string;
write('String eingeben!');
readln([Variable]);		 :InpSt "String eingeben!",[Bezeichner] Nach Aufforderung gibt der Nutzer eine Zeichenkette ein, die als String gespeichert wird.
  var wahl:char;
wahl:=readKey;
write(wahl);

Ausgabe: a		 :getKy®wahl
:Disp wahl

Ausgabe: 51		 Unter Turbo Pascal wird genau ein Zeichen eingelesen, welches der nächsten gedrückten Taste entspricht. Bei TI-85 BASIC hingegen, wird ein bestimmter Wert eingelesen, da jede Taste einen ganzzahligen Wert besitzt.
Ausgabeanweisungen writeln('Text'); :Disp "Text" Der Text wird angezeigt, danach erfolgt ein Zeilensprung.
  gotoxy(1,1);
writeln('Text');		 :Outpt(1,1,"Text") Der Text wird an einer ganz bestimmten Stelle angezeigt. Beim Outpt Kommando muss x<=8 und y<=21 sein.
Bildschirmanweisungen Clrscr; :ClLCD Der Bildschirm wird komplett gelöscht.
    :DispG Der aktuelle Graph wird angezeigt.
Sprungmarken label [Bezeichner];
goto [Bezeichner];
...;
1:[Anweisungen];		 :[Anweisungen]
:Lbl Marke1
:[Anweisungen]
:Goto Marke1		 Mit Lbl wird die Marke definiert. Mit dem Befehl Goto wird dann zur definierten Marke gesprungen.
Pause readln; :Pause Die Programmausführung wird solange unterbrochen, bis [ENTER] gedrückt wird.
Unterprogramme / Prozeduren [Prozedurname](Parameter); :[Name des Unterprogramms] Das Programm springt in eine Prozedur oder ein Unterprogramm und führt dies aus.
Rücksprung exit; :Return Der Return Befehl bewirkt, dass das Unterprogramm verlassen wird und die Programmausführung im Hauptprogramm weiterläuft.
Programmende Program [name];
Begin
  [Anweisungen]
End.		 :Stop Sobald der Interpreter auf die Stop Anweisung trifft, wird das Programm beendet.