Schleifen und eindimensionale Felder

Transkript

1 Schleifen und eindimensionale Felder Die Grundelemente der strukturierten Programmierung sind Aktionen und die Zusammenfassung von Aktionen (unsere Blöcke), Entscheidungen (aus dem letzten Kapitel) und Wiederholungen. Beim Wort Wiederholung denkt man zuerst an Befehle, die wiederholt ausgeführt werden. Es lassen sich aber auch Daten wiederholen. Dies führt uns zum Begriff der (eindimensionalen) Felder. Felder Als Feld bezeichnet man eine definierte Anzahl von Variablen, die alle den gleichen Datentyp haben und unter einem einzigen Namen angelegt werden. Solche Felder (engl. array/vector) wollen wir dann mit Hilfe einer Schleife bearbeiten. Legen wir zuerst einmal ein Feld an. (Bild 8-1) Genau wie einfache Variablen (auch Skalare genannt) können Felder global oder lokal angelegt werden. Jedes einzelne Element ist eine Variable für sich. Sie kann wie gewohnt gelesen und beschrieben werden. Eine bestimmte Variable wird mit Hilfe einer ganzen Zahl, dem Index, ausgewählt. Die Kombination aus dem Feldnamen und dem Index in eckigen Klammern beschreibt genau eine Variable. Der Index (lat. Zeigefinger) beginnt immer bei Null (0). Die Abbildung 1 Feldaufbau höchstmögliche Zahl ist eins kleiner als die Gesamtzahl an Elementen. In unserem Fall haben wir vier (4) Elemente im Feld. Daher ist der größte zulässige Index drei (3). Der Index wird beim Zugriff auf ein Feld nicht überprüft. Eine Überprüfung würde ein sogenanntes Laufzeitsystem notwendig machen. Da der Index berechnet werden kann, ergibt sich erst beim Ablauf die Fehlerbedingung. Die Reaktion auf den Fehler müßte dann auch während der Laufzeit erfolgen. Der Index muß stets ganzzahlig sein. Felder werden bei der Programmierung häufig benutzt, um zusammenhängende Daten aufzunehmen. In C benutzt man Felder auch, um Texte zu speichern. Da es keinen eigenen Datentyp string gibt, werden Texte in Feldern aus char gespeichert. Und noch etwas soll im Vorgrifff auf die Adreßrechnung angemerkt werden. Der Feldname allein, also ohne Klammern und Index, steht für die Startadresse des Feldes. Funktionen, die Texte bearbeiten, erwarten als Parameter normalerweise solche Startadressen. Es ist daher möglich, an puts() nicht nur Textkonstante zu übergeben, Schleifen und Felder

2 sondern auch Felder, in denen Texte stehen. Initialisierung von Feldern Ein Feld kann bei der Definition mit Initialisierungswerten vorbesetzt werden. Bei K&R- Compilern konnten nur globale Variablen initialisiert werden, bei ANSI-C-Compilern auch lokale. In beiden Fällen des Bildes 8-2 wurden nicht für alle Variablen der Felder Initialisierungswerte angegeben. Die Inhalte der nicht explizit initialisierten Feldvariablen sind bei lokalen Feldern undefiniert, bei globalen Feldern werden sie mit 0" vorbelegt. Das Vorbelegen geschieht beim Laden des Programmes durch das Betriebssystem. Sollten Sie keinen Lader benutzen, weil Sie Ihr C"-Programm in einem ROM oder EPROM ablegen, dann sind die Inhalte aller globalen Variablen undefiniert. 1 /* Felder und Initialisierung */ 2 /* feld1.c */ 3 #include <stdio.h> 4 int main () 5 { 6 char text[100] = "Guten Morgen"; 7 int werte[10] = { 0,1,2,3,4,5,6,7,8 }; 8 char vokale[] = { A, E, I, O, U }; 9 10 fputs("\x1b[2j",stdout);/*ansi Steuerung*/ 11 printf("anzahl Vokale: %d\n",sizeof(vokale)); 12 puts (text); 13 return 0; 14 } Abbildung 2 Initialisierung Aufzählungen von Werten für die Initialisierung werden in geschweiften Klammern geschrieben. Bei der Initialisierung mit Textkonstanten werden so viele char -Variablen vorbelegt wie der Text Buchstaben besitzt. Die Endekennung für Texte ( \0 ) wird mit übernommen. In Zeile 10 rufen wir fputs() mit dem Feldnamen, also der Startadresse. Schleifen-Grundtypen Die Schleifen sind ein Schlüsselelement jeder Programmiersprache. Jeder Editor läuft in einer Schleife, wartet auf den nächsten Tastendruck und bearbeitet ihn. Ein mathematisches Programm läuft in einer Schleife und verbessert sein Ergebnis, bis der Fehler ausreichend klein ist. Oder ein Buchhaltungsprogramm in einer Bank durchläuft immer wieder die gleichen Operationen, bis alle Überweisungen des Tages erledigt wurden. Ein Schleife besteht aus: einem Test, ob die Schleife weiter durchlaufen werden soll, und einem Schleifenkörper, der die Arbeit macht. Ein Test kann entweder: eine bestimmte Anzahl von Durchläufen abprüfen oder einen bestimmte Endebedingung testen. Eine Schleife, die den Bildschirm dadurch löschen möchte, daß sie 25 Zeilenvorschübe Schleifen und Felder

3 ausgibt, kennt von vornherein die Anzahl der notwendigen Durchläufe. Das Gegenstück ist eine Schleife, die von einer Tastatur solange Zeichen einliest und verarbeitet, bis der Benutzer die ESC-Taste drückt. Hier läuft die Schleife unterschiedlich oft. Ein Test kann außerdem: vor dem Schleifenkörper angeordnet sein oder dahinter. Steht der Test vor dem Schleifenkörper, kann es passieren, daß die Schleife überhaupt nicht ausgeführt wird, da schon vorher der Test negativ ausfällt. Die minimale Durchlaufzahl ist hier einfach 0. Steht der Test am Ende, so wird die Schleife minimal einmal durchlaufen. Je nachdem, ob wir den Test vor dem Schleifenkörper durchführen oder danach, erhalten wir mit den beiden möglichen Testarten vier unterschiedliche Schleifenarten. Test am Anfang, Zähler Test am Anfang, Endebedingung Test am Ende, Zähler Test am Ende, Endebedingung. Schleifen in C In C gibt es keine Zählschleifen, sondern nur Bedingungsschleifen. Aber da es sehr einfach ist, Zählschleifen mit Hilfe einer Bedingung zu formulieren, sind auch solche Schleifen in C problemlos aufzubauen. C kennt drei Arten. Die grundlegende Schleife mit dem Test am Anfang ist die while - Schleife. Den Test am Ende hat die do-while -Schleife. Und schließlich gibt es noch eine Variante der while -Schleife, die besonders für abzählbare Schleifendurchläufe geeignet ist, die for -Schleife. Eine Schleife wird immer von einem Schlüsselwort eingeleitet. Der Test steht stets in einem runden Klammerpaar, und der Schleifenkörper besteht immer nur aus einer syntaktischen Anweisung. Dabei kann eine syntaktische Anweisung entweder eine einzelne Anweisung, eine Anweisungsliste oder ein Block sein. Die while -Schleife Die while -Schleife ist der klassische Fall einer Bedingungsschleife mit dem Test am Anfang. Der Schleifenkörper wird solange durchlaufen, wie der boole sche Ausdruck den Wert wahr liefert. Wir benötigen eine wahre Ablaufbedindung für die Schleife. Schleifen und Felder

4 Abbildung 3 Aufbau der while-schleife Die verschiedenen Möglichkeiten der while -Schleife können wir in den folgenden Beispielen sehen. Geben wir zuerst die berechneten Zahlen von 1 bis 9 aus. Der Test prüft den Wert einer Variablen ob der Endwert noch nicht erreicht ist. Falls der Test mit Ja beantwortet wird, wird der Schleifenkörper ausgeführt. Nach der Ausführung geht die Schleife wieder zum Test zurück. Bei einem Nein setzt man das Programm hinter dem Schleifenkörper fort. 1 /* Test der while Schleife */ 2 /* while1.c */ 3 #include <stdio.h> 4 int main () 5 { 6 int i; 7 i = 0; 8 puts ("\x1b[2jwhile - Schleife\n"); 9 while ( i << 10 ) 10 { 11 i = i +1; 12 printf ( "Variable i ist nun: %d\n", i); 13 } 14 return 0; 15 } Abbildung 4 Einfache while-schleife Ein anderes für die while -Schleife typisches Beispiel, ist die Textausgabe. (Bild 8-5) Wenn wir nicht wissen oder nicht zählen wollen, wie lang der Text in einem Textpuffer ist, dann bearbeiten wir alle Zeichen, bis wir eine Endekennung ( \0 ) finden. Schleifen und Felder

5 1 /* Texte und while Schleife */ 2 /* while2.c */ 3 #include <stdio.h> 4 int main () 5 { 6 char textfeld[100]= "Guten Morgen"; 7 int i = 0; 8 puts ("\x1b[2jwhile-schleife und Text\n"); 9 while ( textfeld[i]!= \0 ) 10 { 11 putchar (textfeld[i]); 12 i = i +1; 13 } 14 putchar( \n ); 15 return 0; 16 } Abbildung 5 Ausgabe eines Textes mit "while" Die for -Schleife Eine Variation der while-schleife stellt die for -Schleife dar. Sie wird besonders für Zählzwecke verwendet. Der Kern der for -Schleife ist wieder eine while -Schleife, die aber durch einen eigenen Initialisierungteil und einen Weiterschaltteil ergänzt wurde. In der for -Schleife finden wir häufig Anweisungslisten im Initialisierungsteil und im Weiterschaltteil. Diese Aufteilung erlaubt eine übersichtliche Programmierung, da alle Anweisungen, die den Ablauf der Schleife beeinflussen, in runden Klanmmern zusammengefaßt sind. for -Schleifen können Sie gelegentlich in einer eigentümlichen Form finden. Da beim Ablauf der Schleifenkörper und der Weiterschaltteil zusammen ausgeführt werden, kann man immer wieder for - Schleifen finden, deren Schleifenkörper leer Abbildung 6 Aufbau der "for"-schleife ist. Selbst wenn im eigentlichen Schleifenkörper nichts mehr zu tun bleibt, muß er trotzdem vorhanden sein. Ein einzelnes Komma, eine leere Anweisung genügt. Dies ist auch ein immer wieder auftretender Fehler bei C -Programmen. Schreibt man hinter die runden Klammern ein überflüssiges Komma, dann wird die Schleife nur diese leere Anweisung wiederholen. Schleifen und Felder

6 Löschen wir in dem folgenden Beispiel (Bild 8-7) den Bildschirm dadurch, daß wir 25 Leerzeilen ausgeben. Durch das Scrollen sollte danach der Bildschirm gelöscht sein. 1 /* for Schleife */ 2 /* for.c */ 3 #include <stdio.h> 4 int main() 5 { 6 int i; 7 for (i = 0; i << 25; i = i+1) 8 putchar ( \n ); 9 return 0; 10 } 11 Abbildung 7 Bildschirm löschen mit "for" Felder und die for -Schleife Felder bestehen aus einer festen, bekannten Anzahl von Variablen. Daher eignet sich zur Bearbeitung von Feldern insbesondere die for -Schleife, da sie als Ersatz für eine Zählschleife entwickelt wurde. 1 /* for Schleife mit Feld */ 2 /* forfeld.c */ 3 #include <stdio.h> 4 int main() 5 { 6 int i; 7 int ifeld[20]; 8 for (i = 0; i << 20; i = i+1) 9 ifeld[i] = i; 10 for (i = 0; i << 20; i = i+1) 11 printf ("\nfeldinhalt %d",ifeld[i]); 12 return 0; 13 } 14 Abbildung 8 Feldbearbeitung mit der "for"-schleife Im Beispiel legen wir ein Feld bekannter Größe an. Diese Größe verwenden wir dann in zwei for -Schleifen. Die erste schreibt in jede Variable des Feldes einen Wert (hier: den Index) und die zweite gibt diesen Wert mit einem Kommentar in einer Zeile aus. Die do-while Schleife Die einzige Schleife in C, die den Test nach dem Schleifenkörper durchführt, ist die dowhile -Schleife. Die Schleife wird mit dem Schlüsselwort do eingeleitet. Danach folgt der Schleifenkörper, der wieder nur aus einer einzigen Anweisung bestehen darf. Gerade bei do-while ist diese Regel gewöhnungsbedürftig, da man annehmen könnte, daß do und das nachfolgende while den Schleifenkörper eindeutig bestimmen müßten. Schleifen und Felder

7 Ein typischer Anwendungsfall für do-while -Schleifen ist die Berechnung von mathematischen Funktionen und Werten. Als Beispiel soll die Eulersche Zahl e, die Basis der natürlichen Logarithmen, dienen. Interessant ist hier, daß sich diese Konstante durch eine sogenannte Reihenentwicklung berechnen läßt. Mit jedem Element, das wir in der Reihe neu berechnen, nähern wir uns dem richtigen Ergebnis an. Die Schleife brechen wir ab, wenn ein neues Element nur noch geringfügig vom Vorgänger unterscheidet. Die Formel ist: e = 1 + 1/1! + 1/2! + 1/3!... Das Ausrufungszeiche n darf nicht mit dem C-Operator verwechselt werden und bedeutet Fakultät. 3! = 1* 2 * 3 ist also die Multiplikation aller Zahlen die kleiner oder gleich der Abbildung 9 Schleife mit Test am Ende - "do..while" angegebenen sind. (Sollten Sie keine große Lust auf Mathematik haben... es ist nur ein kleines Beispiel.) Die Variablen müssen vom Typ double sein, damit die größtmögliche Genauigkeit erreicht wird. Dies gilt auch für die konstanten Initialisierungswerte, die als Fließkommakonstante angegeben sind. Schleifen und Felder

8 1 /* Schleifen: Berechnung von e */ 2 /* nlogbasb.c */ 3 #include <stdio.h> 4 int main () 5 { 6 double e = 1.0; 7 double faktor = 1.0; 8 double e_alt = 1.0; 9 double i = 2.0; puts ("\x1b[2j"); 12 puts ("Berechnung von e\n"); 13 do 14 { 15 e_alt = e; 16 e = e / faktor; 17 faktor = faktor * i; 18 i = i + 1.0; 19 } 20 while (e - e_alt >> ); 21 printf ("\ne ist: %f", e); 22 return 0; 23 } Abbildung 10 Anwendung einer Bedingungsschleife Alle Taschenrechner arbeiten übrigens ähnlich. Wenn Sie einen Sinus, Cosinus oder eine Wurzel berechnen lassen, dann laufen intern solche Schleifen ab. Endlosschleifen Eine Sonderform der Schleifen sind die Endllosschleifen. Anwendungsfälle für Endlosschleifen gibt es z. B. in der Hauptsteuerschleife des Programmes. In main() könnte dieses Schleife immer wieder die Eingaben des Benutzers abfragen, die gewünschte Tätigkeit durchführen und dann wieder zur Eingabe zurückkehren. Nur wenn der Benutzer den Abbruch des Programmes wünscht, würde die Schleife mit break verlassen. Endlosschleifen programmiert man mit einer stets wahren Ablaufbedingung. In der while -Schleife genügt ein Wert ungleich 0, da damit ja wahr dargestellt wird. while (1) { Anweisungen; } Abbildung 11 Endlosschleife mit "while" In der for -Schleife läßt man die Abfrage einfach aus. Ein nicht durchgeführter Test wird als wahr angenommen.. Schleifen und Felder

9 for ( i = 0; ; i++) { Anweisungen; } Abbildung 12 Endlosschleife mit "for" Strukturierte Sprünge Die Schleifen sind Programmkonstrukte, die man gelegentlich vorzeitig verlassen will. Entdecken wir im Schleifenkörper eine Bedingung, die ein weiteres Verbleiben in der Schleife überflüssig macht, dann wäre es schön, wenn wir herausspringen könnten. Für solche Fälle kennt C zwei unterschiedliche, strukturierte Sprünge. Einen davon haben wir schon bei der Fallunterscheidung kennen gelernt: break. Dieses break springt unmittelbar hinter das Ende der momentanen Steuerstruktur. Wir können break in vier Fällen benutzen: in einer der drei Schleifen oder in der Fallunterscheidung. Eine etwas andere Situation liegt vor, wenn wir nur den Schleifenkörper abbrechen wollen und wieder zum Test der Schleife gehen möchten. Für diesen Fall kennt C den strukturierten Sprung continue. Dieser Sprung kann nur innerhalb der drei Schleifen benutzt werden. Schleifen und Fallunterscheidung ein Beispiel Unsere Möglichkeiten, Programme zu schreiben, sind mit den nun bekannten Schleifen, Entscheidungen und Feldern viel größer geworden. Schauen wir uns daher ein Beispiel an, das alle diese Programmkonstrukte zusammen verwendet. Die Tastatur soll zu einem Keyboard für Musik umfunktioniert werden. Die Idee ist, daß mit dem Drücken der Taste a ein Ton von 440 Hertz erklingen soll. Dieser Ton ist der Kammerton (Referenzton). Ausgehend von diesem Ton können wir uns alle andere Töne einer Oktave berechnen. Mit den berechneten Frequenzen füllen wir eine Tabelle aus 12 Variablen, die die 12 Halbtöne aufnimmt. In einer Schleife liest das Programm den jeweils nächsten Tastendruck und benutzt die Fallunterscheidung, um herauszufinden, ob es eine bekannte Taste war. In einer ersten Stufe wollen wir nur die acht Töne der c-dur-tonleiter benutzen. Leider läßt sich dieses Beispiel so einfach nur unter DOS realisieren. Die Bibliotheken unter UNIX unterstützen den Tongenerator nicht. Vielleicht ist das bei Ihrem System anders. Zuerst benötigen wir mehrere Informationsdateien. Die bekannte stdio.h beschreibt die standardisierten Ein-/Ausgabefunktionen. Um jeden Tastendruck sofort zu erhalten, verwenden wir eine DOS spezifische Funktion getch(). Diese Funktion ist in conio.h deklariert. Schließlich holen wir uns noch die dos.h für die Funktion clrscr() und auch die math.h, weil wir die Exponentialfunktion pow() brauchen. Das Feld für die Notenwerte wird global angelegt. Es wäre aber auch problemlos lokal anzulegen. Die main() -Funktion bereit nun die Werte auf, die das Programm verlangt. Danach bleiben wir dann solange in einer Schleife, bis der Benutzer abbricht. Schleifen und Felder

10 Nach dem Löschen des Bildschirms berechnen wir zuerst die Konstante, die uns von Halbton zu Halbton bringt. (Sie können die Erklärung der Berechnung ohnes weiteres überspringen.) Von Oktave zu Oktave verdoppelt sich die Frequenz eines Tones und innerhalb einer Oktave gibt es 12 Halbtöne. Da sich jeder Halbton vom Vorgänger durch die Multiplikation mit einer festen Konstanten ermitteln läßt, ergibt sich die Konstante als 12. Wurzel aus 2. Abbildung 13 Notenwerte Diese Rechnung macht die Zeile 20. Die Konstante kon ist das Ergebnis der Exponentialfunktion pow(), die die 2.0 hoch 1/12 berechnet. Ist der Exponent ein Bruch, dann berechnet man die Wurzel. Wichtig ist, daß hier die Konstanten alle Fließkommakonstanten vom Typ double sind. Der einzige Frequenzwert, den wir kennen müssen, ist der Kammerton a mit Hertz. Diesen Wert tragen wir in die Tabelle ein und berechnen die anderen Werte in zwei Schleifen. Die eine füllt die oberen Einträge, die andere die unteren. Die höheren Töne ermitteln wir durch Multiplikation, die niederen durch Division mit der Konstanten. Nach dieser Vorarbeit können wir in einer Schleife die Tasten des Benutzers einlesen, in einer Fallunterscheidung verarbeiten und dann den gewünschten Ton ausgeben. Um das Programm nicht zu groß werden zu lassen, wurde eine feste Tondauer gewählt. Das Programm eignet sich auch zum Experimentieren recht gut. Doch nun tippen Sie einmal die folgenden Tasten: e e f g g f e d c c d e e d d Aufgaben: Erweitern Sie das Programm um die Halbtöne. Ein Halbton soll an der Tastenkombination CTRL+Ton erkannt werden. Verwenden Sie konstante Ausdrücke, um die Steuerzeichen darzustellen. Definieren Sie mit Hilfe eines Aufzählungstyps (enum Ihr-Typ) die Konstanten für die 12 Halbtöne. Wenn Sie eine Konstante mit dem Namen cis definieren, dann können Sie diese Konstanten in einer case -Marke benutzen. Das Programm wird dadurch lesbarer. Im nächsten Kapitel Mit den Schleifen haben wir die dritte Gruppe der Abläufe (und die letzte) kennengelernt. Im folgenden Kapitel wollen wir uns nun der Gliederung eines Programmes zuwenden. Die wichtigste Methode, ein großes Programm in verständliche Teile zu unterteilen, bieten die Funktionen. Sie erinnern sich: in C steht alles in Funktionen. Schleifen und Felder

11 1 /* Tonerzeugung in einer Oktave */ 2 /* ohne Halbtöne, NUR DOS */ 3 /* Datei: musik.c */ 4 #include <stdio.h> /* printf() */ 5 #include <conio.h> /* getch() */ 6 #include <dos.h> /* clrscr() */ 7 #include <math.h> /* pow() */ 9 double noten[12]; /* 12 Töne/Okt. */ 11 int main () 12 { 13 int c; 14 double kon,note; 16 /* Bildschirm löschen, 17 Konstante berechnen 18 und Notenfeld aufbauen */ 19 clrscr(); 20 kon = pow (2.0, (1.0/12.0)); 21 printf ("\nc- Syntax: Fallunterscheidung:"); 22 printf ("\nmusikmaschine mit 1 Oktave"); 23 printf ("\nbenutzen Sie cdefgahc."); 24 printf ("\n ESC bricht ab. \n"); 25 printf ("\nversion 1.1\n"); 27 /* Noten für 12 Halbtöne */ 28 noten[9] = 440.0; /* Kammerton a */ 29 for (c = 10; c <<12; c++) 30 noten[c] = noten[c-1] * kon; 31 for (c = 8; c >>= 0; c--) 32 noten[c] = noten[c+1] / kon; 34 /* Schleife zur Tastaturabfrage */ 35 /* getch() liest Zeichen ungepuffert ein */ 36 while ((c = getch())!= '\x1b') 37 { 38 switch (c) 39 { 40 case 'c': note = noten[0]; break; 41 case 'd': note = noten[2]; break; 42 case 'e': note = noten[4]; break; 43 case 'f': note = noten[5]; break; 44 case 'g': note = noten[7]; break; 45 case 'a': note = noten[9]; break; 46 case 'h': note = noten[11]; break; 47 case 'C': note = noten[0]*2; break; 48 default: note = 0.0; break; 49 } 50 putchar ('\n'); 51 printf ("\rfrequenz: %f",note); 52 sound (note); /* Ton ein mit Freq. */ 53 delay(150); /* Tondauer */ 54 nosound(); /* Wieder abschalten */ 55 } 56 return 0; 57 } Abbildung 14 Die Tastatur als Keyboard Schleifen und Felder

12 Schleifen und Felder