| ### Programmieren in C von Prof. Dr. Rainer Thomas

# Anweisungen

### 5.1 Überblick
5.2 "while"-Anweisung
5.3 Verbundanweisung (Block)
5.4 "if"-Anweisung
5.5 "switch"- und "break"-Anweisung
5.6 "for"-Anweisung, Komma-Operator
5.7 "do"-Anweisung
5.8 "continue"- und "goto"-Anweisung

## 5.1 Überblick

### Anweisungen in C

- Anweisungen dienen zur Formulierung des durch ein Programm zu realisierenden Algorithmus
- Anweisung
- Ausdrucksanweisung

- Leeranweisung

## 5.2 "while"-Anweisung

### Die while-Anweisung in C

- Syntaxdiagramm :

- Realisierung der abweisenden Schleife (pre-checked loop)

Solange die Auswertung des Ausdrucks einen Wert !=0 (entspr. TRUE) ergibt, wird die Anweisung (=Schleifenanweisung) ausgeführt;
hat der Ausdruck den Wert =0, so wird mit der folgenden Anweisung fortgefahren.

- Ablaufdiagramm

- Struktogrammsymbol

### Beispiel zur while-Anweisung in C

    /* ------------------------------------------------------------------- */
    /* Programm ZIFFZAHL                                                   */
    /* ------------------------------------------------------------------- */
    /* Ermittlung der Anzahl der Ziffern einer Integerzahl                 */
    /* ------------------------------------------------------------------- */

    #include <stdio.h>

    void main(void)
    {
      int zahl, stellen=1;

      printf("\nZahl ? ");
      scanf("%d",&zahl);
      while(zahl=zahl/10)
        stellen++;                      /* oder :   ++stellen; */
      printf("\n%d Stellen\n",stellen);
    }

    /* ------------------------------------------------------------------- */

Bildschirmausgabe :

    E:\RT\C\VORL>ziffzahl
    Zahl ? 32637
    5 Stellen

## 5.3 Verbundanweisung (Block)

- Verbundanweisung (Block)

Jede in das Klammerpaar { und } eingeschlossene Folge von Anweisungen. Vor den Anweisungen dürfen auch Vereinbarungen stehen (Variablenver- einbarung, Funktionsdeklaration, Typdefinition)

Die Verbundanweisung ist syntaktisch identisch mit dem Rumpf einer Funktion

Achtung : Die Verbundanweisung wird nicht mit einem ';' abgeschlossen.

- Beispiel :

    /* Programm AUSZAHL */

    /* Ausgabe der ersten n ganzen Zahlen */
    /* n wird eingelesen */

    #include <stdio.h>

    void main(void)
    {
      int n, i=1;

      printf("\nWieviel Zahlen ? ");
      scanf("%d",&n);
      while (i<=n)
      { printf("%d\n",i);                 /* Verbundanweisung */
        ++i;
      }
    }

Bildschirmausgabe :

    C>auszahl
    Wieviel Zahlen ? 6
    1
    2
    3
    4
    5
    6

## 5.4 "if"-Anweisung

### Die if-Anweisung in C

- Syntaxdiagramm :

- Realisierung der Auswahl zwischen zwei Alternativen

Wenn die Auswertung des Ausdrucks einen Wert !=0 (entspr. TRUE) ergibt, wird Anweisung1 ausgeführt; wenn der Ausdruck dagegen den Wert 0 hat (enstpr. FALSE), wird Anweisung2 (wenn else-Zweig vorhanden) bzw keine Anweisung (wenn else-Zweig nicht vorhanden) ausgeführt.

- Ablaufdiagramm

bzw.

- Struktogrammsymbol

bzw.

### Programmbeispiel zur if-Anweisung in C

    /* ------------------------------------------------------------------ */
    /* Programm COUNT1                                                    */
    /* ------------------------------------------------------------------ */
    /* Programm zaehlt Blanks und Newlines                                */
    /* Input von stdin                                                    */
    /* ------------------------------------------------------------------ */

    #include <stdio.h>

    void main(void)
    {
      int zb, zn;
      int c;

      zb=zn=0;
      while ((c=getchar()) != EOF)
      { if (c==' ')
          ++zb;
        else if (c=='\n')
          ++zn;
      }
      printf("\nZaehlergebnisse : Blanks   = %4d\n",zb);
      printf("%17s Newlines = %4d\n"," ",zn);
    }

    /* ------------------------------------------------------------------ */

Bildschirmausgabe :

    E:\RT\C\VORL>count1 <count1.c
    Zaehlergebnisse : Blanks   =   297
                      Newlines =    26

## 5.5 "switch"- und "break"-Anweisung

### Die switch-Anweisung in C

- Syntaxdiagramm :

- Realisierung der Auswahl zwischen mehr als zwei Möglichkeiten

- Der hinter switch stehende Ausdruck (Verzweigungsausdruck) muß ein ganzzahliges Ergebnis liefern (int oder char).
Der jeweils hinter "case" stehende Ausdruck darf nur konstante Operanden enthalten (konstanter Ausdruck) und muß ebenfalls ein ganzzahliges Ergebnis (Fallwert) liefern.
Alle Fallwerte müssen unterschiedlich sein, ihre Reihenfolge ist beliebig. Auch die Stellung der default-Marke ist beliebig.
- Der Verzweigungsausdruck wird ausgewertet und mit allen Fallwerten verglichen. Bei Übereinstimmung wird das Programm mit der hinter dem entsprechenden Fallwert stehenden Anweisung fortgesetzt. --> Die Fallwerte dienen als Marken für die Programmfortsetzung
Stimmt der Wert des Verzweigungsausdrucks mit keinem Fallwert über- ein, so wird das Programm

- wenn die default-Marke vorhanden ist, mit der hinter dieser Marke stehenden Anweisung fortgesetzt,
- wenn die default-Marke nicht vorhanden ist, mit der auf die switch-Anweisung folgenden Anweisung fortgesetzt.

- Eine echte Mehrfachauswahl wird durch die switch-Anweisung erst zusammen mit der break-Anweisung realisiert.

- Struktogrammsymbol

### Programmbeispiel zur switch- und break-Anweisung

    /* Programm ANTWORT1 */
    /* Demonstration der switch-Anweisung ohne break */

    #include <stdio.h>

    void main(void)
    { char zeichen;
      printf("Ihre Wahl (j,n,v) ? ");
      zeichen=getchar();

      switch (zeichen)
      { case 'j':
        case 'J': printf("ja\n");
        case 'n':
        case 'N': printf("nein\n");
        case 'v':
        case 'V': printf("vielleicht\n");
        default : printf("unbekannt\n");
      }
    }

Bildschirmausgabe:

    E:\RT\C\VORL>antwort1
    Ihre Wahl (j,n,v) ? n
    nein
    vielleicht
    unbekannt

    /* ------------------------------------------------------------------- */

    /* Programm ANTWORT2 */
    /* Demonstration der switch-Anweisung mit break */

    #include <stdio.h>

    void main(void)
    { char zeichen;
      printf("Ihre Wahl (j,n,v) ? ");
      zeichen=getchar();

      switch (zeichen)
      { case 'j':
        case 'J': printf("ja\n");
                  break;
        case 'n':
        case 'N': printf("nein\n");
                  break;
        case 'v':
        case 'V': printf("vielleicht\n");
                  break;
        default : printf("unbekannt\n");
                  break;
      }
    }

Bildschirmausgabe:

    E:\RT\C\VORL>antwort2
    Ihre Wahl (j,n,v) ? n
    nein

## 5.6 "for"-Anweisung, Komma-Operator

### Die for-Anweisung in C

- Syntaxdiagramm :

Ausdruck1 : Anfangsausdruck
Ausdruck2 : Bedingungsausdruck
Ausdruck3 : Veränderungsausdruck

- Allgemeine Formulierung :

for (Anfangsausdruck; Bedingungsausdruck; Veränderungsausdruck)
  Anweisung

- Beispiel :

    for (i=1; i<100; i++)
    printf("%d\n",i);

- Ablaufdiagramm :

- Struktogrammsymbol :

Die for-Anweisung ist aequivalent zu folgender - eine while-Anweisung enthaltende - Verbundanweisung :

    { Anfangsausdruck;
      while (Bedingungsausdruck)
      { Anweisung;
        Veraenderungsausdruck;
      }
    }

### Verschiedene Formulierungen mittels der for-Anweisung

     -------------------------------------------------------------------------

                 for (i=1; i<100; i++)
                   printf("%d\n",i);

                 for (i=1; i<100; )
                 { printf("%d\n",i);
                   i++;
                 }

                 for (i=1; i<100; )
                   printf("%d\n",i++);

                 for (i=1; i<100; printf("%d\n", i++));

                 for (i=1; i<100; printf("%d\n",i), i++);

    -------------------------------------------------------------------------

             zaehl=0;
             for (c=erstzeich; c!='\n'; zaehl++, c=getchar());

             for (zaehl=0, c=erstzeich; c!='\n'; zaehl++, c=getchar());

             zaehl=0;
             for (c=erstzeich; c!='\n'; c=getchar())
               zaehl++;

             zaehl=0;
             for (c=erstzeich; c!='\n'; )
             { zaehl++;
               c=getchar();
             }

### Der Komma-Operator in C

- binärer Operator : ,
- Der Komma-Operator verbindet zwei Ausdrücke zu - syntaktisch betrachtet - einem einzigen Ausdruck.
Er erlaubt damit die Verwendung von zwei (bzw mehreren) Ausdrücken an Stellen, an denen nur ein Ausdruck stehen darf.

Die Auswerte-Reihenfolge der beiden durch den Komma-Operator verbun- denen Teil-Ausdrücke ist festgelegt:

  Der linke Ausdruck wird zuerst ausgewertet.

Der Wert des durch den Komma-Operator gebildeten Gesamtausdrucks ist gleich dem Wert des rechten Teil-Ausdrucks
- Beispiel :

    ...
    int y;
    int x;
    y = (x=3, x+1);   /* y wird der Wert 4 zugewiesen ! */

- Präzedenz :

  geringste Priorität, noch unterhalb der Zuweisungsopera- toren
  --> die Operanden des Komma-Operators brauchen nie geklammert werden

- Anwendung :

  hauptsächlich im ersten und letzten Ausdruck des Steuerkopfes der for-Anweisung,
sowie im steuernder Ausdruck der while-Anweisung

z.B. statt :

    ...
    c=getchar();
    while (c!=EOF)
    {
      ...
      c=getchar();
    }

  eleganter :

    ...
    while (c=getchar(), c!=EOF)
    {
      ...
    }

Vorsicht vor zu häufiger, unüberlegter Anwendung des Komma-Operators :
nicht unbedingt guter Programmierstil,
Gefahr des unübersichtlichen Quellcodes.

## 5.7 "do"-Anweisung

### Die do-Anweisung in C

- Syntaxdiagramm :

- Realisierung der nichtabweisenden Schleife (post-checked loop)
Die Anweisung wird ausgeführt, solange die Auswertung des Ausdrucks einen Wert !=0 (entspr. TRUE) ergibt.
Hat der Ausdruck den Wert =0 (entspr. FALSE), so erfolgt kein weiterer Schleifendurchlauf, sondern es wird mit der folgenden Anweisung fort- gefahren.
- Beispiel :

    do
    { xalt=xneu;
      xneu=xalt-f/fstrich;
    } while (fabs(xneu-xalt)>eps);

- Ablaufdiagramm :

- Struktogrammsymbol

### Programmbeispiel zur do-Anweisung

    /* ------------------------------------------------------------------ */
    /* Programm GGT */
    /* ------------------------------------------------------------------ */
    /* Ermittlung des groessten gemeinsamen Teilers (ggT) und kleinsten   */
    /* gemeinsamen Vielfaches (kgV) zweier natuerlicher Zahlen a und b    */
    /*                                                                    */
    /* Es gilt :  kgv(a,b) = (a * b) / ggT(a,b)                           */
    /* ------------------------------------------------------------------ */

    #include <stdio.h>

    void main(void)
    {
      int a,b;
      int p,q,r;
      int ggt, kgv;

      printf("\nggT und kgV von ? ");
      scanf("%d %d",&a,&b);
      if (a>b)
      { p=a;            /* p <-- max(a,b) */
        q=b;            /* q <-- min(a,b) */
      }
      else
      { p=b;
        q=a;
      }
      do
      { r=p%q;
        p=q;
        q=r;
      }
      while (r);
      ggt=p;
      kgv=a/ggt*b;
      printf("\nggT(%d, %d) = %d\n",a,b,ggt);
      printf("kgV(%d, %d) = %d\n",a,b,kgv);
    }

    /* ------------------------------------------------------------------ */

Bildschirmausgabe :

    E:\RT\C\VORL>ggt

    ggT und kgV von ? 156 91

    ggT(156, 91) = 13
    kgV(156, 91) = 1092

## 5.8 "continue"- und "goto"-Anweisung

### Sprung-Anweisung in C

- break-Anweisung

Sprung aus einer switch-Anweisung heraus zur folgenden Anweisung, Beendigung einer Schleifenanweisung (while, for, do) unabhängig vom Abbruchkriterium

- continue-Anweisung

Sprung zum Ende des gegenwärtigen Schleifendurchlaufs,d.h.

bei while und do | : | Sprung unmittelbar zur Auswertung des Schleifenabbruchkriteriums
bei for | : | Sprung unmittelbar zur Auswertung des Veränderungsausdrucks

Beispiel :

    while (Bedingung1)
    { Anweisung1;
      if (Bedingung2) continue;
        Anweisung2;
    }

ersetzbar durch :

    while (Bedingung1)
    { Anweisung1;
      if (!Bedingung2)
        Anweisung2;
    }

bzw. durch :

    while (Bedingung1)
    { Anweisung1;
      if (Bedingung2) ;
      else Anweisung2;
    }

- goto-Anweisung

Sprung zu der durch die Marke gekennzeichneten Anweisung.

Das Sprungziel muß innerhalb der gleichen Funktion liegen.

Sprünge
  über Blockgrenzen hinweg,
  in Kontrollstrukturen (while, for, do, if, switch) hinein
  und aus Kontrollstrukturen heraus

sind zulässig.

Zum Inhaltsverzeichnis | Zum nächsten Abschnitt

###### Copyright © FH München, FB 04, Prof. Dr. Rainer Thomas
V - PC - 501 - 00 - TH - 02
V - PC - 511 - 00 - TH - 03
V - PC - 512 - 00 - TH - 05
V - PC - 521 - 00 - TH - 02
V - PC - 531 - 00 - TH - 02
V - PC - 532 - 00 - TH - 04
V - PC - 541 - 00 - TH - 04
V - PC - 542 - 00 - TH - 05
V - PC - 551 - 00 - TH - 05
V - PC - 552 - 00 - TH - 06
V - PC - 553 - 00 - TH - 02
V - PC - 561 - 00 - TH - 05
V - PC - 562 - 00 - TH - 06
V - PC - 571 - 00 - TH - 02