4.3 Verzweigungen

Die allgemeine Form der Verzweigungen (auch Alternative) ist

if ( <logischer ausdruck> )
  <anweisung_A>
else
  <anweisung_B>

und zählt ihrerseits wiederum als Anweisung. Der else -Zweig kann weggelassen werden (einfache Alternative).

Struktogramm:

Wie so oft kann ein konkretes Problem auf verschiedene Weise programmiert werden.
Beispiel: Wir betrachten dazu die Berechnung der Heaviside-Funktion

y(x) = $$\begin{cases} 1 & \quad x \ge 0 \\ 0 & \quad x < 0 \end{cases}$$

und stellen vier Varianten der Implementierung vor. (siehe Ex431.cc)

//	           Rahmenprogramm
#include <iostream.h>
main()
{
 double x,y; 
 
 cout << endl << " Input Argument      : ";
 cin  >> x; 
//                          Version a 

//                          Version b

//                          Version c

//                          Version d

}

Variante a: einfache Alternative

//	           Version a
{
 y = 0.0 ;
 if ( x >= 0. ) 
     y = 1.0 ;        // genau eine Anweisung im if-Zweig
   
 cout << " Result of version a) : " << y << endl;
}

Variante b: zweifache Alternative

//	           Version b
{
 if ( x >= 0.0 ) 
     y = 1.0 ;
 else
     y = 0.0 ;
   
 cout << " Result of version b) : " << y << endl;
}

Variante c: zweifache Alternative mit Blöcken

//	           Version c
{
 if ( x >= 0.0 ) 
   {
     y = 1.0 ;
   }
 else
   {
     y = 0.0 ;
   }
   
 cout << " Result of version c) : " << y << endl;  
}

Variante d: Entscheidungsoperator.
Treten in einer zweifachen Alternative in jedem Zweig nur je eine Wertzuweisung zur selben Variablen auf (wie in Versionen b) und c)), dann kann der Entscheidungsoperator

<log. ausdruck> ? <ausdruck_A> : <ausdruck_B>

verwendet werden.

//	           Version d
{
 y = (x >= 0) ? 1.0 : 0.0 ;
   
 cout << " Result of version d) : " << y << endl;  
}

Beispiel: Ein weiteres Beispiel ist die Berechnung der Signum-Funktion (Vorzeichenfunktion)

y(x) = $$\begin{cases} 1 & \quad x > 0 \\ 0 & \quad x = 0 \\ -1 & \quad x < 0 \end{cases}$$

und wir stellen mehrere Varianten der Implementierung vor. (siehe Ex432.cc)

Struktogramm:
Wir betrachten zwei Implementierungsvarianten, das Rahmenprogramm ist identisch zum Rahmenpogramm auf Seite .

Variante a: Schachtelung der Alternativen

//	           Version a
{
 if ( x > 0.0 ) 
   {
     y = 1.0 ;
   }
 else
   {
     if ( x == 0.0 )
       {
         y = 0.0 ;
       }
     else
       {
         y = -1.0 ;
       }
   }  
 cout << " Result of version a) : " << y << endl;
}

Variante b: Falls der else-Zweig nur aus einer weiteren if-else-Anweisung besteht, kann Variante a leicht modifiziert werden.

//	           Version b
{
 if ( x > 0.0 ) 
   {
     y = 1.0 ;
   }
 else if ( x == 0.0 )
   {
     y = 0.0 ;
   }
 else
   {
     y = -1.0 ;
   }
 
 cout << " Result of version b) : " << y << endl;  
}

Allgemein kann eine solche Mehrwegentscheidung als

if ( <logischer ausdruck_1> )
  <anweisung_1>
else if ( <logischer ausdruck_2> )
  <anweisung_2>
        ...
else if ( <logischer ausdruck_(n-1)> )
  <anweisung_(n-1)>
else
  <anweisung_n>

geschrieben werden, wobei der else-Zweig wiederum optional ist.

Beispiel: Bestimmung von Minimum und Maximum zweier einzugebender Zahlen. (siehe Ex433.cc)

Struktogramm:

//				Example: Maximum and Minimum of two numbers

#include <iostream.h>

main()
{
 int i1,i2,min,max; 
 
 cout << endl << " Input Arguments   i1 i2 : ";
 cin  >> i1 >> i2 ;

 if ( i1 < i2 ) 
   {
     min = i1 ;
     max = i2 ;
   }
 else
   {
     min = i2 ;
     max = i1 ;
   }
   
 cout << " Min,Max  (a) : " << min << " , " << max << endl;
}

Beispiel: Bestimmung des Minimums dreier einzugebender Zahlen. (siehe Ex434.cc)

Struktogramm:

//				Example: Minimum of three numbers

#include <iostream.h>

main()
{
 int i1,i2,i3,min; 
 
 cout << endl << " Input Arguments   i1 i2 i3  : ";
 cin  >> i1 >> i2 >> i3;

 if ( i1 < i2 ) 
   {
     if ( i1 < i3 )
       {
         min = i1;
       }
     else
       {
         min = i3;
       }
   }
 else
   {
     if ( i2 < i3 )
       {
         min = i2;
       }
     else
       {
         min = i3;
       }
   }  
 cout << " Min  (a) : " << min  << endl;
}