[Inhalt][0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17]

Willkommen beim fünften Teil des C-Kurses!

Diesmal befassen wir uns mit Bedingungen, Schleifen und bedingten Anweisungen.Doch bevor wir uns mit Schleifen und anderen Dingen beschäftign, sollten wir uns erstmal fragen, wie bvergleicht man denn Werte ?
 
Bedingungen / Vergleiche

Möchte man feststellen, ob eine Variable einer bestimmten Bedingung genügt, so muß man einen Vergleich anstellen. In der folgenden Tabelle wird auch angegeben, welche Bedingung erfüllt sein muß, damit ein Ausruck als wahr interpretiert wird.
 

== gleich
beide Ausdrücke sind gleich
!= ungleich
beide Ausdrücke sind nicht gleich
> größer 
der erste Ausdruck ist größer als der zweite
>= größer oder gleich
der erste Ausdruck ist größer oder gleich dem zweiten
< kleiner
der erste Ausdruck ist kleiner als der zweite
=< kleiner oder gleich
der erste Ausdruck ist kleiner oder gleich dem zweiten
&& logisches und
beide Ausdrücke müssen wahr sein
|| logisches oder
einer der Ausdrücke muß wahr sein
! Negation
der folgende Ausdruck muß falsch sein.

Hier gibt es Prioritäten zu beachten, wenn man Bedingungen aneinanderreiht.Generell gilt aber, das man lieber zuviel als zuwenig klammern sollte, da sonst der Überblick verloren geht und man verzweifelt versucht einen Fehler zu finden.
 

< , <= , > , >= hat Vorrang vor == , != hat Vorrang vor && , ||

Anhand eines kleinen Beispiels sollten evetuell noch vorhandene Fragezeichen beseitigt werden.
Wenn man folgende Bedingung hat

if ( a < b  &&  b < c )

so wird erst geprüft ob a<b ist und danach, ob b<cist. Im folgenden gehen wir einmal Schritt für Schritt durch, wie der obere Ausdruck mittels if (mehr zu if im Anschluß) geprüft wird. fettgedruckt sind die Ausdrücke die geprüft werden. Die Ergebnisse der geprüften Ausdrücke (wahr oder falsch) sind unterstrichen. Nehmen wir mal an, das gilt
 

a = 1
b = 2
c = 3

dann wird der Reihenfolge der Prioritäten nach der Ausdruck abgearbeitet.
 

if ( a < b  &&  b < c ) {...}
if ( wahr  &&  b < c ) {...}
if ( wahr  &&  wahr ) {...}
if ( wahr ) {...}

Wie wir sehen, ist es aber leicht möglich Fehler zu machen, daher nochmal der Ratschlag: Zuviel Klammern schadet nie! Nun gehen wir ein bischen näher auf den Negationsoperator ein, der auf den ersten Blick schwer zu verstehen ist, aber bei dem nach einem Beispiel die berühmten Schuppen von den Augen fallen.
 

if ( ! ( a == b ) ) {...}
if ( ! ( falsch ) ) {...}
if ( wahr ) {...}

Wir werden späteren noch ein kleines Programm schreiben, wo wir alle Bedingungen durchtesten. Doch erstmal zu den Schleifen.
 
Schleifen:

Prinzipiell gibt es zwei Arten von Schleifen: Die vorprüfenden und die nachprüfenden Schleifen. Die vorprüfenden Schleifen prüfen vor dem Schleifenkörper und die nachprüfenden Schleifen nach dem Schleifenkörper, ob eine Bedingung wahr ist. Nachprüfende Schleifen haben einen Nachteil: Die Schleife wird mindestens einmal abgearbeitet, da erst nach dem abarbeiten des Schleifenkörpers geprüft wird, ob Bedingungen wahr sind oder nicht. Wenn der Schleifenkörper aus einem Befehl besteht, können die geschweiften Klammern weggelassen werden. Alle folgenden Beispielprogramme sollten das gleiche Ausgeben

Screenshot des ausgeführten Programms

Vor einer Falle sollte unbedingt gewarnt werden: Wenn bei einer Bedingung eine Zuweisung erfolgt, so wird diese immer als wahr interpretiert (wenn diese korrekt vorgenommen wurde). Folgendes Beispiel wird also in einer Endlosschleife hängen bleiben.
 

#include <stdio.h>

void main ( void) 
{

int i = 0; 

/* Endlosschleife! */
while ( i = 2)
{

printf ( "i = %d\n",i ); 
i=i+1; 
}
}

Das passiert häufig, wenn man statt der Abfrage auf Gleichheit = = eine Zuweisung mit = vornimmt.
 
 
while

 
 

while ( Bedingung )
    { Schleifenkörper }

Der Schleifenkörper wird solange wiederholt, solange die Bedingung erfüllt ist. Die Prüfung der Bedingung erfolgt immer vor der Ausführung des Schleifenkörpers.

Beispiel:
 

#include <stdio.h>

void main ( void) 
{

int i = 0; 
while ( i <= 10 )
{
printf ( "i = %d\n",i ); 
i=i+1; 
}
}

Der Schleifenkörper wird nun solange durchlaufen, bis die Bedingung nicht mehr wahr ist, d.h. bis i > 10 ist. Hier wird vor jedem Durchgang geprüft, ob die Bedingung zutrifft.
 
 
do

 

do
    { Schleifenkörper } 
while ( Bedingung );

Hier gilt das selbe, wie bei der while-Schleifen. Im Gegensatz zu while wird hier nach der Ausführung des Schleifenkörpers die Bedingung geprüft wird, ob ein erneutes durchlaufen der Schleife nötig ist. Man muß immer beachten: Hinter dem while [Bedingung] steht immer ein Semikolon!

Beispiel:
 

#include <stdio.h>

void main ( void) 
{

int i= 0; 

do
{

printf ( "i = %d\n",i ); 
i=i+1;
}
while ( i <= 10 );
}

 
 
for

 
for (  Initialisierung  ;  Bedingung  ;  Anweisung  ) 
    { Schleifenkörper }

Bei einer for-Schleife wird zuerst die Initialisierung abgearbeitet. Solgange die Bedingung wahr ist, wird der Schleifenkörper und anschließend die Anweisung ausgeführt. Danach wird wieder die Bedingung geprüft, und so weiter.Sieht alles sehr kryptisch aus. Also schreiben wir das ganze etwas um und erhalten als equivalent folgenden Ausdruck:
 

Initialisierung; 

while ( Bedingung )
{ 

    Schleifenkörper; 
    Anweisung; 
}

Man könnte meinen eine for-Schleife ist eine getarnte while-Schleife. Beim compilieren werden beide auch gleich behandelt, aber nach einiger Zeit ist meistens einem for lieber, da man weniger schreben muß.
 

#include <stdio.h>

void main ( void) 
{

int i= 0; 

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

}

Hier haben wir den Eingangssatz angewendet das, wenn der Schleifenkörper aus einem Befehl besteht, die geschweiften Klammern wegfallen können. Oberes Beispiel ist, wenn wir unsere Erläuterung einer for-Schleife anschauen, das Selbe wie das Beispiel der while-Schleife. Nur etwas kürzer :-) Zur besseren Veranschaulichung wurden die Teile mit gleicher Farbei eingefärbt, die einander entsprechen.
 
 

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

 
 
continue

Die Anweisung continue innerhalb einer Schleife dient dazu, den Schleifenkörper nicht weiter abzuarbeiten und direkt zum Vergleich zu springen. Bei while und do-while Schleifen wird sofort in den while-Vergleich gesprungen. Eine Sonderheit gibt es bei for-Schleifen, diese werden neu-initialisiert. Bei dem Beispiel wird das im weiteren erklärte if-statement benutzt.
 
break

Der Befehl dient zum Verlassen des Schleifenkörpers, in dem break ausgeführt wird, bzw. der switch-Anweisung. Bei dem Beispiel wird das im weiteren erklärte if-statement benutzt.
 
Bedingte Anweisungen

Im Gegensatz zu den Schleifen, wo ein Schleifenkörper solange abgearbeitet wird, solange die Bedingung wahr ist, wird in bedingten Anweisungen die Anweisung einmal abgearbeitet, wenn die Bedingung wahr ist. Bei vergleichen bitte immer auf die Variablentypen achten!
 
 
if

 

if ( Bedingung ) 
    { Körper1 }
else
    { Körper2 }

Wenn die Bedingung wahr ist, wird der Befehls-Körper1 abgearbeitet. Wenn die Bedingung nicht zutrifft wird die Alternative im Befehls-Körper2 abgearbeitet.
Natürlich kann man das else weglassen, dann wird keine Alternative ausgeführt.

Beispiel:
 

#include <stdio.h>

void main (void)
{
int t=2;

if ( t == 2 ) 
{
printf ( "\nHallo, t ist 2\n");
printf ( ".... wirklich :-)\n\n");
}
}

Screenshot des ausgeführten Programms

...oder als 2. Beispiel ....
 

#include <stdio.h>

void main (void)
{
int t=1;

if ( t == 2 ) 
{
printf ( "\nHallo, t ist 2\n");
printf ( ".... wirklich :-)\n\n");
}
else
{
printf ( "\nSchade...\n");
printf ( " ... t ist nicht 2\n");
}
}

Warum das Doppel-Gleichzeichen ? Ein einfaches Gleichzeichen ist immer eine Zuweisung, z.B. b = 3. Würde nun in der Klammer t = 2 stehen, so würde t erst der Wert 2 zugeordnet werden und dann eine Überprüfung auf wahr erfolgen, der ist bei positiven Werten ungleich Null immer wahr! Wird ein Vergleich angestellt muß nun ein Doppel-Gleichzeichen stehen!
 
 
 
if & else if

Jetzt steht natürlich die Frage im Raum, was ist, wenn man mehrere Abfragen kombinieren will ? Als eine Methode empfiehlt sich der Gebrauch von else if-Konstrukten.
 

if ( Bedingung1 ) 
    { Körper1 }
else if ( Bedingung2 )
    { Körper2 }
else
    { Körper3 }

Hier wird erst die erste Bedingung Bedingung1 geprüft. Trifft diese nicht zu, wird die zweite geprüft. Wenn Bedingung2 zutrifft, so wird der Körper2 ausgeführt. Trifft keine der Bedingungen zu, so wirde der Befehls-Körper3 ausgeführt.Wer schon einmal in einer anderen Sprache programmiert hat, z.B. Basic, der kenn die if-then Befehle. In C wurde das then einfach weggelassen. Zu beachten ist: Wird eine Bedingung auseführt, so werden die anderen alternativen Fälle ignoriert.

Beispiel:
 

#include <stdio.h>

void main (void)
{
int t=3;

if ( t == 1 ) 

printf ( "\n t = 1 \n" ); 
else if ( t == 2 ) 
printf ( "\n t = 2 \n");
else
printf ("\n t ist weder 1 noch 2\n\n");
}

Screenshot des ausgeführten Programms

Wie Eingangs versprochen noch ein kleines Beispielprogramm, um die verschiedenen Bedingungen näher kennenzulernen.
 

#include <stdio.h>

void main (void)
{

 int a, b;

/* einlesen von a und b */
 printf("\n a = ");
 scanf("%d",&a);

 printf("\n b = ");
 scanf("%d",&b);

/* Bedingungen testen */
 if (a == b) 
  printf ("\na ist gleich b\n");

 if (a < b) 
  printf ("\na ist kleiner als b\n");

 if (a <= b) 
  printf ("\na ist kleiner oder gleich b\n");

 if (a > b) 
  printf ("\na ist groesser als b\n");

 if (a >= b) 
  printf ("\na ist groesser oder gleich b\n");

 if (a != b) 
  printf ("\na ist ungleich b\n");

 if (! (a<b) ) 
  printf ("\na ist nicht kleiner als b\n");

}

Setzen wir nun für a = 3 und für b = 2 ein, so würden wir z.B. folgende Ausgaben des Programms erhalten.

Screenshot des ausgeführten Programms

Als kleine Übung einfach ein bischen mit den Fallunterscheidungen herumspielen und auch auf andere Variablentypen anwenden, oder experimentieren sie auch ein bischen mit dem logischen und ( && ) oder dem logischen oder ( || ) herum. Da es ja auch nicht nur Zahlen gibt, sondern auch Zeichenketten, müßte es doch auch so etwas geben, um Zeichenketten zu vergleichen. Gibt es auch, jedoch werden wir später darauf eingehen. Man kann sich jetzt natürlich vorstellen, das es etwas ermüdend sein kann, wenn man sehr viele Fallunterscheidungen machen will, ob eine Variable nun diesen oder jenen Wert besitzt. Auch für solche Probleme wurde gesorgt....
 
 
 
switch & case

 

switch ( Variable ) 

{ 

    case Term1: 
      Aktion1; 
      break; 
    case Term2 : 
      Aktion2;
      break;
    default:
      Aktion3; 
}

Hier wird eine Variable auf Gleichheit untersucht. Mit der switch-Anweisung gibt man die zu untersuchende Variable an. Als erstes wird geprüft ob die Variable dem Term1 entspricht, wenn ja, so wird Aktion1 ausgeführt. Diese können beliebeig viele sein. Abgeschlossen werden die Aktionen mit einem break! Wie wir ja schon vorher lernten, verlassen wir mit break die switch-case Block. Solange kein break auftritt werden alle weiteren Befehle abgearbeitet. Danach wird der nächste Vergleich angestellt, u.s.w. Hinter dem Schlüsselwort default steht kein Vergleich, da diese Aktionen ausgeführt werden, wenn sich keine Übereinstimmungen in den oberen Fällen ergab. Also ein Default-Anweisung, solange kein anderer Fall eintritt. Da dieser als letztes aufgerufen wird, benötigt man hier keine break-Anweisung.
 

#include <stdio.h>

void main (void)
{

char i = 'x'; 

switch ( i )
{

    case 'a' :
      printf ( "\n i = a \n" );
      break;
    case 'b' : 
      printf ( "\n i = b \n" );
      printf ( "Schade :-(\n" );
      break;
    default:
      printf ( "\n i war weder a noch b \n"); 
      printf ( "\n ...ist aber nicht so schlimm :-)\n");
}
}

Screenshot des ausgeführten Programms

War ein bischen viel Theorie auf einmal, oder ? Am besten versucht man zu jeder Schleifenart ein kleines Beispielprogramm zu schreiben.
 
 
 
Übungsaufgabe

1) Schreiben sie ein Programm, welches eine eingegebene Zahl als Wortlaut auf den Bildschirm ausgibt. Z.B.:
 

Eingabe => 5 

Ausgabe => fuenf

2) Schreiben sie je ein Programm mit den verschiedenen Schleifentypen,. die die Zahlen von 2 bis 7 auf dem Bildschirm ausgeben und überlegen sie auch, woher bestimmte Überraschungen herrühren könnten.



[Inhalt][0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17]