# Struktogramme
- auch als Nassi-Shneiderman-Diagramme bekannt
- Ziel: Darstellung eines Programms unabhängig von der Programmiersprache
- Symbole
- mit Hilfe dieser Symbole lässt sich der Ablauf eines Programms beschreiben
- fast alle Symbole lassen sich beliebig ineinander verschachteln
- Prozess Symbol / Process Symbol: Anweisungen werden nacheinander von oben nach unten durchlaufen
[](https://doku.stnd.io/uploads/images/gallery/2022-03/pixhl4Yo2jpg8Ov7-strukto-01.png)
```Python
# Anweisungen in Python
a = input("Zahl eingaben") # Anweisung 1
b = 5 * a # Anweisung 2
print(b) # Anweisung 3
```
- Verzweigung / Decision Symbol: Bedingung wird geprüft, wenn Sie zu trifft wird "ja" ausgeführt, andernfalls "nein". Kann verschachtelt sein.
[](https://doku.stnd.io/uploads/images/gallery/2022-03/gvYl603MA5H936Ho-strukto-02.png)
```Python
# Verzweigung in Python
if (a == 5): # Prüfung der Variablen a -> Ergebnis True oder False
print("a ist fünf") # Wenn Prüfung True, wird dieser Block ausgeführt
else:
print("a ist nicht fünf") # Wenn Prüfung False, wird dieser Block ausgeführt
```
- - - Sonderfall: Case-Statement: Inhalt der Variablen wird geprüft und entsprechender Fall wird ausgeführt. Manche Programmiersprachen haben "Switch" ansonsten mit "if - else if - else" auflösbar.
[](https://doku.stnd.io/uploads/images/gallery/2022-03/ecQYhnONAKJo06oR-strukto-03.png)
```C
// Mit Switch in C aufgelöst
case (a) { // Angabe welche Variable geprüft werden soll
1: printf("a hat den Wert eins"); // Auswahl entsprechend der Prüfung
2: printf("a hat den Wert zwei");
3: printf("a hat den Wert drei");
default: print("a ist größer drei"); // Sollte keine Prüfung zutreffen wird dieser Fall ausgeführt
};
// Mit if - else if - else aufgelöst
if (a == 1) { // Prüfung der Variable a -> Ergebnis True / False
printf("a hat den Wert eins"); // Block der True als Ergebnis hat wird ausgeführt
} else if (a == 2) {
printf("a hat den Wert zwei");
} else if (a == 3) {
printf("a hat den Wert drei");
} else {
printf("a ist größer drei"); // Wird ausgeführt sollte kein Block True sein
};
```
- Schleifen oder Wiederholungsstruktur: Struktur die solange durchlaufen wird, bis Endbedingung erfüllt ist
- Kopfgesteuerte - Schleifen (z.B. while und for): Bedingung wird vor ersten durchlauf geprüft und nur dann betretten, wenn Bedingung zutrifft. Kann also auch nicht durchlaufen werden, wenn Endbedingung direkt zutrifft.
[](https://doku.stnd.io/uploads/images/gallery/2022-03/WpMcaVsAHg34X2LD-strukto-05.png)
```C
// Kopfgesteuerte while-Schleife
while (i <= 10) { // Die Variable i wird geprüft, sollte sie bereits größer 10 sein, wird Schleife nicht ausgeführt
printf("%i\n", i); // Wird ausgeführt sollte i kleiner oder gleich 10 sein
i++;
}
// Kopfgesteuerte for-Schleife
for (i = 0; i <= 10; i++) { // Sonderfall i läuft von 0 bis 10
printf("%i\n", i);
}
```
- Fußgesteuerte - Schleife (z.B. do-while): Endbedingung wird nach dem ersten Durchlauf geprüft und wenn diese Zutrifft, wird die Schleife beendet. Sollte sie nicht zu treffen, wird die Schleife solange durchlaufen bis die Bedingung zutrifft.
[](https://doku.stnd.io/uploads/images/gallery/2022-03/XyB8ocUs3ZOLng6V-strukto-06.png)
```C
// Fussgesteuerte-Schleife
do { // Schleife wird betretten
printf("%i\n", a); // Schleife wird ausgeführt
a++;
} while (a <= 10); // Prüfung und sollte a größer 10 sein, wird Schleife beendet. Ansonsten wird Schleife erneut ausgeführt
```
- Funktion und Funktionsaufruf: Um nicht mehrfach den gleichen Code schreiben zu müssen, kann man Funktionen schreiben die man immer wieder aufrufen kann. Dazu muss man zwei Dinge beachten.
Zum Einen muss die Funktion aufgerufen werden ggf. Parameter übergeben werden. Zum Anderen wird die Funktion als eigenes Struktogram geschrieben und am Anfang die möglichen Übergabeparamet genannt.
Sollte die Funktion Rückgabeparameter haben sind diese mit **Rückgabe** zu markieren (nicht Ausgabe).
- Funktionsaufruf
[](https://doku.stnd.io/uploads/images/gallery/2022-04/D7f4xut8JU7Wjad0-aufruf.png)
```C
// Möglicher Funktionsaufruf in C
// Funktionsdefinition
int berechne(int zahl1, int zahl2) { // Funktion bekommt zwei Integer übergeben und gibt einen Integer zurück
int ergebnis; // lokale Variable
ergebnis = zahl1 + zahl2; // Berechnung von ergebnis
return ergebnis; // Rückgabewert
}
//Hauptfunktion
void main(void) {
int a; // Deklaration von Variablen
int b;
int c;
a = 4; // Zuweisung von Wert an Variable
b = 5;
c = ergebnis(a, b); // Aufruf von Funktion "berechne" Übergabeparameter sind Werte von a, b. Rückgabe von Funktion wird zugewiesen
printf("%i\n", c); // Ausgabe von c
}
```
- Beispiel Code als Struktogramme dargestellt. Hauptfunktion (main) und aufgerufene Funktion (berechne)
[](https://doku.stnd.io/uploads/images/gallery/2022-04/iC4uAluPxuRuKTEJ-main.png) [](https://doku.stnd.io/uploads/images/gallery/2022-04/p8K3WBHvfHwWYR0W-main-funktion.png)