AuD Styleguide C++

Hallo zusammen!
AuD Styleguide C++
Hallo zusammen!
Wie viele von euch bereits gemerkt haben, gibt es diverse Dinge in C++ Quellcode, die keinen Einfluss
auf die Ausführung des Programms haben, aber in den Beispiellösungen trotzdem strikt eingehalten
Wie viele von euch bereits gemerkt haben, gibt es diverse Dinge in C++ Quellcode, die keinen Einfluss
wurden. Das sind z.B. Einrückung und Kommentare. Auch wenn diese Dinge das eigentliche
auf die Ausführung des Programms haben, aber in den Beispiellösungen trotzdem strikt eingehalten
Programm nicht verändern, haben sie trotzdem einen Zweck.
wurden. Das sind z.B. Einrückung und Kommentare. Auch wenn diese Dinge das eigentliche
Programm
Beim nicht von
Schreiben verändern, haben erfahrene
Code achten sie trotzdem einen Zweck.
Programmierer auf den sogenannten “Codestil”. Meist
gibt es für jede Sprache oder für jedes Projekt einen “Styleguide”, der vorschreibt, wie der Code
Beim Schreiben von Code achten erfahrene Programmierer auf den sogenannten “Codestil”. Meist
aussehen soll. Diese Regeln sollt ihr immer in eurem Code einhalten. Zwei Wochen nach Beginn des
gibt es für jede Sprache oder für jedes Projekt einen “Styleguide”, der vorschreibt, wie der Code
Semesters werden diese bei euren Abgaben verpflichtend; entsprechend wird es zu deutlichem
aussehen soll. Diese Regeln sollt ihr immer in eurem Code einhalten. Zwei Wochen nach Beginn des
Punkteabzug bei Nichteinhaltung kommen. Aber wir sind uns sicher, dass ihr diese einfachen Regeln
Semesters werden diese bei euren Abgaben verpflichtend; entsprechend wird es zu deutlichem
ohne Probleme einhalten könnt.
Punkteabzug bei Nichteinhaltung kommen. Aber wir sind uns sicher, dass ihr diese einfachen Regeln
ohne
Es Probleme
gibt einhalten
viele gute Gründe,könnt.
warum man solche Regeln einhalten sollte ;-) Später werden
Programmierer, die die grundlegenden Regeln nicht beherrschen, komisch beäugt.
Es gibt viele gute Gründe, warum man solche Regeln einhalten sollte ;-) Später werden
Programmierer, die die grundlegenden Regeln nicht beherrschen, komisch beäugt.

Teil 1: Einrücken
Mit dem Begriff “Einrücken” bezeichnet man den Vorgang, eine Zeile im Code mit einer gewissen
Teil 1: Einrücken
Anzahl von Whitespace anfängt, sodass die Zeile visuell weiter rechts steht. Beispiel:
Mit dem Begriff “Einrücken” bezeichnet man den Vorgang, eine Zeile im Code mit einer gewissen
Anzahl von Whitespace anfängt, sodass die Zeile visuell weiter rechts steht. Beispiel:
1 // Ich bin nicht eingerückt
2 // Ich bin zwei Leerzeichen eingerückt (ein "Level")
1
3 // Ich bin nicht eingerückt
// Ich bin vier Leerzeichen eingerückt (zwei Level)
2
4 // Ich bin zwei Leerzeichen eingerückt (ein "Level")
// Ich bin wieder nicht (also kein Level) eingerückt
3 // Ich bin vier Leerzeichen eingerückt (zwei Level)
4 // Ich bin wieder nicht (also kein Level) eingerückt
Durch richtiges Einrücken kann man sehr schnell Teile des Codes identifizieren, die zusammen
gehören. Wir sprechen hierbei von sogenannten “Blöcken”. Ein Block ist quasi: Code, der zwischen
Durch richtiges Einrücken kann man sehr schnell Teile des Codes identifizieren, die zusammen
geschweiften Klammern steht. Beispiel:
gehören. Wir sprechen hierbei von sogenannten “Blöcken”. Ein Block ist quasi: Code, der zwischen
geschweiften Klammern steht. Beispiel:
1 if (x == 5) {
2 cout << "Hallo ";
1
3 if (x ==
cout << 5) {<< endl;
x
2
4 cout
} << "Hallo ";
3 cout << x << endl;
4 }
Hier sehen wir einen Block, der zwei Anweisungen ( cout << "Hallo" und cout << x << endl )
enthält. Wie euch hier schon direkt auffällt: Die beiden Anweisungen in dem Block sind ein Level
Hier sehen wir einen Block, der zwei Anweisungen ( cout << "Hallo" und cout << x << endl )
weiter eingerückt, als das if .
enthält. Wie euch hier schon direkt auffällt: Die beiden Anweisungen in dem Block sind ein Level
weiter
Und eingerückt,
das als das
ist auch schon if
die .
Hauptregel: Der
Inhalt
eines
Blocks
wird
ein
Level
mehr
eingerückt
als
die
Zeile,
in
der
der
Block
anfängt.
Und das ist auch schon die Hauptregel: Der
Inhalt
eines
Blocks
wird
ein
Level
mehr
eingerückt
Gucken wir uns dazu dieses Beispiel (mit
als
die
Zeile,
in
der
der
Block
anfängt . vielen Kommentaren) an:

Gucken wir uns dazu dieses Beispiel (mit vielen Kommentaren) an:
 1 // Hier sind wir noch 0 Level eingerückt...
2 int x = 2;
1
3 // Hier sind wir noch 0 Level eingerückt...
2
4 int x = 2;
// Auch die `for`-Schleife selber ist weiterhin 0 Level eingerückt. Aber
3
5 // Vorsicht: Die `for` Schleife beginnt gleich einen neuen Block!
4
6 // Auch die `for`-Schleife selber ist weiterhin 0 Level eingerückt. Aber
for (int i = 0; i < 5; i++) {
5
7 // Vorsicht: Die `for` Schleife beginnt gleich einen neuen Block!
// Die `for` Schleife hat einen neuen Block angefangen! Der Inhalt
6
8 for (int i = 0; i < 5; i++) {
// dieses Blocks (also das, was von der Schleife wiederholt wird), wird
7
9 // Die `for` Schleife hat einen neuen Block angefangen! Der Inhalt
// um ein Level weiter eingerückt (also 1 Level, weil wir vorher 0
8
10
// dieses Blocks (also das, was von der Schleife wiederholt wird), wird
// Level eingerückt waren)
9
11
// um ein Level weiter eingerückt (also 1 Level, weil wir vorher 0
int z = x;
10
12
// Level eingerückt waren)
11
13
int z = x;
// Das `if` selber ist weiterhin um 1 Level eingerückt, aber
12
14
// gleich beginnt ein neuer Block!
13
15
// Das `if` selber ist weiterhin um 1 Level eingerückt, aber
if (i % z == 0) {
14
16 // gleich beginnt ein neuer Block!
// Wir sind in einem weiteren Block, also rücken wir jetzt ein
15
17 if
(i % z == 0) {
// Level mehr ein, als zuvor. Also jetzt 2 Level!
16
18 // Wir sind in einem weiteren Block, also rücken wir jetzt ein
cout << "Hallo" << endl;
17
19
} // Level mehr ein, als zuvor. Also jetzt 2 Level!
18
20 cout
<< "Hallo" << endl;
19
21 }
// Wir haben den Block vom `if` wieder verlassen. D.h. wir sind
20
22
// jetzt nur noch im Block der `for`-Schleife, welcher ja 1 Level
21
23
// Wir haben den Block vom `if` wieder verlassen. D.h. wir sind
// eingerückt ist.
22
24 // jetzt nur noch im Block der `for`-Schleife, welcher ja 1 Level
cout << "tzzzz" << endl;
23
25
} // eingerückt ist.
24
26 cout << "tzzzz" << endl;
25
27 }
// Nun haben wir auch den Block der `for`-Schleife verlassen und
26
28 // rücken jetzt wieder 0 Level ein.
27
29 // Nun haben wir auch den Block der `for`-Schleife verlassen und
cout << "Tschüss" << endl;
28 // rücken jetzt wieder 0 Level ein.
29 cout << "Tschüss" << endl;
Dadurch dass man jetzt sehr schnell sehen kann, auf welchem Einrückungs-Level eine Anweisung
steht, kann man sie sehr schnell einem Block im Kopf zuordnen.
Dadurch dass man jetzt sehr schnell sehen kann, auf welchem Einrückungs-Level eine Anweisung
steht, kann
Natürlich maninsie
steht sehr C++
echten schnell einem Block
Programmen beiimLevel
Kopf0zuordnen.
nie eine for -Schleife, sondern immer nur
#include ... , using ... und die Hauptoperation ( int main( ... ) ). Hier nochmal ein
Natürlich steht in echten C++ Programmen bei Level 0 nie eine for -Schleife, sondern immer nur
vollständiges Beispiel:
#include ... , using ... und die Hauptoperation ( int main( ... ) ). Hier nochmal ein
vollständiges Beispiel:
1 #include <iostream>
2 using namespace std;
1
3 #include <iostream>
2
4 using namespace
int main () { std;
3
5
4
6 int main
int x (=)

2{;
5
7
6
8
int
for x = 2
(int ; = 0; i < 5; i++) {
i
7
9
int z = x;
8
10 for (int i = 0; i < 5; i++) {

9
11
int
if z
(i = % x
z ;== 0) {
10
12
cout << "Hallo" << endl;
11
13
if
} (i % z == 0) {
12
14 cout
<< "Hallo" << endl;
13
15 }
cout << "tzzzz" << endl;
14
16
}
15
17 cout
<< "tzzzz" << endl;
16
18 }
cout << "Tschüss" << endl;
17
19
return 0;
18
20 cout
} << "Tschüss" << endl;
19 return 0;
20 }
Es ist also auch wichtig, den ganzen Inhalt von int main( ... ) { ... } ein Level weiter
einzurücken. Und den Inhalt jedes weiteren Blocks ebenfalls ein Level weiter.
Es ist also auch wichtig, den ganzen Inhalt von int main( ... ) { ... } ein Level weiter
einzurücken. Und den Inhalt jedes weiteren Blocks ebenfalls ein Level weiter.
Ein weiterer kleiner Hinweis: Kommentare werden immer so eingerückt wie die Zeile unter dem
Kommentar.
Ein weiterer kleiner Hinweis: Kommentare werden immer so eingerückt wie die Zeile unter dem
Kommentar.
Einrücken in Qt Creator
Qt Creator vereinfacht das Einrücken sehr: Sobald man einen neuen Block anfängt, fängt die nächste
Einrücken in Qt Creator
Zeile direkt ein Level weiter eingerückt an. Aber an diversen Stellen kommt es vor, dass ihr manuell
Qt Creator vereinfacht das Einrücken sehr: Sobald man einen neuen Block anfängt, fängt die nächste
einrücken müsst. Natürlich kann man hier die Leertaste so oft drücken, bis jede Zeile eingerückt ist; es
Zeile direkt ein Level weiter eingerückt an. Aber an diversen Stellen kommt es vor, dass ihr manuell
gibt aber ein paar Tricks:
einrücken müsst. Natürlich kann man hier die Leertaste so oft drücken, bis jede Zeile eingerückt ist; es
gibt aber ein paar Tricks:

Mit der Taste [Tab] (siehe oben) kann man in Qt Creator eine Zeile direkt um ein Level weiter
einrücken.
Mit der Taste [Tab] (siehe oben) kann man in Qt Creator eine Zeile direkt um ein Level weiter
Mit der Kombination [Shift] + [Tab] kann man eine Zeile um ein Level weniger einrücken.
einrücken.
Ihr könnt auch mehrere Zeilen markieren (z.B. mit der Maus) und dann [Tab] oder [Shift] +
Mit der Kombination [Shift] + [Tab] kann man eine Zeile um ein Level weniger einrücken.
[Tab] drücken, um alle markierten Zeilen auf einmal um ein Level mehr oder weniger
Ihr könnt auch mehrere Zeilen markieren (z.B. mit der Maus) und dann [Tab] oder [Shift] +
einzurücken.
[Tab] drücken, um alle markierten Zeilen auf einmal um ein Level mehr oder weniger
einzurücken.
Negativ-Beispiele
Wir schauen uns hier mal ein paar Negativ-Beispiele an, damit ihr mal seht, wie man es nicht machen
Negativ-Beispiele
sollte.
Wir schauen uns hier mal ein paar Negativ-Beispiele an, damit ihr mal seht, wie man es nicht machen
sollte. : Gar nicht eingerückt.
Falsch

Falsch: Gar nicht eingerückt.

1 if (a != 0) {
2 a = 7;
1
3 if (a
cout !=
<< 0) { << endl;
"Hallo"
2
4 a
} = 7;
3 cout << "Hallo" << endl;
4 }
Falsch: Anweisungen im selben Block unterschiedlich weit eingerückt.

Falsch: Anweisungen im selben Block unterschiedlich weit eingerückt.

1 int a = 4;
2 a++;
1
3 int a
int = 4
b =; 7;
2
4 a++ ;
int c = a + b;
3
5 int b = 7;<< "derp" << endl;
cout
4 int c = a + b;
5 cout << "derp" << endl;
Falsch: Kommentar falsch eingerückt.

Falsch: Kommentar falsch eingerückt.

1 if (x > 5) {
2 // Ausgabe von x
1
3 if (x >
cout 5) x
<< { << endl;
2
4 // Ausgabe von x
}
3 cout << x << endl;
4 }

Schließende geschweifte Klammer

Falsch: Schließende geschweifte Klammer zu weit eingerückt.
Schließende geschweifte Klammer
Falsch: Schließende geschweifte Klammer zu weit eingerückt.
 1 if (a != 0) {
2 a = 7;
1
3 if (a !=
cout 0
<< ) {
"Hallo" << endl;
2
4 a
} = 7;
3 cout << "Hallo" << endl;
4 }
Falsch: Schließende geschweifte Klammer nicht in eigener Zeile.

Falsch: Schließende geschweifte Klammer nicht in eigener Zeile.

1 if (x < 0) {
2 x = 3;
1
3 if
} (x <
cout 0) x
<< { << endl; // Neue Zeile nach `}` anfangen!
2 x = 3;
3 } cout << x << endl; // Neue Zeile nach `}` anfangen!
Ausnahme: Auf eine schließende geschweifte Klammer darf in der selben Zeile nur while (...) der
do-while Schleife, else oder else if (...) folgen. Sonst ist } immer alleine in der Zeile.
Ausnahme: Auf eine schließende geschweifte Klammer darf in der selben Zeile nur while (...) der
Korrektes Beispiel:
do-while Schleife, else oder else if (...) folgen. Sonst ist } immer alleine in der Zeile.
Korrektes Beispiel:
1 if (x < 0) {
2 x = 3;
1
3 if (x <
} else
{0) {
2
4 x = 3
x = x ; + 9;
3
5 }
} else {
4 x = x + 9;
5 }

Öffnende geschweifte Klammer

Richtig: Öffnende geschweifte Klammer in der gleichen Zeile wie das if , for , while , …
Öffnende geschweifte Klammer
Richtig: Öffnende geschweifte Klammer in der gleichen Zeile wie das if , for , while , …
1 if (a != 0) {
2 cout << "hi" << endl;
1
3 if (a != 0) {
}
2 cout << "hi" << endl;
3 }
Falsch: Öffnende geschweifte Klammer in neuer Zeile. (Diese Position der öffnenden geschweiften
Klammer ist eigentlich nicht falsch, wird aber in AuD nicht verwendet!)
Falsch: Öffnende geschweifte Klammer in neuer Zeile. (Diese Position der öffnenden geschweiften
Klammer ist eigentlich nicht falsch, wird aber in AuD nicht verwendet!)
1 if (a != 0)
2 {
1
3 if (a !=
cout << 0
) << endl;
"hi"
2
4 {
}
3 cout << "hi" << endl;
4 }

Wie viel einrücken?

Was genau ist jetzt ein “Level” beim Einrücken? Sehr verbreitet ist es, mit 2 Leerzeichen (Spaces)
Wie viel einrücken?
oder mit 4 Leerzeichen einzurücken. In allen Beispielen oben entspricht ein Level zwei Leerzeichen.
Was genau ist jetzt ein “Level” beim Einrücken? Sehr verbreitet ist es, mit 2 Leerzeichen (Spaces)
oder mit
Über 4 Leerzeichen
dieses Thema gibteinzurücken. In allen
es verschiedene Beispielendas
Meinungen, oben entspricht
wichtige ein Level
ist jedoch: zwei Leerzeichen.
Solange man innerhalb
eines Programms konsistent vorgeht, also jedes Level mit gleich vielen Leerzeichen einrückt, ist das
Über dieses Thema gibt es verschiedene Meinungen, das wichtige ist jedoch: Solange man innerhalb
ok! Nur ein Leerzeichen reicht als Einrückung pro Level nicht aus.
eines Programms konsistent vorgeht, also jedes Level mit gleich vielen Leerzeichen einrückt, ist das
ok!
TippNur
: In ein Leerzeichen
Qt Creator könntreicht
ihr inals
denEinrückung pro für
Einstellungen Level
dennicht aus. unter Verhalten die Einrücktiefe
Texteditor
für die Taste [Tab] einstellen. Die Standardeinstellung ist auf 4 gesetzt.
Tipp: In Qt Creator könnt ihr in den Einstellungen für den Texteditor unter Verhalten die Einrücktiefe
für die Taste [Tab] einstellen. Die Standardeinstellung ist auf 4 gesetzt.
Zusammenfassung
Denkt einfach an die Hauptregel, dann solltet ihr das Einrücken problemlos hinbekommen: Der Inhalt
Zusammenfassung
eines Blocks wird ein Level weiter eingerückt, als der Code drumherum.
Denkt einfach an die Hauptregel, dann solltet ihr das Einrücken problemlos hinbekommen: Der Inhalt
eines Blocks wird ein Level weiter eingerückt, als der Code drumherum.
Teil 2: Kommentare
Durch gute Kommentare kann man seinen Quellcode qualitativ sehr aufwerten und dafür sorgen, dass
Teil 2: Kommentare
andere Menschen (oder man selber zwei Monate später) den Quellcode deutlich einfacher verstehen.
Durch gute Kommentare kann man seinen Quellcode qualitativ sehr aufwerten und dafür sorgen, dass
Leider kann man allerdings auch Kommentare schreiben, die sinnlos sind oder eventuell sogar stören.
andere Menschen (oder man selber zwei Monate später) den Quellcode deutlich einfacher verstehen.
Daher gucken wir uns hier mal an, wie genau wir gute Kommentare schreiben können.
Leider kann man allerdings auch Kommentare schreiben, die sinnlos sind oder eventuell sogar stören.
Daher
Es gibtgucken wir uns hier
unterschiedliche mal von
Arten an, wie genau wir gute
Kommentaren, Kommentare
welche schreiben
unterschiedlichen können.dienen. Wir
Zwecken
beschäftigen uns mit folgenden wichtigen Nutzen:
Es gibt unterschiedliche Arten von Kommentaren, welche unterschiedlichen Zwecken dienen. Wir
beschäftigen uns mit folgenden
Nähere Erläuterungen wichtigen Nutzen:
des Codes
Überschriften
Nähere Erläuterungen des Codes
Operationen-Beschreibungen
Überschriften
Code deaktivieren
Operationen-Beschreibungen
DieseCode deaktivieren
Einteilung ist übrigens nicht strikt! Alle genannten Punkte nutzen die gleiche C++ Syntax. Man
kann diese Einteilung mit Variablenrollen vergleichen: Es ist nur eine ungefähre Zuweisung, welchen
Diese Einteilung ist übrigens nicht strikt! Alle genannten Punkte nutzen die gleiche C++ Syntax. Man
Zweck ein Kommentar erfüllt.
kann diese Einteilung mit Variablenrollen vergleichen: Es ist nur eine ungefähre Zuweisung, welchen
Zweckam
Ganz einEnde
Kommentar erfüllt. zusammengefasst, wie ihr jetzt Kommentare schreiben sollt.
wird nochmal

Ganz am Ende wird nochmal zusammengefasst, wie ihr jetzt Kommentare schreiben sollt.
Arten von Kommentaren

Arten von
Nähere Kommentaren
Erläuterungen des Codes
Ein Großteil aller Kommentare ist dazu gedacht, Code näher zu erklären, der ohne Kommentare
Nähere Erläuterungen des Codes
schwierig zu verstehen wäre oder zumindest nicht auf Anhieb klar ist. Beispiel:
Ein Großteil aller Kommentare ist dazu gedacht, Code näher zu erklären, der ohne Kommentare
schwierig zu verstehen wäre oder zumindest nicht auf Anhieb klar ist. Beispiel:
1 // Falls die Zahl ungerade ist
2 if (number % 2 == 1) {
1
3 // Falls die Zahl ungerade ist
cout << "..." << endl;
2
4 if
} (number % 2 == 1) {
3 cout << "..." << endl;
4 }
In diesem Code ist der Ausdruck number % 2 == 1 für viele (gerade Anfänger) wahrscheinlich nicht
sofort verständlich. Der Kommentar darüber fasst den Ausdruck jedoch kurz zusammen, sodass der
In diesem Code ist der Ausdruck number % 2 == 1 für viele (gerade Anfänger) wahrscheinlich nicht
Leser schneller sieht, was der Code tut.
sofort verständlich. Der Kommentar darüber fasst den Ausdruck jedoch kurz zusammen, sodass der
Leser wichtiger
Noch schneller sind
sieht,diese
was der Code tut.jedoch, wenn sie die grundlegende Idee des Algorithmus
Erklärungen
beschreiben – denn dieser ist nicht so schnell aus dem Quellcode ersichtlich. Betrachten wir mal den
Noch wichtiger sind diese Erklärungen jedoch, wenn sie die grundlegende Idee des Algorithmus
folgenden Code:
beschreiben – denn dieser ist nicht so schnell aus dem Quellcode ersichtlich. Betrachten wir mal den
folgenden Code:
 1 int magic(int arrayLength, int array [], int key) {
2 int left = 0;
1
3 int magic
int (int
right = arrayLength
arrayLength ,
-int
1; array [], int key) {
2
4 int left = 0;
3
5
int right
while = arrayLength
(left <= right ) { - 1;
4
6 int middle = (left + right ) / 2;
5
7 while (left <= right ) {
6
8
int
if middle = (left
(array[middle + right
] == key) )
{ / 2;
7
9 return middle;
8
10
if (array
} else if[ middle
(array[]middle
== key )>
] key
{ ) {
9
11 return middle ;
right = middle - 1;
10
12
}}
else
else if
{ (array[middle ] > key) {
11
13 right
left == middle
middle +-

11
;;
12
14
}} else {
13
15 left
} = middle + 1;
14
16 }
15
17
}return -1;
16
18 }
17 return -1;
18 }
Viele von euch werden vermutlich die binäre Suche erkennen. Aber nehmt mal an, dass ihr diesen
Standardalgorithmus noch nicht kennt: Dann wäre es ziemlich schwierig, nachzuvollziehen, was hier
Viele von euch werden vermutlich die binäre Suche erkennen. Aber nehmt mal an, dass ihr diesen
eigentlich gemacht wird und warum es funktioniert. Und in der Realität werdet ihr meist Code lesen,
Standardalgorithmus noch nicht kennt: Dann wäre es ziemlich schwierig, nachzuvollziehen, was hier
der Algorithmen nutzt, die ihr noch nicht kennt. Daher ist es wichtig, den Algorithmus in Kommentaren
eigentlich gemacht wird und warum es funktioniert. Und in der Realität werdet ihr meist Code lesen,
zu beschreiben.
der Algorithmen nutzt, die ihr noch nicht kennt. Daher ist es wichtig, den Algorithmus in Kommentaren
zu beschreiben.
 1 int magic(int arrayLength, int array [], int key) {
2 // Wir suchen hier nach dem Element `key` und nutzen dabei aus,
1
3 int magic(int arrayLength, int array [], int key) {
// dass das Array sortiert ist. Wir gucken zuerst in die Mitte
2
4 // Wir suchen hier nach dem Element `key` und nutzen dabei aus,
// und prüfen, ob wir zufällig schon das richtige Element gefunden
3
5
// dass das Array sortiert ist. Wir gucken zuerst in die Mitte
// haben.
4
6
// und prüfen, ob wir zufällig schon das richtige Element gefunden
//
5
7
// haben.
// Falls wir es noch nicht gefunden haben, schränken wir jetzt
6
8
//
// unseren Suchbereich ein: entweder müssen wir nur noch in der
7
9
// Falls wir es noch nicht gefunden haben, schränken wir jetzt
// linken Hälfte oder nur noch in der rechten Hälfte suchen. Mit
8
10
// unseren Suchbereich ein: entweder müssen wir nur noch in der
// diesem Trick können wir unsere Suchzeit stark optimieren.
9
11
// linken Hälfte oder nur noch in der rechten Hälfte suchen. Mit
10
12
// diesem Trick können wir unsere Suchzeit stark optimieren.
// Die Variablen `left` und `right` beschreiben die Grenzen
11
13
// unseres derzeitigen Suchbereichs.
12
14
// Die Variablen `left` und `right` beschreiben die Grenzen
int left = 0;
13
15
// unseres derzeitigen Suchbereichs.
int right = arrayLength - 1;
14
16 int left = 0;
15
17
int right = arrayLength - 1;
// Wenn die Grenzen aneinander vorbeilaufen heißt das, dass das
16
18 // Element nicht im Array ist.
17
19
// Wenn die Grenzen aneinander vorbeilaufen heißt das, dass das
while (left <= right ) {
18
20 // Element nicht im Array ist.
19
21 while
(left <= right ) {
// Die Mitte zwischen den beiden Grenzen.
20
22 int middle = (left + right ) / 2;
21
23 // Die Mitte zwischen den beiden Grenzen.
22
24
int
if middle = (left
(array[middle + right
] == key) )
{ / 2;
23
25 // Gefunden!
24
26 if
(array
return [middle;] == key) {
middle
25
27 // Gefunden!
} else if (array[middle ] > key) {
26
28
return middle;
// Das gesuchte Element ist kleiner als das Element im
27
29 } else if (array[middle ] > key) {
// Array, das wir gerade betrachten. Wir müssen also
28
30 // Das gesuchte Element ist kleiner als das Element im
// in der linken Hälfte weitersuchen. Dazu passen wir
29
31
// Array, das wir gerade betrachten. Wir müssen also
// unsere rechte Grenze an.
30
32 // in der linken Hälfte weitersuchen. Dazu passen wir
right = middle - 1;
31
33 // unsere rechte Grenze an.
} else {
32
34 right = middle - 1;
// Hier genau umgekehrt: Wir suchen in der rechten
33
35 } else {
// Hälfte weiter.
34
36 // Hier genau umgekehrt: Wir suchen in der rechten
left = middle + 1;
35
37
} // Hälfte weiter.
36
38 left
} = middle + 1;
37
39 }
38
40
}// Wir haben das Element nicht gefunden. Um zu signalisieren,
39
41 // dass das gesuchte Element nicht existieren, geben wir -1
40
42
// Wir haben das Element nicht gefunden. Um zu signalisieren,
// zurück.
41
43
// dass das gesuchte Element nicht existieren, geben wir -1
return -1;
42
44
} // zurück.
43 return -1;
44 }
Im Fall von Standardalgorithmen wie der binären Suche könnte man als Einleitung natürlich auch
einfach etwas schreiben wie:
Im Fall von Standardalgorithmen wie der binären Suche könnte man als Einleitung natürlich auch
einfach etwas schreiben wie:
2 // Diese Operation implementiert die binäre Suche. Für weitere
3 // Informationen, siehe:
2
4 // Diese Operation implementiert die binäre Suche. Für weitere
//
3
5 // Informationen, siehe:
// https://en.wikipedia.org/wiki/Binary_search_algorithm
4 //
5 // https://en.wikipedia.org/wiki/Binary_search_algorithm
In richtigen Implementierungen der binären Suche wird der Index middle übrigens etwas anders
berechnet:
In richtigen Implementierungen der binären Suche wird der Index middle übrigens etwas anders
berechnet:
 21 // Normalerweise könnten wir die Mitte zwischen `left` und `right` einfach
22 // so berechnen: `(left + right) / 2`. Leider führt das jedoch bei großen
21
23 // Normalerweise könnten wir die Mitte zwischen `left` und `right` einfach
// Arrays zu einem Integer-Overflow. Um das zu vermeiden berechnen wir die
22
24 // so berechnen: `(left + right) / 2`. Leider führt das jedoch bei großen
// Mitte wie unten gezeigt. Beide Rechnungen haben das gleiche Ergebnis!
23
25 // Arrays zu einem Integer-Overflow. Um das zu vermeiden berechnen wir die
int middle = left + (right - left) / 2;
24 // Mitte wie unten gezeigt. Beide Rechnungen haben das gleiche Ergebnis!
25 int middle = left + (right - left) / 2;
Ohne Kommentar wäre hier fast allen Lesern nicht klar, warum die Mitte so umständlich berechnet
wird.
Ohne Kommentar wäre hier fast allen Lesern nicht klar, warum die Mitte so umständlich berechnet
wird.

Sind also mehr Kommentare immer gut? Nein! Wir schauen uns jetzt mal Kommentare an, die
entweder nichts bringen oder sogar schädlich sind.
Sind also mehr Kommentare immer gut? Nein! Wir schauen uns jetzt mal Kommentare an, die
entwederKommentare
Unnütze nichts bringen oder
sind sogardie
solche, schädlich
nur das sind.
wiederholen, was der Code schon ausdrückt.

Unnütze Kommentare sind solche, die nur das wiederholen, was der Code schon ausdrückt.
1 int number;
2 cin >> number;
1
3 int number;
2
4 cin >> number;
// Integer Variable x anlegen und mit 0 initialisieren
3
5 int x = 0;
4
6 // Integer Variable x anlegen und mit 0 initialisieren
5
7 int x = 0;
// Solange number größer als 0 ist
6
8 while (number > 0) {
7
9 // Solange number größer als 0 ist
// Wir berechnen den Rest, wenn wir number durch 10 teilen. Diesen Wert
8
10 while (number > 0) {
// addieren wir auf x.
9
11 // Wir berechnen den Rest, wenn wir number durch 10 teilen. Diesen Wert
x = x + (number % 10);
10
12
// addieren wir auf x.
11
13 x = x + (number % 10);
// number durch 10 teilen
12
14
number = number / 10;
13
15
} // number durch 10 teilen
14 number = number / 10;
15 }
Alle diese Kommentare sind sinnlos: Der Code darunter sagt exakt das Gleiche aus. Klar: Für
Programmieranfänger, die noch Probleme haben, C++ zu lesen, mögen diese Kommentare sinnvoll
Alle diese Kommentare sind sinnlos: Der Code darunter sagt exakt das Gleiche aus. Klar: Für
sein. Aber sobald man nach einigen Wochen die einfache C++ Syntax versteht, werden die
Programmieranfänger, die noch Probleme haben, C++ zu lesen, mögen diese Kommentare sinnvoll
Kommentare redundant.
sein. Aber sobald man nach einigen Wochen die einfache C++ Syntax versteht, werden die
Kommentare
Viel wichtiger redundant.
noch: Der Code oben enthält keine Kommentare, die sinnvoll beschreiben, was passiert.
Wie wär’s hiermit?
Viel wichtiger noch: Der Code oben enthält keine Kommentare, die sinnvoll beschreiben, was passiert.
Wie wär’s hiermit?
4 // In x berechnen wir die Quersumme.
5 int x = 0;
4
6 // In x berechnen wir die Quersumme.
5
7 int x = 0;
// Solange wir noch Ziffern haben
6
8 while (number > 0) {
7
9 // Solange wir noch Ziffern haben
// Wir addieren die letzte Ziffer von `number` zu unserer
8
10 while (number > 0) {
// bisherigen Quersumme dazu.
9
11 // Wir addieren die letzte Ziffer von `number` zu unserer
x = x + (number % 10);
10
12
// bisherigen Quersumme dazu.
11
13 x = x + (number % 10);
// Wir schneiden die letzte Ziffer von `number` ab.
12
14
number = number / 10;
13
15
} // Wir schneiden die letzte Ziffer von `number` ab.
14 number = number / 10;
15 }
Hier wurde die semantische Bedeutung des Codes erklärt. Besser, nicht wahr?

Hierund
Hin wurde die semantische
wieder Bedeutung
sind Kommentare leider des
auchCodes erklärt.
inkorrekt. Besser,
Diese nicht wahr?
Kommentare sind dann sogar
schädlich. Denken wir nochmal an unser Beispiel von oben:
Hin und wieder sind Kommentare leider auch inkorrekt. Diese Kommentare sind dann sogar
schädlich. Denken wir nochmal an unser Beispiel von oben:
 1 // Falls die Zahl gerade ist
2 if (number % 2 == 1) {
1
3 // Falls die Zahl gerade ist
cout << "..." << endl;
2
4 if
} (number % 2 == 1) {
3 cout << "..." << endl;
4 }
Ein solches Kommentar verspricht dem Leser: “Du brauchst dir den Code nicht genau angucken, ich
sag dir, was passiert!” Leider ist der Kommentar in diesem Beispiel falsch. Wenn der Inhalt von
Ein solches Kommentar verspricht dem Leser: “Du brauchst dir den Code nicht genau angucken, ich
Kommentaren nicht zum Code passt, wird der Leser oft stark verwirrt.
sag dir, was passiert!” Leider ist der Kommentar in diesem Beispiel falsch. Wenn der Inhalt von
Kommentaren nicht zum Code passt, wird der Leser oft stark verwirrt.
Überschriften
Kommentare werden auch oft als Überschrift genutzt, um mehrere Zeilen Code zusammenzufassen:
Überschriften
Kommentare werden auch oft als Überschrift genutzt, um mehrere Zeilen Code zusammenzufassen:
1 // Dividend und Divisor einlesen
2 int dividend;
1
3 // Dividend und Divisor einlesen
cout << "Dividend: ";
2
4 int dividend
cin ; ;
>> dividend
3
5 cout << "Dividend: ";
4
6 cin >> dividend
int divisor ; ;
5
7 do {
6
8 int divisor
cout ;
<< "Divisor (nicht 0): " ;
7
9 do {
cin >> divisor;
8
10 cout
} while << "Divisor (nicht 0): "
(divisor == 0); ;
9
11 cin >> divisor;
10
12 } while (divisor == 0);
// Quotient und Rest berechnen und ausgeben
11
13 int quotient = dividend / divisor;
12
14 // Quotient und Rest berechnen und ausgeben
int mod = dividend % divisor;
13
15 int quotient
cout = dividend
<< dividend / divisor
<< " / " ;
<< divisor << " = " << quotient << endl;
14
16 int mod = dividend % divisor;
cout << dividend << " % " << divisor << " = " << mod << endl;
15 cout << dividend << " / " << divisor << " = " << quotient << endl;
16 cout << dividend << " % " << divisor << " = " << mod << endl;
Hier ist jede Programmzeile sehr selbsterklärend und braucht daher nicht wirklich erklärende
Kommentare. Die beiden Kommentare im Code sind nur Überschriften, damit sich der Leser schneller
Hier ist jede Programmzeile sehr selbsterklärend und braucht daher nicht wirklich erklärende
im Code zurecht findet und große Teile beim Lesen überspringen kann.
Kommentare. Die beiden Kommentare im Code sind nur Überschriften, damit sich der Leser schneller
im
BeiCode zurechtProgrammen
sehr großen findet und große Teilesolche
werden beim Lesen überspringen kann. manchmal visuell betont, z.B.
“Überschrift”-Kommentare
so:
Bei sehr großen Programmen werden solche “Überschrift”-Kommentare manchmal visuell betont, z.B.
so:
1 // ==================================================================
2 // ===== Dividend und Divisor einlesen
1
3 // ==================================================================
// ==================================================================
2 // ===== Dividend und Divisor einlesen
3 // ==================================================================
Das ist keine besondere C++ Syntax, sondern einfach nur irgendwelche Zeichen, damit diese
Überschrift aus dem Code heraussticht.
Das ist keine besondere C++ Syntax, sondern einfach nur irgendwelche Zeichen, damit diese
Überschrift aus dem Code heraussticht.
Operationen Beschreibungen
Operationen sind dazu da, Funktionalität zu kapseln. Damit ein anderer Entwickler eine Operation von
Operationen Beschreibungen
euch nutzen kann, muss er wissen, was eure Operation genau tut. Dies zu beschreiben, ist Aufgabe
Operationen sind dazu da, Funktionalität zu kapseln. Damit ein anderer Entwickler eine Operation von
der Operationen-Dokumentation. Das ist einfach ein Kommentar, der über der Operation steht. Andere
euch nutzen kann, muss er wissen, was eure Operation genau tut. Dies zu beschreiben, ist Aufgabe
Entwickler sollten alles wichtige über die Operation aus der Dokumentation herausfinden können –
der Operationen-Dokumentation. Das ist einfach ein Kommentar, der über der Operation steht. Andere
und zwar ohne in den Rumpf der Operation zu schauen! Beispiel:
Entwickler sollten alles wichtige über die Operation aus der Dokumentation herausfinden können –
und zwar ohne in den Rumpf der Operation zu schauen! Beispiel:
1 // Gibt das Maximum aus dem Array zurück.
2 int max(int arrayLength, int array []) {
1
3 // Gibt das Maximum aus dem Array zurück.
...
2
4 int
} max(int arrayLength, int array []) {
3 ...
4 }
Ist das eine gute Operationen-Dokumentation? Leider nein:

Ist das eine

Gibt diegute Operationen-Dokumentation?
Operation den Wert oder den IndexLeider nein:
des maximalen Elements zurück?
Was passiert, wenn das Array leer ist?
Gibt die Operation den Wert oder den Index des maximalen Elements zurück?
Was
In der passiert, wenn
Dokumentation das Array
müssen leer ist? Fälle exakt beschrieben werden. Das wäre besser:
alle möglichen

In der Dokumentation müssen alle möglichen Fälle exakt beschrieben werden. Das wäre besser:
1 // Gibt den Index des Elements mit dem größten Wert zurück. Wenn das
2 // übergebene Array leer ist, wird -1 zurückgegeben.
1
3 // Gibt den Index des Elements mit dem größten Wert zurück. Wenn das
int max(int arrayLength, int array []) {
2
4 // übergebene Array leer ist, wird -1 zurückgegeben.
...
3
5 int
} max(int arrayLength, int array []) {
4 ...
5 }

Code deaktivieren
Manchmal werden Kommentare “missbraucht”, um Code zu deaktivieren. Dies passiert insbesondere
Code deaktivieren
während man das Programm testet. Hier wird zum Beispiel ein selbstgeschriebener
Manchmal werden Kommentare “missbraucht”, um Code zu deaktivieren. Dies passiert insbesondere
Sortieralgorithmus mit verschiedenen Arrays getestet:
während man das Programm testet. Hier wird zum Beispiel ein selbstgeschriebener
Sortieralgorithmus mit verschiedenen Arrays getestet:
1 // int array[] = {1, 2, 3};
2 // int array[] = {-1, 1, -1};
1
3 // int array[] = {1, 2, 3};
int array [] = {0, 9, 8, 4};
2
4 // int array[] = {-1, 1, -1};
3
5 int array []
bubbleSort ( = {0,) ;9, 8, 4};
array
4
6 printArray(array);
5 bubbleSort(array);
6 printArray(array);
Eigentlich ist es nicht der Zweck von Kommentaren, Code zu deaktivieren. Es kann aber sehr nützlich
sein, daher werden Kommentare dafür oft missbraucht. Allerdings sollte man in den meisten Fällen so
Eigentlich ist es nicht der Zweck von Kommentaren, Code zu deaktivieren. Es kann aber sehr nützlich
entstandenen “Test-Code” aufräumen, bevor man seinen Code fertigstellt (bzw. hochlädt).
sein, daher werden Kommentare dafür oft missbraucht. Allerdings sollte man in den meisten Fällen so
entstandenen “Test-Code” aufräumen, bevor man seinen Code fertigstellt (bzw. hochlädt).
Exkurs: Wer sollte denn meinen Code lesen?
Code wird deutlich öfter gelesen, als geschrieben. Also wird auch höchstwahrscheinlich euer Code
Exkurs: Wer sollte denn meinen Code lesen?
später oft gelesen werden. Und ihr wollt alles tun, damit der Leser eures Codes später wenig
Code wird deutlich öfter gelesen, als geschrieben. Also wird auch höchstwahrscheinlich euer Code
Verständnisprobleme hat und schnell vorankommt. Dazu gibt es ein bekanntes Zitat:
später oft gelesen werden. Und ihr wollt alles tun, damit der Leser eures Codes später wenig
Verständnisprobleme hatguy
Always code as if the undwho
schnell
endsvorankommt. Dazu
up maintaining yourgibt es ein
code willbekanntes Zitat:
be a violent psychopath who
knows where you live. Code for readability.
Always code as if the guy who ends up maintaining your code will be a violent psychopath who
knows
Und where
warum you
solltet ihrlive.
jetztCode forschon
in AuD readability.
anfangen, ordentlich zu kommentieren? Gute Kommentare
zu schreiben ist viel schwieriger, als die meisten sich das vorstellen! Daher muss das Kommentare-
Und warum solltet ihr jetzt in AuD schon anfangen, ordentlich zu kommentieren? Gute Kommentare
Schreiben gelernt werden und genau dafür ist AuD auch da.
zu schreiben ist viel schwieriger, als die meisten sich das vorstellen! Daher muss das Kommentare-
Schreiben
Außerdem gelernt
wissen werden und
wir wo ihr genau
wohnt … dafür ist AuD auch da.

Außerdem wissen wir wo ihr wohnt …

Zusammenfassung

Schreibt Code, der einfach zu lesen ist.

Zusammenfassung
Fügt Kommentare an den Stellen hinzu, an denen weitere Erklärungen das Verständnis
Schreibt Code, der einfach zu lesen ist.
erleichtern.
Fügt Kommentare an den Stellen hinzu, an denen weitere Erklärungen das Verständnis
Fasst größere Blöcke von Code mit Überschriften zusammen, sodass man schnell einen groben
erleichtern.
Überblick hat.
Fasst größere Blöcke von Code mit Überschriften zusammen, sodass man schnell einen groben
Beschreibt, was eure Operationen machen und erwähnt dabei alle wichtigen Details.
Überblick hat.
Beschreibt, was eure Operationen machen und erwähnt dabei alle wichtigen Details.
Teil 3: Namen
Beim Programmieren muss man sich immer wieder Namen ausdenken: für Variablen, Operationen,
Teil 3: Namen
Klassen und vieles anderes. Die Namen haben keinen Einfluss auf das Verhalten des Programms,
Beim Programmieren muss man sich immer wieder Namen ausdenken: für Variablen, Operationen,
sind jedoch für die Lesbarkeit des Codes sehr wichtig. Im folgenden wird erklärt, wie man passende
Klassen und vieles anderes. Die Namen haben keinen Einfluss auf das Verhalten des Programms,
und gute Namen vergibt.
sind jedoch für die Lesbarkeit des Codes sehr wichtig. Im folgenden wird erklärt, wie man passende
und gute
Das Namen
Vergeben vergibt.
eines Namens hat zwei Komponenten:

Das Vergeben
1. Case eines Namens hat zwei Komponenten:
(einfach)
2. Bedeutung (schwierig)
Case (einfach)
Bedeutung (schwierig)

(1) Case

Fangen wir mit dem einfacheren Teil an: den richtigen Case für den Namen nutzen. Wie wir in
(1) Case
Abschnitt (2) noch sehen werden, werden unsere Variablennamen meist aus mehreren Wörtern –
Fangen wir mit dem einfacheren Teil an: den richtigen Case für den Namen nutzen. Wie wir in
manchmal fast aus einem ganzen Satz – bestehen. Dummerweise erlaubt fast keine
Abschnitt (2) noch sehen werden, werden unsere Variablennamen meist aus mehreren Wörtern –
Programmiersprache Leerzeichen in Namen!
manchmal fast aus einem ganzen Satz – bestehen. Dummerweise erlaubt fast keine
DawirallerdingsimDeutschenundEnglischennormalerweiseaufLeerzeichenzumTrennenvonWörternange
Programmiersprache Leerzeichen in Namen!
wiesensind, müssen wir uns irgendwie überlegen, wie wir stattdessen Wörter aneinander hängen.
DawirallerdingsimDeutschenundEnglischennormalerweiseaufLeerzeichenzumTrennenvonWörternange
wiesensind,
Hierbei habenmüssen wir die
sich über unsZeit
irgendwie überlegen,Schreibweisen
unterschiedliche wie wir stattdessen Wörter
(Cases) aneinander
entwickelt. hängen.
In C++ werden
wir dabei unterschiedliche Cases für unterschiedliche Namen (Variable, Operation, Klasse, …)
Hierbei haben sich über die Zeit unterschiedliche Schreibweisen (Cases) entwickelt. In C++ werden
benutzen:
wir dabei unterschiedliche Cases für unterschiedliche Namen (Variable, Operation, Klasse, …)
benutzen:
Verwendung Case Beispiel
für
“big
red
counter”

Variablen
Verwendung lowerCamelCase
Case int bigRedCounter = 3;
Beispiel
für
“big
red
counter”

Operationen
Variablen lowerCamelCase
lowerCamelCase char bigRedCounter() { ... }
int bigRedCounter = 3;

Klassen
Operationen
lowerCamelCase
UpperCamelCase
char bigRedCounter() { ... }
class BigRedCounter { ... }

Klassen UpperCamelCase const int BIG_RED_COUNTER =

class BigRedCounter { ... }
Konstanten SCREAMING_SNAKE_CASE
2;
const int BIG_RED_COUNTER =
Konstanten SCREAMING_SNAKE_CASE
2;
Dazu noch ein paar Bemerkungen:

DazuDie
noch ein paar
Regeln Bemerkungen:
implizieren insbesondere, dass Variablen und Operationen am Anfang mit einem
Kleinbuchstaben beginnen!
Die Regeln implizieren insbesondere, dass Variablen und Operationen am Anfang mit einem
Die allgemein recht bekannte Schreibweise lower_snake_case wird auch häufig in C++
Kleinbuchstaben beginnen!
benutzt. Wir legen uns aber auf die oben beschriebene Schreibweise fest.
Die allgemein recht bekannte Schreibweise lower_snake_case wird auch häufig in C++
Falls man zur Benennung Deutsch nutzt, würde man oft auch zusammengesetzte Wörter als
benutzt. Wir legen uns aber auf die oben beschriebene Schreibweise fest.
mehrere Wörter behandeln: BaumHausKönig anstatt Baumhauskönig .
Falls man zur Benennung Deutsch nutzt, würde man oft auch zusammengesetzte Wörter als
Wichtig: Einfach nur die Leerzeichen wegzulassen ist keine Lösung. Also die Namen
mehrere Wörter behandeln: BaumHausKönig anstatt Baumhauskönig .
bigredcounter oder Bigredcounter zu nutzen ist ganz falsch!
Wichtig: Einfach nur die Leerzeichen wegzulassen ist keine Lösung. Also die Namen
bigredcounter
Insgesamt oder
ist aber die Bigredcounter
Schreibweise, zu
also den nutzen Case
richtigen ist ganz falsch! recht einfach. Man muss
zu nutzen,
lediglich die kurze Tabelle oben auswendig lernen und beim Programmieren daran denken.
Insgesamt ist aber die Schreibweise, also den richtigen Case zu nutzen, recht einfach. Man muss
lediglich die kurze Tabelle oben auswendig lernen und beim Programmieren daran denken.
(2) Bedeutung
Nachdem ihr nun wisst, welchen Case ihr verwenden sollt, müsst ihr noch den eigentlichen Namen
(2) Bedeutung
wählen. Das ist leider schwieriger. Der folgende Spruch ist recht bekannt unter Programmierern:
Nachdem ihr nun wisst, welchen Case ihr verwenden sollt, müsst ihr noch den eigentlichen Namen
wählen.
ThereDas
are ist
onlyleider schwieriger.
2 hard problems Der folgendescience:
in computer Spruch ist rechtinvalidation,
cache bekannt unter Programmierern:
naming things, and off-
by-1 errors.
There are only 2 hard problems in computer science: cache invalidation, naming things, and off-
Derby-1 errors.
Begriff “cache invalidation” spielt in AuD keine Rolle; die anderen beiden Probleme hattet ihr aber
sicherlich auch schon mal. Der Punkt ist: Namen auszuwählen ist schwierig!
Der Begriff “cache invalidation” spielt in AuD keine Rolle; die anderen beiden Probleme hattet ihr aber
sicherlich
Was auchgute
sind nun schon
undmal.
wasDer Punkt
sind ist: Namen
schlechte auszuwählen
Namen? ist schwierig!
Im deutschen Sprachraum hört man oft den
Begriff sprechende
Namen. Das bedeutet einfach nur, dass die Namen für sich selbst sprechen und
Was sind nun gute und was sind schlechte Namen? Im deutschen Sprachraum hört man oft den
somit die
Variable,
Operation,
o.ä.
erklären. Darum geht es nämlich nur wieder: Den Programmierer
Begriff sprechende
Namen. Das bedeutet einfach nur, dass die Namen für sich selbst sprechen und
beim Lesen von Quellcode unterstützen. Um sich beim Auswählen eines Namens zu helfen, kann man
somit die
Variable,
Operation,
o.ä.
erklären. Darum geht es nämlich nur wieder: Den Programmierer
sich z.B. die folgenden Fragen stellen:
beim Lesen von Quellcode unterstützen. Um sich beim Auswählen eines Namens zu helfen, kann man
sich Welchen
z.B. die folgenden Fragen
Zweck erfüllt stellen:
meine Variable?
Was genau tut meine Operation?
Welchen Zweck erfüllt meine Variable?
Welchen Wert (bzw. Werte) wird meine Variable enthalten?
Was genau tut meine Operation?
Man Welchen Wert
sollte also (bzw. möglich
– soweit Werte) wird meinevermeiden,
– Namen Variable enthalten?
die keine zusätzlichen Informationen vermitteln,
wie z.B. wert , zahl , helfer und temp . Auch Namen, die nur aus einem einzigen Buchstaben
Man sollte also – soweit möglich – Namen vermeiden, die keine zusätzlichen Informationen vermitteln,
bestehen sollten in den meisten Fällen vermieden werden.
wie z.B. wert , zahl , helfer und temp . Auch Namen, die nur aus einem einzigen Buchstaben
bestehen sollten in den meisten Fällen vermieden werden.
1 int arrayLength = 6;
2 int array [arrayLength] = {3, 4, 5, 6, 7, 9};
1
3 int arrayLength = 6;
2
4 int array [arrayLength] = {3, 4, 5, 6, 7, 9};
// Führe binäre Suche durch:
3
5 int i = 0;
4
6 // Führe binäre Suche durch:
int j = arrayLength - 1;
5
7 int i = 0;
6
8 int
... j = arrayLength - 1;
7
8 ...
Die Variable array könnte besser input heißen, um zu kennzeichnen, dass es eingelesen wurde.
Aber viel wichtiger: i und j sind schlechte Namen! Hier sollte man lieber start und end (oder
Die Variable array könnte besser input heißen, um zu kennzeichnen, dass es eingelesen wurde.
low / high , oder leftBound / rightBound , oder …) verwenden, um die Rolle der Variablen zu
Aber viel wichtiger: i und j sind schlechte Namen! Hier sollte man lieber start und end (oder
beschreiben.
low / high , oder leftBound / rightBound , oder …) verwenden, um die Rolle der Variablen zu
beschreiben.
Allerdings gibt es immer mal wieder Ausnahmen. Manchmal beschreibt ein einziger Buchstabe den
Zweck der Variable schon ausreichend (z.B. x und y , wenn man über Vektoren spricht). Zu
Allerdings gibt es immer mal wieder Ausnahmen. Manchmal beschreibt ein einziger Buchstabe den
erkennen, wann es sich um eine Ausnahme handelt, ist natürlich recht schwierig.
Zweck der Variable schon ausreichend (z.B. x und y , wenn man über Vektoren spricht). Zu
erkennen,
Beispiele: wann es sich um eine Ausnahme handelt, ist natürlich recht schwierig.

Beispiele:
data (schlecht: Alles ist “data”)

counter (oft nicht optimal: was wird gezählt?) → numberOfMoves (aha, das war gemeint!)
data (schlecht: Alles ist “data”)
Einen counter (oft nicht optimal:
sprechenden
Namen was ist
zu nutzen wird
diegezählt?) numberOfMoves
wichtigste Regel, allerdings sollte
(aha,der
dasName
war gemeint!)
auch
möglichst kurz sein. Diese beiden Regeln scheinen natürlich im Konflikt miteinander zu stehen: Je
→
Einen sprechenden
Namen zu nutzen ist die wichtigste Regel, allerdings sollte der Name auch
kürzer der Name, desto weniger kann man damit erklären. Hier gilt: So lang wie nötig, so kurz wie
möglichst kurz sein. Diese beiden Regeln scheinen natürlich im Konflikt miteinander zu stehen: Je
möglich.
kürzer der Name, desto weniger kann man damit erklären. Hier gilt: So lang wie nötig, so kurz wie
möglich.
Beispiele:

Beispiele:
numberOfElementsInArray (schlecht) → arrayLength (gut)

theTimeItTakesToSort (schlecht)
numberOfElementsInArray → sortDuration
(schlecht) (gut)
arrayLength (gut)
theTimeItTakesToSort
Bei Variablen, (schlecht)Zweck
die einen komplizierteren →
sortDuration (gut)
erfüllen, ist es meist nicht möglich, eine volle
Beschreibung dieses Zwecks in den Namen → zu quetschen. Hier ist es dann besser, einen
Bei Variablen, die einen komplizierteren Zweck erfüllen, ist es meist nicht möglich, eine volle
ausführlichen Kommentar über der Variablendeklaration zu schreiben. Beispiel (Quicksort
Beschreibung dieses Zwecks in den Namen zu quetschen. Hier ist es dann besser, einen
Partitionierung):
ausführlichen Kommentar über der Variablendeklaration zu schreiben. Beispiel (Quicksort
Partitionierung):
1 // Während der Partitionierung haben wir im Array immer vier unterschiedliche
2 // Bereiche:
1
3 // Während der Partitionierung haben wir im Array immer vier unterschiedliche
//
2
4 // Bereiche:
// +---------------------------------------------+
3
5 //
// | p | kleiner | größer | nicht eingeordnet |
4
6 // +---------------------------------------------+
// +---------------------------------------------+
5
7 // | p | kleiner | größer | nicht eingeordnet |
// ^ ^ ^
6
8 // +---------------------------------------------+
// 0 startUpper startRest
7
9 // ^ ^ ^
//
8
10 // 0 startUpper startRest
// - p: Ist nur ein Element lang und enthält das Pivot Element.
9
11 //
// - kleiner: Enthält Elemente kleiner oder gleich p
10
12 // - p: Ist nur ein Element lang und enthält das Pivot Element.
// - größer: Enthält Elemente größer p
11
13 // - kleiner: Enthält Elemente kleiner oder gleich p
// - nicht eingeordnet: Enthält Elemente, die noch in "kleiner" oder
12
14 // - größer: Enthält Elemente größer p
// "größer" eingeordnet werden müssen.
13
15 // - nicht eingeordnet: Enthält Elemente, die noch in "kleiner" oder
//
14
16 // "größer" eingeordnet werden müssen.
// Dabei ist `startUpper` immer der erste Index in dem "größer" Bereich
15
17 //
// und `startRest` ist der erste Index des noch nicht eingeordneten
16
18 // Dabei ist `startUpper` immer der erste Index in dem "größer" Bereich
// Bereichs.
17
19 // und `startRest` ist der erste Index des noch nicht eingeordneten
int startUpper;
18
20 // Bereichs.
int startRest;
19 int startUpper;
20 int startRest;
Leider wird an vielen Stellen (in Büchern, in Vorlesungen, …) nicht konsistent auf gute
Variablenbenennung geachtet. Gerade in der theoretischen Informatik merkt man den Einfluss der
Leider wird an vielen Stellen (in Büchern, in Vorlesungen, …) nicht konsistent auf gute
Mathematik: Jeder Variablenname nur ein Zeichen lang, meist aus dem griechischen oder
Variablenbenennung geachtet. Gerade in der theoretischen Informatik merkt man den Einfluss der
hebräischen Alphabet. Daher sollte man sich – was Variablenbenennung angeht – nicht allzu sehr an
Mathematik: Jeder Variablenname nur ein Zeichen lang, meist aus dem griechischen oder
solchen Standardwerken orientieren.
hebräischen Alphabet. Daher sollte man sich – was Variablenbenennung angeht – nicht allzu sehr an
solchen Standardwerken orientieren.

Gute Benennung von Variablen muss man lernen; daher sollt ihr auch schon in AuD damit anfangen.
Sobald man eine Variable einführt, sollte man sich auch einen guten Namen ausdenken. Nach
Gute Benennung von Variablen muss man lernen; daher sollt ihr auch schon in AuD damit anfangen.
Fertigstellung des Programms, könnt ihr noch einmal über euren Quellcode schauen und versuchen
Sobald man eine Variable einführt, sollte man sich auch einen guten Namen ausdenken. Nach
noch bessere Namen zu finden. Oder bittet einen Kollegen euren Code zu lesen und zu bewerten, ob
Fertigstellung des Programms, könnt ihr noch einmal über euren Quellcode schauen und versuchen
er einfach zu verstehen ist. Natürlich könnt ihr auch jederzeit euren Tutor oder eure Tutorin dazu
noch bessere Namen zu finden. Oder bittet einen Kollegen euren Code zu lesen und zu bewerten, ob
befragen.
er einfach zu verstehen ist. Natürlich könnt ihr auch jederzeit euren Tutor oder eure Tutorin dazu
befragen.
Im Übrigen kann es auch ein paar Minuten dauern, einen guten Namen zu finden! Nehmt euch diese
Zeit ruhig. Über gewisse Namen (von öffentlichen APIs) wird sogar manchmal wochenlang in größeren
Im Übrigen kann es auch ein paar Minuten dauern, einen guten Namen zu finden! Nehmt euch diese
Teams diskutiert. Namen sind eben doch wichtig!
Zeit ruhig. Über gewisse Namen (von öffentlichen APIs) wird sogar manchmal wochenlang in größeren
Teams diskutiert. Namen sind eben doch wichtig!