Benutzername
Passwort
C64 < Hauptseite < BASIC V2.0 < Schleifen, Sprünge und I/O
📑
📘
Eine der wichtigsten Funktionen in der Programmierung ist die Abfrage von Werten mittels IF-Bedingungen. Mit dem BASIC-Befehl IF können wir den Programmablauf abhängig von der Auswertung eines Ausdrucks steuern, beispielsweise durch einen Vergleich.

Wir können den IF-Befehl (wenn ...) mit dem anschließenden BASIC-Befehl THEN (dann ...) oder GOTO (springe zu ...) nutzen. Wenn der Ausdruck nach dem IF "wahr" ist (also einen Wert ungleich 0 ergibt), wird der darauf folgende Befehl ausgeführt. Ist der Ausdruck "falsch" (den Wert 0 hat), wird der anschließende Befehl ignoriert und die darunter folgenden Befehle in dieser Zeile werden nicht mehr ausgeführt.

Wenn wir die GOTO-Zeilennummer-Variante nutzen, werden etwaige nach der Zeilennummer folgende Befehle niemals ausgeführt und kommen somit einem Kommentar gleich.

Der Ausdruck nach dem IF-Befehl enthält in der Regel Operatoren, um Vergleiche anzustellen, die gegebenenfalls mit logischen Verknüpfungen noch komplexere Bedingungen bilden können. Das Ergebnis des Ausdrucks entscheidet über den weiteren Programmablauf und wird als Integer-Wert betrachtet.

ungleich 0:
entspricht einem "Wahr" und der THEN- oder GOTO-Zweig wird aktiv.
gleich 0:
entspricht einem "Falsch" und der THEN- oder GOTO-Zweig wird übergangen.
Wir fangen mit den vergleichen zweier Werte an:

= : Prüfung auf Gleichheit

10 IF 5 = 5 THEN PRINT "IST GLEICH"

Bildschirmausgabe = IST GLEICH

10 IF 7 = 5 THEN PRINT "IST GLEICH"

Bildschirmausgabe = keine Ausgabe

<> : Prüfung auf Ungleichheit

10 IF 5 <> 5 THEN PRINT "IST UNGLEICH"

Bildschirmausgabe = keine Ausgabe

10 IF 7 <> 5 THEN PRINT "IST UNGLEICH"

Bildschirmausgabe = IST UNGLEICH


> : Prüfung auf größer als

10 IF 5 > 5 THEN PRINT "IST GROESSER"

Bildschirmausgabe = keine Ausgabe

10 IF 7 > 5 THEN PRINT "IST GROESSER"

Bildschirmausgabe = IST GROESSER


< : Prüfung auf kleiner als

10 IF 5 < 5 THEN PRINT "IST KLEINER"

Bildschirmausgabe = keine Ausgabe

10 IF 5 < 7 THEN PRINT "IST KLEINER"

Bildschirmausgabe = IST KLEINER


>= : Prüfung auf kleiner grösser

10 IF 5 >= 5 THEN PRINT "IST GROESSER GLEICH"

Bildschirmausgabe = IST GROESSER GLEICH

10 IF 5 >= 7 THEN PRINT "IST GROESSER GLEICH"

Bildschirmausgabe = keine Ausgabe


<= : Prüfung auf kleiner gleich

10 IF 5 <= 5 THEN PRINT "IST KLEINER GLEICH"

Bildschirmausgabe = IST KLEINER GLEICH

10 IF 5 <= 7 THEN PRINT "IST KLEINER GLEICH"

Bildschirmausgabe = IST KLEINER GLEICH

OR : Prüfung auf Oder-Verknüpfung (Mindestens eine Abfrage muss WAHR sein. C64-Wiki ORhttps://www.c64-wiki.de/wiki/OR)

10 IF 1 = 0 OR 1 = 1 THEN PRINT "EINS DER ABFRAGEN IST WAHR"

Bildschirmausgabe = EINS DER ABFRAGEN IST WAHR

10 IF 1 = 0 OR 0 = 1 THEN PRINT "EINS DER ABFRAGEN IST WAHR"

Bildschirmausgabe = Keine Ausgabe, da keines der Abfragen WAHR ist.

AND : Prüfung auf UND-Verknüpfung (Alle Abfragen müssen WAHR sein. C64-Wiki ANDhttps://www.c64-wiki.de/wiki/AND)

10 IF 1 = 1 AND 1 = 1 THEN PRINT "WAHR"

Bildschirmausgabe = WAHR

10 IF 1 = 0 AND 0 = 1 THEN PRINT "WAHR"

Bildschirmausgabe = Keine Ausgabe, da keines der Abfragen WAHR ist

NOT : Kehrt die Aussage um (Aus WAHR wird UNWAHR und andersherum. C64-Wiki NOThttps://www.c64-wiki.de/wiki/NOT)

10 IF NOT 2 = 1 AND 2 = 2 THEN PRINT "WAHR"

Bildschirmausgabe = WAHR

10 IF NOT 1 = 1 AND 1 = 1 THEN PRINT "WAHR"

Bildschirmausgabe = Keine Ausgabe, da beide der Abfragen WAHR sind.

10 IF NOT(1=2) AND NOT(1=2) THEN PRINT "WAHR"

Bildschirmausgabe = WAHR weil NOT() aus UNWAHR = WAHR macht .
10 FOR X=1 TO 5
20 PRINT "AUSGABE ZEILE";X
30 NEXT X

Eine FOR-NEXT-Schleife wiederholt eine bestimmte Anzahl von BASIC-Befehlen, die vom Startwert bis zum Endwert durchgeführt werden, wobei die Endbedingung im NEXT-Befehl überprüft wird. Auch wenn keine Parameterangaben gemacht werden, wird die Schleife mindestens einmal durchlaufen. Die Schrittweite (STEP) kann festgelegt werden, um zu bestimmen, ob die Schleifenvariable erhöht oder erniedrigt wird und um welchen Wert dies geschieht. Wenn kein STEP-Befehl angegeben wird, wird die Schrittweite standardmäßig als +1 festgelegt.

FOR-NEXT-Schleifen sind besonders nützlich für die wiederholte Ausführung von gleichartigen BASIC-Befehlen, wie z.B. Berechnungen, Bildschirmausgaben und PRINT-Befehle. Durch den Einsatz von Schleifen kann man mit weniger Code das gleiche Ergebnis erzielen.

Einfache Schleifen

10 FOR X=1 TO 20: PRINT X: NEXT
=> Es werden die Zahlen 1-20 zeilenweise angezeigt.

10 FOR X=-10 TO 0 STEP 0.5: PRINT X: NEXT X
=> Es werden hier 20 Zahlen von -10 bis 0 angezeigt, da die Schrittweite 0.5 ist.

10 FOR X=100 TO -100 STEP -25: PRINT X: NEXT X
=> Es werden hier 9 Zahlen angezeigt und die Schleife wird herunter gezählt von 100 bis -100 mit der Schrittweite -25.

Verschachtelung
lang:
10 FOR X=1 TO 10
20 PRINT
30 FOR Y=1 TO 10
40 PRINT X*Y;
50 NEXT Y
60 NEXT X
kurz:
10 FOR X=1 TO 10: PRINT: FOR Y=1 TO 10: PRINT X*Y;:NEXT Y,X



Das Doppelpunkt-Zeichen ":" ist ein Trennzeichen, das dazu verwendet wird, mehrere Befehle oder Anweisungen in einer einzelnen Codezeile zu kombinieren. Das ":" ermöglicht es, mehrere Anweisungen in einer Codezeile auszuführen, anstatt sie auf mehrere Zeilen aufzuteilen. Dies spart Speicherplatz und macht den Code kompakter.

In der ersten FOR-Schleife wird die Variable X auf 1 gesetzt, und mit dem Befehl PRINT wird eine neue Zeile initialisiert. In der darauffolgenden FOR-Schleife wird die Variable Y auf 1 gesetzt und das Ergebnis von X*Y mit PRINT X*Y; ausgegeben. Durch das Semikolon (;) bleibt der Cursor hinter der Ausgabe, um weitere Ergebnisse in derselben Zeile auszugeben.Die Schleifen werden mit NEXT Y,X wiederholt. Zunächst wird die Y-Variable um 1 erhöht, und die Schleife (FOR Y=1 TO 10: PRINT XY;:NEXT Y) wird wiederholt, bis Y=10 ist. Anschließend wird die X-Variable um 1 erhöht, und die Schleife (FOR X=1 TO 10: PRINT: FOR Y=1 TO 10: PRINT XY;:NEXT Y,X) wird wiederholt.

Es ist wichtig zu beachten, dass die Variablen X und Y auch außerhalb der FOR-Schleifen existieren.
10 IF 5 = 5 GOTO 500
...
500 PRINT "HIER GEHT ES WEITER"



Mir GOTO-Befehl springen wir zur angegeben BASIC-Zeile in unseren Code und führen den Code an dieser stelle weiter fort. Der Wertbereich für Zeilennummern von 0 bis 63999 sollte nicht überschritten werden! (darüber liegende Werte führen zu einem ?SYNTAX ERROR)

Link: www.c64-wiki.de GOTOFür weitere Informantionen

https://www.c64-wiki.de/wiki/GOTO
10 GOSUB 50
20 PRINT " HALLO LEUTE"
30 END
50 PRINT "ICH BIN EIN UNTERPROGRAMM"
60 RETURN
Mit den GOSUB-Befehl springen wir in ein Teil unsern BASIC-Programm, arbeiten es ab und springen wieder mit RETRUN zurück zum Aufrufbefehl GOSUB und führen das Programm weiter an dieser Stelle fort.
Machen wir noch ein kleines Beispiel:
10 PRINT CHR$(147)
20 SP = 20: ZE = 3: A$ = "GUTEN TAG!": GOSUB 1010: GOSUB 2010
30 SP = 10: ZE = 3: A$ = "ICH BIN DER COMMODORE 64": GOSUB 1010: GOSUB 2010
40 SP = 12: ZE = 6: A$ = "UND WER BIST DU?": GOSUB 1010
100 END

1000 **************************
1001 REM CURSORPOSITION SETZEN
1002 **************************
1010 POKE 211,SP :POKE 214, ZE: SYS 58640 : PRINT A$
1020 RETURN

2000 **************************
2001 REM WARTESCHLEIFE
2000 **************************
2010 FOR X=0 TO 1500: NEXT X
2020 RETURN
Mit 10 PRINT CHR$(147) leeren wir den Bildschirm.
Mit 20 SP = 20: ZE = 3: A$ = "GUTEN TAG!"
Setzen wir ein paar Variablen. Mit SP speichern wir die horizontale Position auf dem Bildschirm. Mit ZE speichern wir die vertikale Position auf dem Bildschirm und mit A$ speichern wir das, was wir später ausgeben möchten.
Jetzt springen wir mit GOSUB 1010 zu unserem ersten Unterprogramm.
1000 **************************
1001 REM CURSORPOSITION SETZEN
1002 **************************
1010 POKE 211,SP :POKE 214, ZE: SYS 58640 : PRINT A$
1020 RETURN
Mit POKE-Befehl setzen wir an der <speicherstelle>,<den 8bit Wert (0-255)> ab:
211 => Aktuelle (logische!) Spalte des Cursors (0..79)
213 => Aktuelle Zeile des Cursors (0..24)

LINK:Speicherbelegungsplan 64https://www.c64-wiki.de/wiki/Speicherbelegungsplan

Mit SYS-Befehl werden Assemblerprogramm ausgeführt.
58640 => PLOT: Setzt/holt Cursorposition: Register X = Zeile, Register Y = Spalte

Mit dem Befehl PRINT A$ geben wir unseren Text aus und kehren dann mit dem RETURN-Befehl zurück zum Hauptprogramm.

Jetzt kommt unser nächste Unterprogramm mit GOSUB 2010:
2000 **************************
2001 REM WARTESCHLEIFE
2000 **************************
2010 FOR X=0 TO 1500: NEXT X
2020 RETURN
Dies ist eine einfache Warteschleife, die für eine bestimmte Zeit wartet und dann zum Hauptprogramm zurückkehrt. So werden auch die die restlichen Zeilen des Codes abgearbeitet, bis das END-Statement erreicht wird, welches das BASIC-Programm beendet.

Link: www.c64-wiki.de GOSUBhttps://www.c64-wiki.de/wiki/GOSUB
für weitere Informantionen

https://www.c64-wiki.de/wiki/GOSUB
Der BASIC-Befehl ON wird in Verbindung mit den Befehlen GOTO und GOSUB sowie einem Argument (Zahl) verwendet, um je nach Wert der berechneten Zahl zu verschiedenen Sprungzielen zu verzweigen. Die Liste nach dem Befehl GOTO oder GOSUB enthält durch Komma (,) getrennte numerische Konstanten als Sprungziele, die im Bereich der zulässigen Zeilennummern (0-63999) liegen können. Alternativ können auch leere Einträge in der Liste vorhanden sein.

Typische Anwendung
Verwendung mit GOTO:
10 INPUT "GEBEN SIE BITTE EIN ZAHL EIN: "; A
20 ON A GOTO 1000,2000,3000
30 END
1000 PRINT "1. SPRUNGZIEL"
1001 A=A+1: GOTO 20
2000 PRINT "2. SPRUNGZIEL"
2001 A=A+1: GOTO 20
3000 PRINT "3. SPRUNGZIEL"
3001 A=A+1: GOTO 20
Verwendung mit GOSUB:
10 INPUT "GEBEN SIE BITTE EIN ZAHL EIN: "; A
20 ON A GOSUB 1000,2000,3000
30 END
1000 PRINT "1. SPRUNGZIEL"
1001 A=A+1: RETURN
2000 PRINT "2. SPRUNGZIEL"
2001 A=A+1: RETURN
3000 PRINT "3. SPRUNGZIEL"
3001 A=A+1: RETURN
🖛Eine Leerangabe entspricht dabei der Zeilennummer 0. Existiert diese Zeile nicht, mündet dies in der BASIC-Fehlermeldung ?UNDEF'D STATEMENT ERROR.
🖛Ein Sprung zur angegebenen Zeilennummer wird nur dann ausgeführt, wenn der Wert des Arguments Zahl zwischen 1 und der Anzahl der tatsächlich angeführten Sprungziele liegt.
🖛Zahl (A) darf generell nur Werte von 0 bis 255 annehmen, sonst wird mit dem Fehler ?ILLEGAL QUANTITY ERROR abgebrochen.
🖛Ergibt die Auswertung zu Zahl keine Ganzzahl, wird automatisch analog zu INT die entsprechende Ganzzahl ermittelt. Falls die Zahl 0 oder größer als die Anzahl der Sprungziele ist, wird zu keinem der Sprungziele verzweigt und der ON-Befehl übergangen.

Liefert das Argument zu ON keinen Zahlentyp, erscheint die BASIC-Fehlermeldung ?TYPE MISMATCH ERROR. Enthält das Argument eine Zahl außerhalb des zulässigen Zeilennummernbereichs, führt dies zur BASIC-Fehlermeldung ?SYNTAX ERROR. Falls die Zeile zur gewählten Zeilennummer nicht existiert, endet dies in der Ausgabe der BASIC-Fehlermeldung ?UNDEF'D STATEMENT ERROR. Sonstige Berechnungsfehler des ON-Arguments können gegebenenfalls weitere BASIC-Fehlermeldungen hervorrufen, wie z.B. die BASIC-Fehler ?DIVISION BY ZERO ERROR oder ?OVERFLOW ERROR.

Link: www.c64-wiki.de ONhttps://www.c64-wiki.de/wiki/ON
für weitere Informantionen

https://www.c64-wiki.de/wiki/ON
von:
Betreff :
von:
Impressum / sitemap.xml
version 1.0 © 2022-2026, www.retro-archiv.de Rechte vorbehalten