Vom Struktogramm zum
men mit der schließenden geschweiften Klammer
Programm
Ein ganz einfaches C++-Programm sieht so aus:
#include <iostream>
int main() {
std::cout << "Hallo 2BKI1!";
return 0;
} Anführungszeichen gesetzt, einzelne Zeichen
Dieses Programm besteht aus vier nicht leeren Zeilen,
die folgende Bedeutung haben:
#include <iostream> Das Hashzeichen in der er-
sten Spalte bedeutet, dass es sich um eine
Präprozessordirektive handelt. Das Schlüsselwort
include weist den Präprozessor an, den Inhalt ei-
ner Datei an diese Stelle in den Quelltext ein-
zufügen. Der Name der Datei lautet iostream und
er ist hier in ein < und ein > eingeschlossen.
Durch diese Einfügung wird uns (unter ande-
rem) ein Objekt mit dem Namen std::cout zur
Verfügung gestellt, das wir für Ausgaben (norma-
lerweise auf den Bildschirm) verwenden können.
int main() { Alle ausführbare Anweisungen müssen
in C++ in einer Funktion stehen. Daher benötigen
wir für ein Programm immer mindestens eine Funk-
tion. Die Ausführung, bei der die Ausführung ei-
nes Programms beginnt, muss zwingend den Namen
main besitzen. Wenn es also in einem Programm
nur eine Funktion gibt, dann muss diese main hei-
ßen.
Dass es sich bei main um eine Funktion han-
delt, wird dadurch erkennbar, dass auf den Na-
men ein rundes Klammerpaar folgt, das hier
leer ist. Dieses Klammerpaar ist eine leere Pa-
rameterliste. Dass die Parameterliste leer ist, be-
deutet, dass der Funktion keine Informationen
übergeben werden. Die Parameterliste könnte auch
(int nargs, char **argv) lauten, dann würde
sie zwei Elemente enthalten. Was das bedeutet, se-
hen wir später.
Der Name und die Parameterliste zusammen bilden
die Signatur der Funktion. Zwei Funktionen dürfen
den selben Namen haben, aber nicht die gleiche Si-
gnatur.
Vor dem Namen der Funktion steht der
Rückgabetyp. Er legt fest welche Art von Er-
gebnis die Funktion erzeugt. Das Schlüsselwort int
bedeutet, dass das Ergebnis eine ganze Zahl ist.
Eine Funktion, die kein Ergebnis erzeugt, bekommt
den Rückgabetyp void. Das Schlüsselwort void
kann auch verwendet werden um explizit eine leere
Parameterliste anzuzeigen, z.B. main(void).
Die öffnende geschweifte Klammer schließt zusam-
am Ende den Funktionskörper ein. In ihm stehen
die ausführbaren Anweisungen.
std::cout << "Hallo 2BKI1!"; Das Objekt
std::cout wird hier zur Ausgabe einer Zei-
chenkette verwendet. Es wird dazu mit Hilfe des
Operators << mit der Zeichenkette verknüpft. Jede
Anweisung wird in C++ mit einem Semikolon (;)
abgeschlossen, so auch diese.
Zeichenketten werden in C++ in doppelte
in einfache Anführungszeichen. Die Ausdrücke
"x" und ’x’ bedeuten einmal eine Zeichenkette
mit einem Zeichen, das ein x ist und einmal das
Zeichen x, was einen Unterschied macht (Details
kommen später).
return(0); Hier wird die Funktion (und damit das
Programm) beendet und der Rückgabewert (das
Ergebnis) festgelegt. Es ist üblich, dass ein
Rückgabewert von 0 einen fehlerfreien Ablauf si-
gnalisiert, während alle anderen Werte auf Fehler
hindeuten. Das gilt aber nur für Programme (also
die main-Funktion) nicht für andere Funktionen.
Um zu einem ausführbaren Programm zu kommen, muss
ein Struktogramm in einen Quelltext übersetzt werden.
Dabei können wir folgendermaßen vorgehen:
• Jedes Struktogramm wird in genau eine Funktion
übersetzt.
• Jede Variable, die verwendet wird muss definiert
werden. Dies geschieht am Besten direkt nach der
öffnenden Klammer des Funktionskörpers.
Eine Variablendefinition besteht aus einem Daten-
typ (für ganze Zahlen können wir int verwen-
den, wenn diese auch negativ sein können oder
unsigned, wenn sie positiv oder Null sind), dem
Namen der Variablen, die definiert werden sollen,
oder einer durch Kommata getrennten Liste von
Namen, wenn mehrere Variablen definiert werden
sollen und einem abschließenden Semikolon. Das
kann zum Beispiel so aussehen:
int x;
unsigned i, j, k;
Eine Variable enthält initial keinen bestimmten
Wert,1 sondern einfach das, was zufällig in dem zu-
gehörigen Speicher steht. Wir können Variablen je-
doch initialisieren, indem wir an den Namen ein =
und den gewünschten Wert anhängen, wie zum Bei-
spiel
int x=-1;
unsigned i=7, j, k=0;
1 Das gilt nicht für globale Variablen, die, wenn eine explizite
Initialisierung fehlt, mit 0 initialisiert werden.
 Die Variable x einhält hier initial den Wert 1, die
Variable i den Wert 7 und die Variable k den Wert
8. Die Variable j enthält zunächst einen zufälligen
Wert.
Auch Arrays können wir definieren, indem wir an
den Namen ein eckiges Klammerpaar anhängen, in
dem die Anzahl der Elemente im Array angegeben
ist. Zum Beispiel
int a[3];
Wollen wir ein Array initialisieren, so geben wir
die Werte mit Kommata getrennt in geschweiften
Klammern an. Zum Beispiel
int a[3]={1,2,3};
• Eine Zuweisung im Struktogramm übersetzen wir
in eine Zuweisung im Quelltext. Dieser besteht aus
dem Zuweisungsoperator (=, nicht wie im Strukto-
gramm :=“), links davon der Name einer Variablen
”
(z.B. x oder k) oder eines Arrayelements und auf der
rechten Seite ein Ausdruck, dessen Wert von einem
passenden Typ ist. Wir haben ja bei der Definiti-
on unserer Variablen jeweils einen Typ angegeben
und wenn wir festgelegt haben, dass die Variable
Zahlen enthalten soll, dann können wir ihr keine
Zeichenkette zuweisen.
In den Ausdrücken können die üblichen Rechenzei-
chen verwendet werden, insbesondere +, -, * (für
Multiplikation), / (für Division) und % (für die Mo-
dulooperation). Es werden im Laufe der Zeit noch
viele weitere Operatoren hinzukommen.
• Eine Ausgabe kann mit dem Objekt std::cout er-
folgen, wenn die Datei iostream zuvor eingefügt
wurde. Sie erfolgt mit dem Operator << und sie
sieht zum Beispiel so aus:
std::cout << x;
Es können mehrere Ausgaben in einer Anweisung
zusammengefasst werden. Das sieht dann so aus:
std::cout << "x=" << x << " y=" << y << "\n";
• Eine Eingabe kann (wenn die Datei iostream ein-
gefügt wurde, siehe oben) von der Tastatur aus mit
dem Objekt std::cin erfolgen. Das kann z.B. so
aussehen:
std::cin >> x;
Das Programm unterbricht dann an dieser Stelle
die Ausführung, bis eine Eingabe mit der Tasta-
tur geschrieben und mit einem Zeilenumbruch abge-
schlossen ist. Das eingegebene Datum wird dann in
der Variablen x (die existieren muss!) gespeichert.
Das Datum muss zur Variablen passen.
Es können auch mehrere Eingaben in einer Zeile
erfolgen:
std::cin >> x >> y >> z;
So werden drei Daten in der Eingaben (in einer oder
mehr Zeilen) erwartet.
Der Operator >> deutet an, dass Daten vom Objekt
std::cin zu den Variablen hin fließen, während bei
einer Ausgabe it std::cout der Operator << andeu-
tet, dass Daten zum Objekt std::cout hin fließen
(siehe oben).
• Das Programmende markiert im Quelltext ein
return-Statement. Ist der Rückgabetyp der Funk-
tion void, gibt es also kein Ergebnis, so steht das
Schlüsselwort return alleine da, gefolgt vom an-
schließenden Semikolon. Gibt es ein Ergebnis, so
wird dieses nach dem Wort return in Form eines
Ausdrucks mit einem geeigneten Wert angegeben.
Also zur Beispiel return 0;
• Ein Funktionsaufruf erfolgt in C++ durch den Na-
men der aufzurufenden Funktion, dem in runden
Klammern eine Werteliste folgt, in der für jeden
Parameter aus der Parameterliste (siehe oben) ein
Wert angegeben wird.
• Eine einfach Verzweigung wird in eine if-
Verzweigung übersetzt. Sie beginnt mit dem
Schüsselwort if, dem in runden Klammern die Be-
dingung folgt. Dies ist ein Ausdruck, dessen Wert
als Wahrheitswert interpretiert werden kann. Das
kann ein Vergleich sein, wie a==2 (beachte: in Struk-
togrammen wird eine einfaches = als Vergleichsope-
rator verwendet, bei C++ ein doppeltes) oder a>b
oder ein Ausdruck, der eine ganze Zahl ergibt. Dann
wird die 0 als false ( falsch“) und jede andere
”
Zahl als true ( wahr“) betrachtet. Der Ja-Zweig
”
wird in geschweiften Klammern angehängt. Ist der
Nein-Zweig nicht leer, so kommt nach dem Ja-Zweig
das Schlüsselwort else und danach in geschweiften
Klammern der Nein-Zweig.
Wir übersetzen also
a>0?
Ja Nein
Ausgabe a Ausgabe a
Ausgabe " ist positiv" Ausgabe " ist nicht positiv"
in den Quelltext
if(a>0) {
std::cout << a;
std::cout << " ist positiv";
} else {
std::cout << a;
std::cout << " ist nicht positiv";
}
• Mehrfachverzweigungen werden in ein switch-
Statement übersetzt. Dieses hat die Form
 switch(a) { endet am darauffolgenden Zeilenende. Die zweite Art be-
case 1: std::cout << "eins\n"; ginnt mit einem /* und endet mit */. Alles dazwischen
break; (auch Zeilenumbrüche) gehört zum Kommentar.
case 2: std::cout << "zwei\n";
break; Kommentare werden vom Präprozessor entfernt und ha-
case 3: std::cout << "drei\n"; ben auch den Programmablauf keinen Einfluss.
break;
default: std::cout << "was anderes\n";
} Beispiel

Wichtig ist, dass am Ende jeden Zweiges ein break Wir betrachten das folgende Struktogramm, das den
steht, da sonst die nachfolgenden Anweisungen Bubblesort-Algorithmus beschreibt:
ebenfalls ausgeführt werden. Bubblesort
a: array ganzer Zahlen (Übergabepara-
• Kopfgesteuerte Schleifen werden in while-Schleifen meter)
übersetzt. Diese bestehen aus dem Schlüsselwort n: Anzahl der Elemente in aliste
while, an das in runden Klammern die Abbruchbe- dummy: ganze Zahl (Hilfsvariable)
dingung angehängt wird. Der Schleifenkörper steht i = 1..n-1
danach in geschweiften Klammen. Dieser wird so k = 1..n-1
lange ausgeführt, bis die Abbruchbedingung nicht a[k-1]>a[k] ?
mehr erfüllt ist. Ja Nein
• Zählergesteuerte Schleifen werden im Quelltext dummy := a[k-1]
durch eine for-Schleife realisiert. Diese beginnt mit a[k-1] := a[k]
dem Schlüsselwort for. Danach kommt ein rundes a[k] := dummy
Klammerpaar, dessen Inhalt durch zwei Semikolon
ist drei Teile geteilt wird.
Der erste Teil wird Initialisierung“ genannt. Ob- #include <iostream>
”
wohl dort fast alle stehen darf, dient er insbeson- void bubblesort(int a[], int n) {
dere dazu der Zählvariablen den Startwert zuzu- // Wir definieren
weisen. Die Zählervariable kann hier auch definiert int dummy;
(und initialisiert) werden.
Der zweite Teil ist die Abbruchbedingung, die gleich for(int i=1; i<=n-1; i=i+1) {
funktioniert, wie bei der while-Schleife. for(int k=1; k<=n-1; k=k+1) {
if(a[k-1]>a[k]) {
Der dritte Teil heißt Inkrementierung“. Auch hier dummy = a[k-1];
”
darf auch etwas ganz anderes stehen, aber sie a[k-1] = a[k];
ist dafür gedacht, der Zählvariablen den nächsten a[k] = dummy;
Wert zuzuweisen. Dort steht also zumeist etwas wie }
i=i+1. }
Eine for-Schleife wird ausgeführt, indem zuerst die }
Initialisierung ausgeführt wird. Dann wird solan- }
ge, wie die Abbruchbedingung erfüllt ist der Schlei-
fenkörper ausgeführt und anschließend die Inkre- // Die Funktion, bei der die Ausführung beginnt
mentierung. Daraufhin wird die Abbruchbedingung // heißt immer "main".
geprüft usw. int main() {
// Wir definieren das Array mit den
• Fußgesteuerte Schleifen sind im Quelltext // Zahlen, die sortiert werden sollen:
do-while-Schleifen. Bei ihnen steht der Schlei- int a[] = {3, 2, 4, 1, 6, 8, 9};
fenkörper in geschgweifte Klammern eingeschlossen // In der Variablen n steht, wie viele
zwischen den Schlüsselwörtern do und while. Nach // Zahlen das Array a enthält.
dem while folgt in runden Klammern die Ab- int n = 7;
bruchbedingung.
// Wir rufen die Sortierfunktion auf.
Anders als in Struktogrammen, kann in Quelltext bubblesort(a, n);
erläuternder Kommentar eingefügt werden. Es ist eine
gute Idee, davon reichlich Gebrauch zu machen. for(int i=0; i<n; i=i+1) {
std::cout << a[i] << " ";
In C++ werden zwei Arten von Kommentaren unterschie- }
den: Der erste beginnt mit zwei Schrägstrichen (//) und std::cout << "\n";
}

Wir können den Quelltext mit einem einfachen Texte-

ditor schreiben und abspeichern. Dabei ist es üblich für
den Dateinamen eine der Dateiendungen .C, .cc, .c++,
.cxx oder .cpp zu verwenden. Wir nehmen im Folgen-
den an, dass der Name der Datei, in die wir unseren
Quelltext geschrieben haben bubblesort.cpp sei.

Um ein ausführbares Programm zu erstellen, benötigen

wir einen Compiler. Dies ist eigentlich nicht ganz kor-
rekt, obwohl diese Sprechweise üblich ist. Damit aus
dem Quelltext das Executable wird, muss der Quell-
text durch den Präprozessor, dessen Ergebnis durch den
Compiler, der Assemblercode daraus macht. Der Assem-
blercode wird vom Assembler in Objektcode übersetzt,
was wiederum mit Objektcode aus anderen Quellen
vom Linker zum fertigen Executable zusammengebun-
den wird.

Wir müssen uns zunächst nicht um dies Details

kümmern, da das Programm g++ alle diese Schritte zu-
sammenfassen kann. Wir starten das Programm von der
Kommandozeile aus mit dem Kommando
g++.exe -o bubblesort.exe bubblesort.cpp

Dabei legt die Angabe -o bubblesort.exe fest, dass

das Excutable in der Datei bubblesort.exe steht (bei
Windows ist die Dateinamenserweiterung .exe, bei UN-
IX haben ausführbare Dateien zumeist keine Datein-
amenserweiterung).

Nun können wir das Programm mit dem Kommando

./bubblesort.exe

starten.