Schleifenprogrammierung in C/C++, Fortran und Pascal

Transkript

1 Schleifenprogrammierung in C/C++, Fortran und Pascal Stefan Ackermann Mathematisches Institut der Universität Leipzig 8. April Die kopfgesteuerte Schleife Bei der kopfgesteuerten Schleife steht die Bedingung, unter der die Anweisungen des Schleifenkörpers abgearbeitet werden sollen, vor dem Schleifenkörper. Ist die Bedingung falsch, dann wird zu der auf den Schleifenkörper folgenden Anweisung gesprungen. Es kann also sein, dass der Schleifenkörper nie durchlaufen wird. ja Bed.? nein Solange... C++: Fortran: Pascal: while (< logischer Ausdruck >){ // Ihre Anweisungen do while (< logischer Ausdruck >) Ihre Anweisungen while (< logischer Ausdruck >) do { Ihre Anweisungen Ein typisches Beipiel für die Anwendung einer kopfgesteuerten Schleife ist das Löschen von eventuell noch nicht aus dem Tastaturpuffer abgerufenen Zeichen vor einer erneuten Nutzereingabe, hier dargestellt in Pascal: var c: char; // Tastaturpuffer leeren while keypressed do readkey; // neue erwartete Nutzereingabe //bei einer Anweisung kann und end entfallen 1

2 c:=readkey;... end. 2 Die fußgesteuerte Schleife Bei der fußgesteuerten Schleife steht die Bedingung, unter der die Anweisungen des Schleifenkörpers abgearbeitet werden sollen, nach dem Schleifenkörper, d. h. der Schleifenkörper wird wenigstens einmal durchlaufen. Abhängig von der Programmiersprache wird dann erneut zum Schleifenanfang gesprungen, wenn die Bedingung wahr (C(C++/Fortran) oder falsch (Pascal) ist, anderenfalls wird mit der auf die Schleife folgenden Anweisung fortgesetzt. In Fortan gibt es keine eigentliche fußgesteuerte Schleife; man kann die Schleife an jeder Stelle mit dem Befehl exit verlasssen. Dies ist auch in C/C++ und Pascal mit dem Befehl break möglich (s. u.). nein Bed.? ja Wiederhole bis... C++: Fortran: Pascal: do { // Ihre Anweisungen while (< logischer Ausdruck >) do Anweisungsblock 1 if ( < logischer Ausdruck > ) exit Anweisungsblock 2 repeat { Ihre Anweisungen until (< logischer Ausdruck >); Bemerkung: In Fortran hat man nur dann eine echte fußgesteuerte Schleife, wenn der Anweisungsblock 2 leer ist. Ein typisches Beipiel für die Anwendung einer fußgesteuerten Schleife ist die Umwandlung einer vom Nutzer als Zeichenkette eingegebenen Zahl in eine numerische Variable, im Folgenden in der Sprache Pascal dargestellt: var s: String; x: real; ierr: integer; 2

3 repeat write( Geben Sie eine reelle Zahl ein: x= ); readln(s); val(s,x,ierr); if ierr<>0 then Writeln( Eingabefehler - bitte wiederholen); until ierr=0;... end. 3 Die Zählschleife Die Zählschleife ist eine besondere kopfgesteuerte Schleife, d. h. es wird vor der Abarbeitung des Schleifenkörpers geprüft, ob die Schleifenvariable im angegebenen Bereich liegt. Am Ende des Schleifenkörpers wird die Schleifenvariable inkrementiert oder dekrementiert; die zulässige Schrittweite hängt von der Programmiersprache ab: Pascal Die Schleifenvariable muss eine ordinale Variable (Aufzählungstyp) sein, also z. B. eine ganze Zahl oder ein Zeichen (char). Mit to bzw. downto wird für die Schleifenvariable der Nachfolger bzw. der Vorgänger eingesetzt. Fortan Die Schleifenvariable sollte eine ganze Zahl sein, auch wenn der Compiler andere Datentypen zulässt, sonst kann es nämlich durch Rundungsfehler zu unerwünschten Effekten kommen. Die Schrittweite kann - positiv oder negativ - frei gewählt werden. C/C++ Die Schleifenvariable kann von beliebigem Typ sein; die Schrittweiten können sogar von Schritt zu Schritt variieren. n := a ja n > b?...; n := n + 1 nein Für n := a bis b C++: Fortran: Pascal: for (var schleifenvariable = anfangswert; schleifenvariable <= endwert; schleifenvariable += schrittweite) { // Ihre Anweisungen do schleifenvariable = anfangswert, endwert, schrittweite Ihre Anweisungen for schleifenvariable := anfangswert [ to / downto] endwert do { Ihre Anweisungen 3

4 4 Befehle zum (unbedingten) Verlassen einer Schleife In allen Schleifenarten der hier benutzten Programmiersprachen kann man an jeder Stelle des Schleifenkörpers zur nach der Schleife folgenden Anwendung oder zum Beginn des Schleifenkörpers springen. Dies kann unbedingt - also ohne jegliche Bedingung - geschehen, man kann aber natürlich auch eine if-anweisung davorsetzen. Verlassen der Schleife Sprung an den Schleifenanfang C++: break continue Fortran: exit cycle Pascal: break continue 5 Beispiele für Zählschleifen Zusätzlich sehen Sie an diesen Beispielen auch, wie in den verschiedenen Programmiersprachen in eine Datei ausgegeben wird. 5.1 Beispiel für eine Zählschleife in C / C++ /* Programm Fahrenheit-Celsius-Tabelle zeigt eine einfache Umrechnungstabelle von Grad Fahrenheit nach Grad Celsius auf der Konsole an (printf) und gibt dies gleichzeitig in eine Datei aus. */ #include <stdio.h> #include <math.h> #include <stdlib.h> #include <stdbool.h> int main(){ double Fahrenheit, Celsius; FILE * f_out; f_out=fopen("fahrenheit.txt", "w"); // oeffne beschreibbar (writeable) printf(" Fahrenheit Celsius\n"); fprintf(f_out, " Fahrenheit Celsius\n"); printf(" \n"); fprintf(f_out, " \n"); for (int i=0; i<21; i++){ Fahrenheit = *i; Celsius = (5.0/9.0) * (Fahrenheit-32.0); printf("%10.5f %10.5f\n",Fahrenheit,Celsius); fprintf(f_out, "%10.5f %10.5f\n",Fahrenheit,Celsius); printf("\n"); fprintf(f_out, "\n"); fclose(f_out); // Textdatei schliessen system("pause"); 4

5 5.2 Beispiel für eine Zählschleife in Fortran Programm Fahrenheit-Celsius-Tabelle gibt eine einfache Umrechnungstabelle von Grad Fahrenheit nach Grad Celsius auf der Konsole und gleichzeitig in eine Textdatei aus program celsius_table implicit none real :: Fahrenheit, Celsius open(unit=20,file= fahrenheit.txt,status= replace,action= write ) write(*,*) Fahrenheit Celsius Ausgabe auf die Konsole write(20,*) Fahrenheit Celsius Ausgabe in die Datei write(*,*) write(20,*) do Fahrenheit = 30.0, 220.0, 10.0 Zählvariable sollte besser ganzzahlig sein Celsius = (5.0/9.0) * (Fahrenheit-32.0) write(*,*) Fahrenheit,Celsius write(20,*) Fahrenheit,Celsius close(unit=20) end program celsius_table 5.3 Beispiel für eine Zählschleife in Pascal program celsius_table; { Programm Fahrenheit-Celsius-Tabelle gibt eine einfache Umrechnungstabelle von Grad Fahrenheit nach Grad Celsius auf der Konsole und gleichzeitig in eine Textdatei aus uses crt; var Fahrenheit, Celsius: real; i: Integer; f_out: Text; BEGIN clrscr; { Bildschirm loeschen - verlangt unit crt Assign(f_out, fahrenheit.txt ); Rewrite(f_out); writeln( Fahrenheit Celsius ); writeln(f_out, Fahrenheit Celsius ); writeln( ); writeln(f_out, ); for i:=0 to 20 do 5

6 Fahrenheit := *i; Celsius := (5.0/9.0) * (Fahrenheit-32.0); writeln(fahrenheit,,celsius); writeln(f_out,fahrenheit,,celsius); readln; Close(f_out); END. 6 Beispiele für kopf- und fußgesteuerte Schleifen Zusätzlich sehen Sie an diesen Beispielen auch, wie in den verschiedenen Programmiersprachen Kommandozeilenparameter verarbeitet und Unterprogramme eingebunden werden. 6.1 Beispiel für kopf- und fußgesteuerte Schleifen in C / C++ /* Programm Primfaktorenzerlegung gibt die Primfaktorzerlegung einer auf der Kommandozeile eingegeben natürlichen Zahl an gleichzeitig Beispielprogramm für kopf- und fussgesteuerte Schleifen */ #include <stdio.h> #include <math.h> #include <stdlib.h> #include <stdbool.h> #include <strings.h> long int z, f, i; char * s; char s1[100]; void hilfe(){ printf(" Dieses Programm berechnet die Primfaktorzerlegung einer\n"); printf(" natuerlichen Zahl, die als Parameter uebergeben werden muss\n\n"); printf(" Beispiel: PRIMFAKT 120\n\n"); void spalte_ab(){ char fs[10], is[20]; i=0; // kopfgesteuerte Schleife while ((z % f)==0){ z/=f; i++; // Rest bei Teilung durch f // ganzzahlige Division z/f // i:=i+1 6

7 if (i>0) { sprintf(fs,"%i",f); strcat(s,fs); if (i>1){ sprintf(is,"%i%",i); strcat(s,"^"); strcat(s,is); strcat(s,"*"); // Umwandlung Zahl f in Zeichenkette fs // s und fs verketten // Umwandlung Zahl i in Zeichenkette is // Potenzzeichen anhängen // s und is verketten // Malzeichen anhängen int main(int argc, char *argv[]){ if (argc<2) {hilfe(); // keinen Kommandozeilenparameter gefunden else{ s = argv[1]; // Aufrufparameter auswerten z=atol(s); // Zeichenkette s in Zahl z umwandeln if (z==0) {hilfe(); // Umwandlung misslungen else{ strcat(s," = "); // Gleichheitszeichen anhängen f=2; spalte_ab(); // Unterprogrammaufruf f=3; // fussgesteuerte Schleife do{ spalte_ab(); // Unterprogrammaufruf f=f+2; while (f<=z); strncpy(s1,s,strlen(s)-1); // letztes Malzeichen löschen printf("\nprimzahlzerlegung:\n"); printf(" \n\n"); printf("%s\n\n",s1); system("pause"); // Damit man etwas sieht - nur unter Windows 6.2 Beispiel für kopf- und fußgesteuerte Schleifen in Fortran Programm Primfaktorenzerlegung gibt die Primfaktorzerlegung einer auf der Kommandozeile eingegeben natürlichen Zahl an gleichzeitig Beispielprogramm für kopf- und fussgesteuerte Schleifen module global globale Variable definieren implicit none save 7

8 integer :: z, f, i character(len=80) :: s end module global program primfaktoren use global integer :: NARGS, io_err NARGS = COMMAND_ARGUMENT_COUNT() if (NARGS==0) then Keinen Kommandozeilenparameter gefunden call hilfe else call GET_COMMAND_ARGUMENT(1,s) Aufrufparameter auswerten read(s,*,iostat=io_err) z Zeichenkette s in Zahl z umwandeln if (io_err /= 0) then Umwandlung misslungen call hilfe else s=trim(s) // = Verkettungsoperator f=2 call spalte_ab Unterprogrammaufruf f=3 fußgesteuerte Schleife do call spalte_ab Unterprogrammaufruf f=f+2 if (f>z) exit s=s(1:len(trim(s))-1) letztes Malzeichen löschen write(*,*) write(*,*) Primzahlzerlegung: write(*,*) write(*,*) write(*,*) s write(*,*) end if end if write(*,*) Weiter mit <1><ENTER> read(*,*) z Damit man etwas sieht end program primfaktoren subroutine hilfe write(*,*) Dieses Programm berechnet die Primfaktorzerlegung einer write(*,*) natuerlichen Zahl, die als Parameter uebergeben werden muss write(*,*) write(*,*) Beispiel: PRIMFAKT 120 write(*,*) end subroutine hilfe subroutine spalte_ab implicit none use global 8

9 character(len=20) :: fs, is i=0 kopfgesteuerte Schleife do while ((z/f)*f == z) Rest bei Teilung durch f ist 0 z=z/f ganzzahlige Division i=i+1 if (i>0) then write(fs,*) f Umwandlung Zahl f in Zeichenkette fs s=trim(s) // trim(adjustl(fs)) s und fs verketten if (i>1) then write(is,*) i s=trim(s) // ^ // trim(adjustl(is)) end if s=trim(s) // * end if end subroutine spalte_ab 6.3 Beispiel für kopf- und fußgesteuerte Schleifen in Pascal { Programm Primfaktorenzerlegung gibt die Primfaktorzerlegung einer auf der Kommandozeile eingegeben natuerlichen Zahl an gleichzeitig Beispielprogramm fuer kopf- und fussgesteuerte Schleifen program primfaktoren; uses CRT; // Unit CRT einbinden var z, f, i : longint; s : string; code : integer; procedure hilfe; writeln( Dieses Programm berechnet die Primfaktorzerlegung einer ); writeln( natürlichen Zahl, die als Parameter übergeben werden muss ); writeln; writeln( Beispiel: PRIMFAKT 120 ); writeln; procedure spalte_ab; var fs, is : string; 9

10 i:=0; // kopfgesteuerte Schleife while (z MOD f)=0 do z:=z DIV f; INC(i); if i>0 then str(f,fs); s:=s+fs; if i>1 then str(i,is); s:=s+ ^ +is; s:=s+ * ; // Rest bei Teilung durch f // ganzzahlige Division // i:=i+1 // Umwandlung Zahl f in Zeichenkette fs // in Pascal kann man Zeichenketten addieren // Hauptprogramm ClrScr; // Bildschirm löschen - benötigt unit CRT if paramcount=0 then hilfe // Keinen Kommandozeilenparameter gefunden else s:=paramstr(1); // Aufrufparameter auswerten val(s,z,code); // Zeichenkette s in Zahl z umwandeln if code>0 then hilfe // Umwandlung misslungen else s:=s+ = ; f:=2; spalte_ab; // Unterprogrammaufruf f:=3; // fuágesteuerte Schleife repeat spalte_ab; // Unterprogrammaufruf f:=f+2; until f>z; Delete(s,length(s),1); // letztes Malzeichen löschen writeln; writeln( Primzahlzerlegung: ); writeln( ); writeln; writeln(s); writeln; end writeln( Weiter mit <ENTER> ); readln; // Damit man etwas sieht end. 10