Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
Vorwort des Gutachters
1 Einstieg in C
2 Das erste Programm
3 Grundlagen
4 Formatierte Ein-/Ausgabe mit »scanf()« und »printf()«
5 Basisdatentypen
6 Operatoren
7 Typumwandlung
8 Kontrollstrukturen
9 Funktionen
10 Präprozessor-Direktiven
11 Arrays
12 Zeiger (Pointer)
13 Kommandozeilenargumente
14 Dynamische Speicherverwaltung
15 Strukturen
16 Ein-/Ausgabe-Funktionen
17 Attribute von Dateien und das Arbeiten mit Verzeichnissen (nicht ANSI C)
18 Arbeiten mit variabel langen Argumentlisten – <stdarg.h>
19 Zeitroutinen
20 Weitere Headerdateien und ihre Funktionen (ANSI C)
21 Dynamische Datenstrukturen
22 Algorithmen
23 CGI mit C
24 MySQL und C
25 Netzwerkprogrammierung und Cross–Plattform-Entwicklung
26 Paralleles Rechnen
27 Sicheres Programmieren
28 Wie geht’s jetzt weiter?
A Operatoren
B Die C-Standard-Bibliothek
Stichwort

Download:
- ZIP, ca. 10,6 MB
Buch bestellen
Ihre Meinung?

Spacer
<< zurück
C von A bis Z von Jürgen Wolf
Das umfassende Handbuch
Buch: C von A bis Z

C von A bis Z
3., aktualisierte und erweiterte Auflage, geb., mit CD und Referenzkarte
1.190 S., 39,90 Euro
Galileo Computing
ISBN 978-3-8362-1411-7
Pfeil 8 Kontrollstrukturen
Pfeil 8.1 Verzweigungen mit der »if«-Bedingung
Pfeil 8.1.1 Anweisungsblock
Pfeil 8.2 Die Verzweigung mit »else if«
Pfeil 8.3 Die Verzweigung mit »else«
Pfeil 8.4 Der !-Operator (logischer Operator)
Pfeil 8.5 Logisches UND (&&) – logisches ODER (||)
Pfeil 8.6 Der Bedingungsoperator »?:«
Pfeil 8.7 Fallunterscheidung: die »switch«-Verzweigung
Pfeil 8.7.1 default
Pfeil 8.8 Die »while«-Schleife
Pfeil 8.8.1 Endlosschleife (»while«)
Pfeil 8.8.2 Fehlervermeidung bei »while«-Schleifen
Pfeil 8.9 Die »do while«-Schleife
Pfeil 8.10 Die »for«-Schleife
Pfeil 8.10.1 Einsatzmöglichkeiten der »for«-Schleife
Pfeil 8.11 Kontrollierte Sprünge
Pfeil 8.11.1 continue
Pfeil 8.11.2 break
Pfeil 8.12 Direkte Sprünge mit »goto«
Pfeil 8.13 Notationsstil
Pfeil 8.13.1 K&R-Stil
Pfeil 8.13.2 Whitesmith-Stil
Pfeil 8.13.3 Allman-Stil
Pfeil 8.13.4 GNU EMACS-Stil
Pfeil 8.13.5 Der Stil des Autors ;) (K&R-like)


Galileo Computing - Zum Seitenanfang

8.8 Die »while«-Schleife Zur nächsten ÜberschriftZur vorigen Überschrift

Mit Schleifen können Sie Anweisungsblöcke mehrfach hintereinander ausführen lassen. Das Grundgerüst der Schleifenbedingung while sieht folgendermaßen aus:

while(Bedingung == wahr) {
   /* Abarbeiten von Befehlen, bis Bedingung ungleich wahr */
}

Ist die Bedingung, die in den Klammern nach while folgt, wahr, so wird der Anweisungsblock in geschwungenen Klammern (oft auch »curly brackets« genannt) ausgeführt. Diese Anweisungen werden so oft ausgeführt, bis die Bedingung in den Klammern falsch, also unwahr ist. Den zugehörigen Programmablaufplan sehen Sie in Abbildung 8.9.

Üblicherweise läuft die while-Schleife in drei Schritten ab:

  • Initialisierung – Die Schleifenvariable bekommt einen Wert.
  • Bedingung – Die Schleifenvariable wird daraufhin überprüft, ob eine bestimmte Bedingung bereits erfüllt ist.
  • Reinitialisieren – Die Schleifenvariable erhält einen anderen Wert.

Abbildung 8.9 Programmablaufplan der »while«-Schleife

In der Praxis sieht dies etwa so aus:

int var=0;           // Initialisieren
while(var < 10) {    // Solange var kleiner als 10 - Bedingung
      // weitere Anweisungen
      var++;         // Reinitialisieren
   }

Jetzt folgt ein Listing mit einer while-Schleife:

/* while1.c */
#include <stdio.h>

int main(void) {
   int zahl=1, tmp=0;

   while(zahl <= 10) {
      tmp=tmp+zahl;
      printf("%d+",zahl++);     /* Zahl + 1 */
   }
   printf("\b = %d\n",tmp);
   return 0;
}

Das Programm führt die while-Schleife so lange aus, bis die Variable zahl kleiner oder gleich 10 ist. Hier ein kurzer Durchgang des Programms Schritt für Schritt:

while(zahl<=10)

Ist die Zahl kleiner oder gleich 10? Die Zahl hat den Wert 1, also wird in den Anweisungsblock gesprungen. Hier wird zuerst die Addition tmp=tmp+zahl durchgeführt. Somit ist der Wert von tmp 1. Jetzt wird die Variable zahl um 1 erhöht (zahl++). Der while-Anweisungsblock endet, und das Programm springt zurück zum Anfang der while-Anweisung. Es erfolgt eine erneute Überprüfung daraufhin, ob die Zahl immer noch kleiner oder gleich 10 ist. Da sie jetzt den Wert 2 hat, geht es wie vorher schon im Anweisungsblock weiter. Das wird so lange wiederholt, bis zahl den Wert 11 erreicht hat. Denn dann ist die Bedingung, ob zahl kleiner oder gleich 10 ist, falsch (unwahr). Das Programm läuft nach dem while-Anweisungsblock weiter und gibt das Ergebnis 55 aus.


Galileo Computing - Zum Seitenanfang

8.8.1 Endlosschleife (»while«) Zur nächsten ÜberschriftZur vorigen Überschrift

Die while-Schleife wird oft absichtlich in Form einer Endlosschleife implementiert. Für das Beenden einer Endlosschleife sorgt dann nicht die Schleifenbedingung, sondern das Schlüsselwort break. Mit der break-Anweisung können Sie die Schleife jederzeit verlassen. Hier sehen Sie ein Beispiel für eine Endlosschleife:

/* while2.c */
#include <stdio.h>

int main(void) {
   int zahl, summe=0;
   printf("Summenberechnung\nBeenden der Eingabe mit 0 \n");

   while(1) {    /* Endlosschleife, denn: 1 ist immer wahr */
      printf("Bitte Wert eingeben > ");
      scanf("%d", &zahl);
      if(zahl == 0)    /*  Haben wir 0 eingegeben ...?   */
         break;        /* ... dann raus aus der Schleife */
      else
         summe+=zahl;
   }
   printf("Die Summe aller Werte beträgt: %d\n", summe);
   return 0;
}

Die Zeile

while(1)

verkörpert die Endlosschleife. Der Inhalt dieser Schleife ist immer wahr, da Sie hier den Wert 1 haben. Sie könnten dort jede beliebige Zahl außer 0 hinschreiben. Sie haben in den vorangegangenen Kapiteln gesehen, dass 1 (und alle anderen Werte ungleich 0) für »wahr« (true) und 0 für »unwahr« (false) steht.

Zurück zu dem Programm. Sie werden so lange aufgefordert, eine Zahl einzugeben, bis Sie den Wert 0 verwenden:

if(zahl == 0)    /*  Falls 0 eingegeben wurde ... */
   break;        /*  ... dann Schleife verlassen  */

Hat die Variable zahl den Wert 0, wird mit der Anweisung break aus dem Anweisungsblock herausgesprungen.


Galileo Computing - Zum Seitenanfang

8.8.2 Fehlervermeidung bei »while«-Schleifen topZur vorigen Überschrift

Natürlich können Sie mit Schleifen auch diverse Fehler machen. Im Folgenden sollen daher einige häufig auftretende Fehler angesprochen werden.

Schließen Sie eine Schleife niemals mit einem Semikolon ab. Folgendes Beispiel erzeugt ungewollt eine Endlosschleife:

int x=0;
while(x > 10); /* Fehler durch Semikolon am Ende */
   {
      printf("Der Wert von x beträgt %d\n", x);
      x++;
   }

Die Variable x wird niemals im Anweisungsblock inkrementiert werden, da die while-Schleife nichts anderes tut, als ständig die Bedingung zu prüfen, ob x größer als 10 ist.

Vermeiden Sie außerdem – wenn möglich – Überprüfungen auf Gleichheit in den Schleifen:

int x=2;
while(x == 10) {
   printf("Der Wert von x beträgt %d \n", x);
   x*=x;
}

Die Bedingung der while-Schleife wird nie erfüllt. Verwenden Sie in einem solchen Fall besser die Überprüfung auf kleiner oder gleich, etwa wie folgt:

while(x <= 10)

Eine weitere Fehlerquelle können die logischen Operatoren in der while-Schleife darstellen, wie das folgende Programmbeispiel verdeutlicht:

/* while3.c */
#include <stdio.h>

int main(void) {
   int zahl1=0, zahl2=0;
   while((zahl1++ < 5) || (zahl2++ < 5) )
      printf("Wert von zahl1: %d zahl2: %d \n ", zahl1, zahl2);
   return 0;
}

Da hier der erste Ausdruck fünfmal wahr ist, wird wegen des logischen ODER-Operators der zweite Ausdruck nicht ausgewertet. Erst dann, wenn der erste Ausdruck unwahr, also 5 ist, wird der zweite Ausdruck fünfmal durchlaufen. Als Nebeneffekt wird aber gleichzeitig der erste Ausdruck bei jedem Schleifendurchlauf inkrementiert. Und so kommt es, dass die Variable zahl1 am Ende den Wert 10 hat, statt 5 wie ursprünglich beabsichtigt.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.






<< zurück
  
  Zum Katalog
Zum Katalog: C von A bis Z

 C von A bis Z
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchtipps
Zum Katalog: Einstieg in C++






 Einstieg in C++


Zum Katalog: C++ von A bis Z






 C++ von A bis Z


Zum Katalog: C/C++






 C/C++


Zum Katalog: Shell-Programmierung






 Shell-Programmierung


Zum Katalog: Linux-UNIX-Programmierung






 Linux-UNIX-
 Programmierung


Zum Katalog: IT-Handbuch für Fachinformatiker






 IT-Handbuch für
 Fachinformatiker


Zum Katalog: Ubuntu GNU/Linux






 Ubuntu GNU/Linux


Zum Katalog: Coding for Fun







 Coding for Fun 


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Galileo Press 2009
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Galileo Computing]

Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de