In dieser Lektion lernen wir, wie unser Tier laufen kann. In Lektion 3 haben wir das Tier mithilfe der Prozedur Put_Line auf den Bildschirm gebracht. Um es noch einmal zu wiederholen: Put_Line druckt sein Argument auf den Bildschirm und beendet die aktuelle Zeile.
“Laufen” heißt, das Tier soll an mehreren Stellen des Bildschirms erscheinen, nacheinander. Ein erster Versuch, das Tier laufen zu lassen, könnte also so aussehen:
with Ada.Text_IO; use Ada.Text_IO;
procedure Run is begin
for I in 1 .. 10 loop
Put_Line ("d");
end loop;
end Run;
Oha, unser zweites Programm, und schon eine Schleife! Intuitiv sollte klar sein, dass wir hier den Prozeduraufruf von Put_Line einfach zehnmal ausführen. Konkret wird das durch eine for-Schleife erreicht. Sie wird durch das Schlüsselwort for eingeführt. Danach kommt der Name einer Schleifenvariable; das ist eine Variable, die in der Schleife verwendet werden kann und bei jedem Durchlauf verändert wird. Nach dem Schlüsselwort in kommt der Bereich der Schleifenvariable, hier sagen wir, dass wir von 1 bis 10 zählen. Das heißt, dass die Schleifenvariable I nacheinander die Werte 1, 2, 3 und so weiter bis 10 annimmt. Nach der Bereichsangabe, und zwischen den Schlüsselwörtern loop und end loop kommt der Schleifenkörper, der hier nur aus dem Put_Line-Aufruf besteht. Das ganze wird durch ein Semikolon abgeschlossen, wie für alle Statements.
Hier ist die Ausgabe dieses Programms:
d
d
d
d
d
d
d
d
d
d
Sieht das wirklich aus wie ein Tier, das läuft? Nicht wirklich, hier hat sich etwas verdoppelt oder verzehnfacht! Es gibt hier gleich mehrere Probleme. Erstens, wie gesagt, verdoppelt sich das Tier anstatt sich zu bewegen. Zweitens ist die Bewegung vertikal, wo doch horizontal als viel natürlicher erscheinen würde. Drittens geht alles viel zu schnell! Auf meinem Computer erscheint die gesamte Ausgabe quasi auf einmal. Eine Bewegung ist mit dem bloßen Auge nicht festzustellen.
Das Problem der vertikalen Bewegung wird durch die Verwendung von Put_Line hervorgerufen: Nach der Ausgabe des Buchstaben erzeugt es ja auch einen Zeilenumbruch. Das kann man einfach abstellen und stattdessen die Prozedur Put verwenden. Es ist in Ada auch nicht sonderlich schwierig, jedesmal ein bißchen zu warten. Dafür gibt es eine neue Form des Statements, die das Schlüsselwort delay verwendet. Insgesamt würde unsere Schleife jetzt so aussehen:
for I in 1 .. 10 loop
Put ("d");
delay 0.5;
end loop;
New_Line;
Wir haben hier delay 0.5; verwendet, um eine halbe Sekunde zu warten. Und hier ist die Ausgabe dieses Programms:
dddddddddd
Immerhin kann man jetzt klar eine Bewegung erkennen, und immerhin geht es jetzt horizontal! Aber die Verdopplung findet noch statt. Um sie zu verhindern, muss die alte Position des Tieres gelöscht werden, bevor es an seiner neuen Position gedruckt wird. Dazu greifen wir in eine Trickkiste. Ein direktes Löschen von einmal gedruckten Zeichen ist so einfach nicht möglich. Wir können aber ein neues Zeichen drucken, dessen Bedeutung es ist, das zuletzt gedruckte Zeichen zu löschen. Das kommt dir vermutlich bekannt vor, ja es geht um die Backspace-Taste, die du hoffentlich auch auf deiner Tastatur hast, und die einen Pfeil nach links als Symbol hat. In Ada können wir so tun, als wurde die Backspace-Taste gedrückt, indem wir das Zeichen ausgeben, das zu dieser Taste passt. Das geht wie folgt:
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Characters.Latin_1;
procedure Run is
begin
for I in 1 .. 10 loop
Put (Ada.Characters.Latin_1.BS);
Put (" ");
Put ("d");
delay 0.5;
end loop;
New_Line;
end Run;
Hier wird in der Schleife als erstes das zuletzt gedruckte Zeichen gelöscht, und zwar durch die Ausgabe des Zeichens Ada.Characters.Latin_1.BS. Damit wir nicht wieder an die gleiche Stelle schreiben, rücken wir nach rechts, indem wir ein Leerzeichen ausgeben. Schließlich wird das Tier ausgegeben und wir warten, damit ein Mensch es auch sehen kann. Es wird beim nächsten Schleifendurchlauf wieder gelöscht und eine Spalte weiter geschrieben. Ähnlich wie für Put_Line und Put, für die wir die magische Zeile mit Ada.Text_IO hinzufügen müssen, erfordert auch dieses neue Zeichen eine magische Zeile:
with Ada.Characters.Latin_1;
Unser Programm funktioniert ziemlich gut, es gibt aber noch einen kleinen Schönheitsfehler: das Tier erscheint nie “ganz links”, das heißt in der ersten Spalte. Das kommt daher, dass wir löschen und nach rechts rücken, bevor das erste Tier ausgegeben wurde. Wir können das durch ein if-Statement verhindern (dies ist das fertige Programm):
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Characters.Latin_1;
procedure Run is
begin
for I in 1 .. 10 loop
if I /= 1 then
Put (Ada.Characters.Latin_1.BS);
Put (' ');
end if;
Put ('d');
delay 0.5;
end loop;
New_Line;
end Run;
Hier verwenden wir ein if-Statement. Es erlaubt, Statements nur unter bestimmten Bedingungen auszuführen. In unserem Fall löschen und rücken wir nur, wenn I, die Schleifenvariable, nicht gleich 1 ist, wenn wir also schon mindestens einmal das Tier gedruckt haben. Das wird durch die Verwendung des “nicht gleich” Operators /= erreicht. Die üblichen Operatoren wie =, <=, >=, < und > gibt es natürlich auch in Ada.
In Ada gibt es den Begriff eines Blockes. Unser Hauptprogramm, der Schleifenkörper, und auch das innere des if-Statements formen jeweils einen Block (wie man sehen kann, können Blöcke innerhalb von anderen Blöcken sein). Die allermeisten solcher Blöcke in Ada müssen mit dem Schlüsselwort end geschlossen werden, und einer Bezeichnung, welcher Block denn jetzt geschlossen wird. Für Schleifen zum Beispiel ist das immer end loop, für if-Statements immer end if, und für Prozeduren immer end gefolgt von dem Prozedurnamen. Leute, die von anderen Programiersprachen kommen, finden das oft etwas nervig, aber die Lesbarkeit des Programmes wird dadurch stark erhöht, und das ist ein großer Vorteil.
Und es bewegt sich doch!