C++-Programmierung/ Einführung in C++

Aus Wikibooks
Zur Navigation springen Zur Suche springen
Einführung in C++
Two male giraffes are necking in San Francisco Zoo.jpg

Zielgruppe:

Programmieranfänger, für Umsteiger reicht die Zusammenfassung.

Lernziel:
Grundelemente in C++


Inhaltsverzeichnis

Hallo, du schöne Welt! [Bearbeiten]

Es ist eine alte Tradition, eine neue Programmiersprache mit einem „Hello-World“-Programm einzuweihen. Auch dieses Buch soll mit der Tradition nicht brechen, hier ist das „Hello-World“-Programm in C++:

Nuvola-inspired-terminal.svg
1 #include <iostream>                                     // Ein- und Ausgabebibliothek
2 
3 int main(){                                             // Hauptfunktion
4     std::cout << "Hallo, du schöne Welt!" << std::endl; // Ausgabe
5 
6     return 0;                                           // Optionale Rückgabe an das Betriebssystem
7 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Hallo, du schöne Welt!

Zugegebenermaßen ist es nicht die Originalversion, sondern eine Originellversion von „Hello-World“. Wenn Sie das Programm ausführen, bekommen Sie den Text „Hallo, du schöne Welt!“ am Bildschirm ausgegeben. Sie wissen nicht, wie Sie das Programm ausführen können? Dann lesen Sie doch einmal das Kapitel über Compiler.

#include <iostream> stellt die nötigen Befehle zur Ein- und Ausgabe bereit. Als nächstes beginnt die „Hauptfunktion“ main(). Diese Hauptfunktion wird beim Ausführen des Programms aufgerufen. Sie ist also der zentrale Kern des Programms. Wenn Funktionen im Text erwähnt werden, stehen dahinter übrigens immer Klammern, um sie besser von anderen Sprachbestandteilen wie beispielsweise Variablen unterscheiden zu können.

std::cout beschreibt den Standardausgabe-Strom. Dabei wird der Text meist in einem Terminal angezeigt (wenn die Ausgabe nicht in eine Datei oder an ein anderes Programm umgeleitet wird). Die beiden Pfeile (<<) signalisieren, dass der dahinterstehende Text auf die Standardausgabe „geschoben“ wird. Das std::endl gibt einen Zeilenumbruch aus und sorgt dafür, dass der Text jetzt am Bildschirm ausgegeben wird.

return 0 beendet das Programm und zeigt dem Betriebssystem an, dass es erfolgreich ausgeführt wurde. Auf die Einzelheiten wird in den folgenden Kapiteln (oder Abschnitten) noch ausführlich eingegangen. Diese Zeile ist optional; wird sie nicht angegeben, gibt der Compiler implizit 0 zurück.

Im Moment sollten Sie sich merken, dass jeder C++-Befehl mit einem Semikolon (;) abgeschlossen wird und dass geschweifte Klammern ({...}) Zusammengehörigkeit symbolisieren – so auch oben in der Hauptfunktion. Alles was zwischen den geschweiften Klammern steht, gehört zu ihr. Leerzeichen, Tabulatorzeichen und Zeilenumbrüche spielen für den C++-Compiler keine Rolle. Sie können das folgende Programm genauso übersetzen wie seine gut lesbare Version von weiter oben:

Nuvola-inspired-terminal.svg

Dieses Programm funktioniert zwar, ist aber für Menschen sehr schwierig zu lesen…


1 #include        <iostream>
2             int
3    main    (
4          )   {std        ::
5      cout
6  <<         "Hallo, du schöne Welt!"<<std
7    ::  endl
8 ;return 0;
9       }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Hallo, du schöne Welt!

Vorsichtig sollten Sie bei Zeilen sein, die mit # beginnen. Leerzeichen und Tabulatoren sind zwar auch hier bedeutungslos, aber Zeilenumbrüche dürfen nicht stattfinden.

Es ist übrigens (für Ihren Rechner) auch irrelevant, ob Sie etwas wie // Ein- und Ausgabebibliothek mit in Ihr Programm schreiben oder nicht. Es handelt sich dabei um sogenannte Kommentare, die Sie in Kürze auch genauer kennenlernen werden. Beachten sollten Sie übrigens, dass bei C++ die Groß- und Kleinschreibung relevant ist. Schlüsselwörter und Namen der Standardbibliothek werden stets kleingeschrieben. Für die Groß-/Kleinschreibung von selbstdefinierten Namen gibt es gewisse Konventionen, auf welche in einem späteren Kapitel eingegangen wird.

Symbol opinion vote.svg
Hinweis

Bei allen in diesem Buch beschriebenen Programmen handelt es sich um so genannte Kommando­zeilen­programme. Falls Sie eine IDE zur Entwicklung benutzen und das Programm direkt aus dieser heraus aufrufen, kann es Ihnen passieren, dass Sie nur einen kurzen Blitz von Ihrem Programm sehen, weil sich das Kommando­zeilen­fenster nach der Programm­beendigung sofort schließt.

In diesem Fall haben Sie zwei Optionen:

  • Rufen Sie eine Kommandozeile auf und führen Sie das Programm von dort manuell aus. (Das wird empfohlen!)
  • Schauen Sie nach, ob es in Ihrer IDE eine Funktion gibt, die das Fenster nach Programmende noch einen Tastendruck lang offen hält. (Eine solche Option muss nicht vorhanden sein!)

Einfache Ein- und Ausgabe [Bearbeiten]

Ein- und Ausgaberoutinen geben Ihnen die Möglichkeit, mit einem Programm zu interagieren. Dieses Kapitel beschäftigt sich mit der Eingabe über die Tastatur und der Ausgabe auf der Konsole in C++-typischer Form. Die C-Variante werden Sie später noch kennenlernen.

Um die C++-Ein- und Ausgabe nutzen zu können, müssen Sie die Bibliothek iostream einbinden. Das geschieht mit:

Nuvola-inspired-terminal.svg
1 #include <iostream>

Danach müssen die Befehle daraus bekanntgegeben werden, da sie sich in einem Namensraum (engl. namespace) befinden. Was Namensräume sind und wofür man sie einsetzt, werden Sie später noch erfahren. Um nun die Ein- und Ausgabebefehle nutzen zu können, müssen Sie dem Compiler sagen: Benutze den Namensraum std. Dafür gibt es zwei Möglichkeiten: Sie können die folgende Zeile verwenden, um alle Namen aus dem Namensraum std verfügbar zu machen:

Nuvola-inspired-terminal.svg
1 using namespace std;

Oder Sie können den Namensraum „std“ immer direkt angeben. Er enthält alle Komponenten der Standardbibliothek von C++. In den Programmen dieses Buches wird der Namensraum immer direkt angegeben. Das heißt, wenn beispielsweise ein Objekt benutzt werden soll, das im Namensraum „std“ liegt, wird ihm „std::“ vorangestellt. Die beiden Doppelpunkte heißen Bereichsoperator.

Die Variante mit using namespace sollte üblicherweise nur innerhalb von Funktionen genutzt werden, da bei Verwendung im globalen Namensraum das ganze Konzept der Namensräume obsolet wird. In gedruckten Büchern wird es gern global verwendet, da dies etwas Platz spart und der in solchen Büchern knapp ist. Lassen Sie sich davon nicht beirren, es ist schlechter Stil.

Einfache Ausgabe[Bearbeiten]

Nun wollen wir aber endlich auch mal was Praktisches tun. Zugegebenermaßen nichts Weltbewegendes und im Grunde nicht einmal etwas wirklich Neues, denn Text haben wir ja schon im „Hello-World“-Programm ausgegeben.

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 
3 int main(){
4     std::cout << "Dieser Text steht nun in der Kommandozeile!";
5     std::cout << "Dieser Text schließt sich direkt an..";
6     std::cout << '.';
7 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Dieser Text steht nun in der Kommandozeile!Dieser Text schließt sich direkt an...

Wie der Text bereits selbst sagte, erscheint er in der Kommandozeile und der zweite schließt sich ohne Unterbrechung an. Der letzte von den drei abschließenden Punkten steht in einer zusätzlichen Zeile, um Ihnen zu demonstrieren, dass man einzelne Zeichen nicht in Anführungszeichen sondern in Apostrophe setzt. Das gilt aber nur für einzelne Zeichen, ab zwei Zeichen ist es schon eine Zeichenkette und dann verwendet man normale Anführungszeichen.

Wenn Sie innerhalb einer Zeichenkette einen Zeilenumbruch einfügen möchten, gibt es zwei Möglichkeiten. Sie können die Escape-Sequenz \n in die Zeichenkette einfügen oder den Manipulator endl (für end-line) benutzen. Was genau Escape-Sequenzen oder Manipulatoren sind, ist Thema eines späteren Kapitels, aber folgendes Beispiel demonstriert schon mal die Verwendung für den Zeilenumbruch:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main(){
 4     std::cout << "Text in der Kommandozeile!\n";                 // Escape-Sequenz \n
 5     std::cout << "Dieser Text schließt sich an...\n";            // Das steht in einer eigenen Zeile
 6 
 7     std::cout << std::endl;                                      // Leerzeile mittels endl
 8 
 9     std::cout << "Text in der Kommandozeile!" << std::endl;      // Zeilenumbruch mit endl
10     std::cout << "Dieser Text schließt sich an..." << std::endl; // Das steht in einer eigenen Zeile
11 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Text in der Kommandozeile!
2 Dieser Text schließt sich an...
3 
4 Text in der Kommandozeile!
5 Dieser Text schließt sich an...

Beide Methoden haben scheinbar den gleichen Effekt. Verwenden Sie die Escape-Sequence Methode mit "\n". std::endl ist langsamer, da es nicht nur einen Zeilenumbruch ausgibt, sondern auch den Ausgabepuffer leert. Dies wird später noch genauer erläutert.

Einfache Eingabe[Bearbeiten]

Für die Eingabe muss ein wenig vorgegriffen werden, denn um etwas einzulesen, ist etwas nötig, worin das Eingelesene gespeichert werden kann. Dieser „Behälter“ nennt sich Variable. Eine Variable muss zunächst einmal angelegt werden. Am besten lässt sich die Eingabe an einem Beispiel erklären:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main(){
 4     int integer;
 5 
 6     std::cout << "Benutzereingabe: ";
 7 
 8     std::cin >> integer;
 9 
10     std::cout << "Sie haben " << integer << " eingegeben.";
11 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Benutzereingabe: 643
2 Sie haben 643 eingegeben.

Es wird, wie bereits erwähnt, erst eine Variable angelegt (int integer;), welcher dann ein Wert zugewiesen wird (cin >> integer;). Diese zweite Zeile bedeutet so viel wie: Lies eine ganze Zahl von der Tastatur und speichere sie in der Variablen integer.

cin (gesprochen c-in) ist sozusagen die Tastatur, integer ist die Variable und >> bedeutet so viel wie „nach“. Zusammen ergibt sich „Tastatur nach Variable“, es wird also der „Inhalt“ der Tastatur in die Variable integer verschoben. Dass eine Ganzzahl von der Tastatur gelesen wird, ist übrigens vom Datentyp der Variablen abhängig, aber dazu später mehr.

Um den Inhalt der Variablen wieder auszugeben, müssen Sie nichts weiter tun, als sie mit einem weiteren Schiebeoperator (<<) hinter cout (gesprochen c-out) anzuhängen. Es ist ohne Weiteres möglich, mehrere solcher Schiebeoperatoren hintereinander zu schalten, solange Sie nur die letzte Ein- oder Ausgabe mit einem Semikolon (;) abschließen. Bei der Eingabe muss natürlich der >>-Operator statt dem <<-Operator benutzt werden. Die Reihenfolge der Ein- oder Ausgabe bei solchen Konstruktionen entspricht der eingegebenen Folge im Quelltext. Was zuerst hinter cout oder cin steht, wird also auch zuerst ausgeführt.

Crystal source cpp.png

Im Anhang zu diesem Kapitel finden Sie:

  • Fragen und die dazugehörigen Antworten.
Fragen
Symbol question.svg Frage 1: Was ist hier verkehrt?
Crystal Clear action button cancel.svg
1 int integer;
2 std::cin << integer;

Der Operator muss >> sein.

Symbol question.svg Frage 2: Funktioniert folgendes Beispiel?
Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main(){
 4     int integer;
 5 
 6     std::cin >> integer;
 7 
 8     std::cout << "Sie haben "
 9               << integer
10               << " eingegeben.";
11 }

Das Beispiel funktioniert hervorragend. Zeilenumbrüche sind kein Problem, solange sie nicht innerhalb einer Zeichenkette stehen. Wenn Sie allerdings beabsichtigen, einen Zeilenumbruch bei der Ausgabe zu erzeugen, müssen Sie \n oder endl benutzen.

Kommentare [Bearbeiten]

In allen Programmiersprachen gibt es die Möglichkeit, im Quelltext Notizen zu machen. Für andere oder auch für sich selbst, denn nach ein paar Wochen werden Sie möglicherweise Ihren eigenen Quelltext nicht mehr ohne Weiteres verstehen. Kommentare helfen Ihnen und anderen besser und vor allem schneller zu verstehen, was der Quelltext bewirkt. In C++ gibt es zwei Varianten, um Kommentare zu schreiben:

Nuvola-inspired-terminal.svg
1 // Ein Kommentar, der mit zwei Schrägstrichen eingeleitet wird, geht bis zum Zeilenende
2 
3 /* Ein Kommentar dieser Art kann
4    sich über mehrere Zeilen
5    erstrecken oder ... */
6 
7 a = b /* ... vor dem Zeilenende enden. */ + c;

Die erste, bis zum Zeilenende geltende Sorte, ist die moderne Art des Kommentars. Sie ist in der Regel vorzuziehen, da sie einige Vorteile gegenüber der alten, noch aus C stammenden Variante hat. Die zweite Sorte (manchmal auch als C-Kommentar bezeichnet) in seiner mehrzeiligen Form sollte nur an Stellen verwendet werden, an denen längere Textpassagen stehen und möglichst nicht zwischen Code. Anwendung finden solche Kommentare oft am Dateianfang, um den Inhalt kurz zusammenzufassen oder Lizenzrechtliches zu regeln.

Der hauptsächliche Nachteil bei den mehrzeiligen Kommentaren besteht darin, dass man sie nicht „verschachteln“ kann. Oft werden beispielsweise Teile des Quellcodes zu Testzwecken kurzweilig auskommentiert. Folgendes Beispiel soll dies demonstrieren:

Crystal Clear action button cancel.svg
1 #include <iostream>                                     /* Ein- und Ausgabebibliothek */
2 
3 int main(){                                             /* Hauptfunktion */
4 /*
5     std::cout << "Hallo, du schöne Welt!" << std::endl; /* Ausgabe */
6 */
7 }

Das würde nicht funktionieren. Wenn hingegen die anderen Kommentare benutzt werden, gibt es solche Probleme nicht:

CrystalClearActionApply.svg
1 #include <iostream>                                     // Ein- und Ausgabebibliothek
2 
3 int main(){                                             // Hauptfunktion
4     /*
5     std::cout << "Hallo, du schöne Welt!" << std::endl; // Ausgabe
6     */
7 }

Im ersten Beispiel wird die Einleitung von /* Ausgabe */ einfach ignoriert. Der abschließende Teil beendet den Kommentar, der die Code-Zeile auskommentieren soll und der eigentliche Abschluss führt zu einem Kompilierfehler. Zugegeben, das ist nicht weiter schlimm, denn solch ein Fehler ist schnell gefunden, aber ihn von vorn herein zu vermeiden, ist eben noch zeitsparender. Im übrigen muss bei einzeiligen Kommentaren oft weniger geschrieben werden. Eine Ausnahme bilden Kommentare, die einfach zu lang sind, um sie auf eine Zeile zu schreiben. Dennoch sollten auch sie durch //-Kommentare realisiert werden.

Nuvola-inspired-terminal.svg

viel Code…


1 // Ich bin ein Beispiel für einen langen Kommentar, der durch doppelte
2 // Schrägstriche über mehrere Zeilen geht. Würde ich am Dateianfang stehen,
3 // hätte man mich wahrscheinlich mit anderen Kommentarzeichen ausgestattet,
4 // aber da ich hier eindeutig von einer Riesenmenge Quelltext umgeben bin,
5 // hat man sich trotz der erhöhten Schreibarbeit für // entschieden

noch viel mehr Code…

Symbol confirmed.svg
Tipp

Viele Texteditoren enthalten eine Tastenkombination, über die sich Text ein- und auskommentieren lässt. Besonders für längere Codepassagen ist dies nützlich.

Rechnen (lassen) [Bearbeiten]

In diesem Kapitel soll unser Rechner einmal das tun, was er ohnehin am besten kann: Rechnen. Wir werden uns derweil zurücklehnen und zusehen oder besser gesagt, werden wir das tun, nachdem wir ihm mitgeteilt haben, was er rechnen soll.

Einfaches Rechnen[Bearbeiten]

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 
3 int main(){
4     std::cout << "7 + 8 = " << 7 + 8 << std::endl; // Ausgabe einer Rechnung
5 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 7 + 8 = 15

Zugegebenermaßen hätten Sie diese Rechnung wahrscheinlich auch im Kopf lösen können aber warum sollten Sie sich so unnötig anstrengen. Ihr Rechner liefert doch auch das richtige Ergebnis, und wenn Sie dies mit der Eingabe von Zahlen kombinieren, können Sie sogar bei jedem Programmdurchlauf zwei unterschiedliche Zahlen addieren:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main(){
 4     int summand1, summand2;                    // Anlegen von zwei Variablen
 5 
 6     std::cin >> summand1 >> summand2;          // Zwei Zahlen eingeben
 7 
 8     std::cout << summand1 << " + " << summand2 // beide durch " + " getrennt wieder ausgeben
 9               << " = "                         // " = " ausgeben
10               << summand1 + summand2           // Ergebnis berechnen und ausgeben
11               << std::endl;                    // Zeilenumbruch
12 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Benutzereingabe: 774
2 Benutzereingabe: 123
3 774 + 123 = 897

Das Ergebnis lässt sich natürlich auch in einer Variablen zwischenspeichern. Folgendes Beispiel demonstriert diese Möglichkeit:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main(){
 4     int summand1, summand2, ergebnis;          // Anlegen von drei Variablen
 5 
 6     std::cin >> summand1 >> summand2;          // Zwei Zahlen eingeben
 7 
 8     ergebnis = summand1 + summand2;            // Ergebnis berechnen
 9 
10     std::cout << summand1 << " + " << summand2 // beide durch " + " getrennt wieder ausgeben
11               << " = "                         // " = " ausgeben
12               << ergebnis                      // Ergebnis ausgeben
13               << std::endl;                    // Zeilenumbruch
14 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Benutzereingabe: 400
2 Benutzereingabe: 300
3 400 + 300 = 700

Die großen Vier[Bearbeiten]

C++ beherrscht die vier Grundrechenarten: Addition (+), Subtraktion (-), Multiplikation (*) und Division (/). Genau wie in der Mathematik gilt auch in C++ die Regel: Punktrechnung geht vor Strichrechnung und Klammern gehen über alles. Das folgende Beispiel soll eine komplexere Rechnung demonstrieren:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main(){
 4     int ergebnis;                                       // Anlegen einer Variable
 5 
 6     ergebnis = ((3 + 3*4)/5 - 1)*512 - 768;             // Ergebnis berechnen
 7 
 8     std::cout << "((3 + 3*4)/5 - 1)*512 - 768 = "       // Aufgabe ausgeben
 9               << ergebnis                               // Ergebnis ausgeben
10               << std::endl;                             // Zeilenumbruch
11 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 ((3 + 3*4)/5 - 1)*512 - 768 = 256

Gerechnet wird in dieser Reihenfolge:

   3 *   4 =   12
   3 +  12 =   15
  15 /   5 =    3
   3 -   1 =    2
   2 * 512 = 1024
1024 - 768 =  256

Sie sollten darauf achten, immer die gleiche Anzahl öffnende und schließende Klammern zu haben, denn dies ist ein beliebter Fehler, der von Anfängern meist nicht so schnell gefunden wird. Compiler bringen in solchen Fällen nicht selten Meldungen, die einige Zeilen unter dem eigentlichen Fehler liegen.

Zusammengesetzte Operatoren[Bearbeiten]

C++ ist eine Sprache für schreibfaule Menschen. Daher gibt es die Möglichkeit, die Rechenoperatoren mit dem Zuweisungsoperator zu kombinieren. Dies sieht dann folgendermaßen aus:

Nuvola-inspired-terminal.svg
1 zahl  = 22;
2 zahl += 5; // zahl = zahl + 5;
3 zahl -= 7; // zahl = zahl - 7;
4 zahl *= 2; // zahl = zahl * 2;
5 zahl /= 4; // zahl = zahl / 4;

Als Kommentar sehen Sie die Langfassung geschrieben. Diese Kurzschreibweise bedeutet nicht mehr, als dass die vor (!) dem Zuweisungsoperator stehende Rechenoperation mit der Variablen auf der linken Seite und dem Wert auf der rechten Seite ausgeführt und das Ergebnis der Variablen auf der linken Seite zugewiesen wird. Sie sollten diese Kurzschreibweise der ausführlichen vorziehen, da sie nicht nur die Finger schont, sondern auch noch ein wenig schneller ist.

Am besten werden Sie dies wahrscheinlich verstehen, wenn Sie es einfach ausprobieren. Stehen auf der rechten Seite noch weitere Rechenoperationen, so werden diese zuerst ausgeführt. Das Ganze stellt sich dann also folgendermaßen dar:

Nuvola-inspired-terminal.svg
1 zahl  = 5;
2 zahl *= 3 + 4; // zahl = zahl * (3 + 4);

Inkrement und Dekrement[Bearbeiten]

Inkrementieren bedeutet, den Wert einer Variablen um 1 zu erhöhen, entsprechend bedeutet Dekrementieren 1 herunterzuzählen. Dem Inkrementoperator schuldet C++ übrigens seinen Namen. Die beiden Operatoren gibt es jeweils in der Präfix- und der Postfix-Variante. Insgesamt ergeben sich also vier Operatoren:

Nuvola-inspired-terminal.svg
1 zahl = 5;
2 
3 zahl++; // Inkrement Postfix (zahl == 6)
4 ++zahl; // Inkrement Präfix  (zahl == 7)
5 zahl--; // Dekrement Postfix (zahl == 6)
6 --zahl; // Dekrement Präfix  (zahl == 5)

Der Unterschied zwischen Inkrement (++) und Dekrement (--) ist ohne größeres Nachdenken erkennbar. Der Sinn von Präfix und Postfix ergibt sich hingegen nicht sofort von selbst. C++ schuldet seinen Namen der Postfix-Variante.

Der Unterschied zwischen Präfix und Postfix besteht im Rückgabewert. Die Präfix-Variante erhöht den Wert einer Zahl um 1 und gibt diesen neuen Wert zurück. Die Postfix-Variante erhöht den Wert der Variablen ebenfalls um 1, gibt jedoch den Wert zurück, den die Variable vor der Erhöhung hatte.

Das folgende kleine Programm zeigt den Unterschied:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main(){
 4     int zahl;                             // Anlegen einer Variable
 5 
 6     std::cout << "zahl direkt ausgeben:\n";
 7 
 8     zahl = 5;                             // zahl den Wert 5 zuweisen
 9 
10     std::cout << zahl << ' ';             // zahl ausgeben
11 
12     zahl++;                               // Inkrement Postfix (zahl == 6)
13     std::cout << zahl << ' ';             // zahl ausgeben
14 
15     ++zahl;                               // Inkrement Präfix  (zahl == 7)
16     std::cout << zahl << ' ';             // zahl ausgeben
17 
18     zahl--;                               // Dekrement Postfix (zahl == 6)
19     std::cout << zahl << ' ';             // zahl ausgeben
20 
21     --zahl;                               // Dekrement Präfix  (zahl == 5)
22     std::cout << zahl << ' ';             // zahl ausgeben
23 
24     std::cout << "\nRückgabewert des Operators ausgeben:\n";
25 
26     zahl = 5;                             // zahl den Wert 5 zuweisen
27 
28     std::cout << zahl   << ' ';           // zahl ausgeben
29     std::cout << zahl++ << ' ';           // Inkrement Postfix (zahl == 6)
30     std::cout << ++zahl << ' ';           // Inkrement Präfix  (zahl == 7)
31     std::cout << zahl-- << ' ';           // Dekrement Postfix (zahl == 6)
32     std::cout << --zahl << ' ';           // Dekrement Präfix  (zahl == 5)
33 
34     std::cout << "\nEndwert von zahl: " << zahl << std::endl;
35 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 zahl direkt ausgeben:
2 5 6 7 6 5
3 Rückgabewert des Operators ausgeben:
4 5 5 7 7 5
5 Endwert von zahl: 5
Symbol move vote.svg
Thema wird später näher erläutert…

In einem späteren Kapitel werden Sie noch ein paar zusätzliche Informationen erhalten, was beim Rechnen schief gehen kann und wie Sie es vermeiden. Wenn Sie beim Herumexperimentieren mit Rechenoperationen plötzlich scheinbar unerklärliche Ergebnisse erhalten, dann ist es an der Zeit einen Blick auf dieses Kapitel zu werfen.

Crystal source cpp.png

Im Anhang zu diesem Kapitel finden Sie:

  • Aufgaben und zugehörige Musterlösungen.
Aufgaben
Symbol neutral vote.svg Aufgabe 1: Rechnen Sie die Ergebnisse der folgenden Aufgaben aus und schreiben Sie ein Programm, welches das Gleiche tut.
zahl  = (500 - 100*(2 + 1))*5
zahl  = (zahl - 700)/3
zahl += 50*2
zahl *= 10 - 8
zahl /= zahl - 200
 
Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2  
 3 int main(){
 4     int zahl;
 5  
 6     zahl  = (500 - 100*(2 + 1))*5;  // 1000
 7     zahl  = (zahl - 700)/3;         //  100
 8     zahl += 50*2;                   //  200
 9     zahl *= 10 - 8;                 //  400
10     zahl /= zahl - 200;             //    2
11     
12     std::cout << "zahl: " << zahl;
13 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 zahl: 2

Variablen, Konstanten und ihre Datentypen [Bearbeiten]

Variablen sind Behälter für Werte, sie stellen gewissermaßen das Gedächtnis eines Programms bereit. Konstanten sind spezielle Variablen, sie ändern ihren Wert nie. Der Datentyp einer Variablen oder Konstanten beschreibt, wie der Inhalt zu verstehen ist.

Ein Rechner kennt nur zwei Grundzustände: 0 und 1. Durch eine Aneinanderreihung solcher Zustände lassen sich mehr verschiedene Werte darstellen. Mit acht aufgereihten Zuständen (= 8 Bit = 1 Byte) lassen sich bereits 256 verschiedene Werte darstellen. Diese Werte kann man beispielsweise als Ganzzahl, (Schrift-)Zeichen, Wahrheitswert oder Gleitkommazahl interpretieren. Der Datentyp gibt daher Auskunft darüber, um was es sich handelt.

Der C++-Standard schreibt nicht vor, dass ein Byte aus genau 8 Bit bestehen muss – diese Anzahl ist jedoch weitverbreitet. Es ist also möglich, dass auf einer speziellen Prozessorarchitektur z. B. eine Anzahl von 10 Bit als „ein Byte“ festgelegt ist. Dies ist jedoch äußerst selten der Fall, daher werden wir im Folgenden annehmen, dass ein Byte aus 8 Bit besteht.

Datentypen[Bearbeiten]

Zunächst sollen die Datentypen von C++ beschrieben werden, denn sie sind grundlegend für eine Variable oder Konstante. Die vier wichtigsten (Gruppen von) Datentypen sind: Wahrheitswerte, Zeichen, Ganzzahlen und Gleitkommazahlen.

Wahrheitswerte[Bearbeiten]

Der Datentyp für Wahrheitswerte heißt in C++ bool, was eine Abkürzung für boolean ist. Er kann nur zwei Zustände annehmen: true (wahr) oder false (falsch). Obwohl eigentlich 1 Bit ausreichen würde, hat bool mindestens eine Größe von einem Byte (also 8 Bit), denn 1 Byte ist die kleinste adressierbare Einheit und somit die Minimalgröße für jeden Datentyp. Es ist auch durchaus möglich, dass ein bool beispielsweise 4 Byte belegt, da dies auf einigen Prozessorarchitekturen die Zugriffsgeschwindigkeit erhöht.

Zeichen[Bearbeiten]

Zeichen sind eigentlich Ganzzahlen. Sie unterscheiden sich von diesen nur bezüglich der Ein- und Ausgabe. Jeder Zahl ist ein Zeichen zugeordnet. Mit den Zahlen lässt sich ganz normal rechnen aber bei der Ausgabe erscheint das zugeordnete Zeichen auf dem Bildschirm. Welches Zeichen welcher Zahl entspricht, wird durch den verwendeten Zeichensatz festgelegt.

Die meisten Zeichensätze beinhalten den sogenannten ASCII-Code (American Standard Code for Information Interchange), welcher die Zeichen 0 – 127 belegt. Er enthält 32 Steuerzeichen (0 – 31) und 96 druckbare Zeichen (32 – 127).

char ist der Standard-Datentyp für Zeichen. Er ist in der Regel 1 Byte groß und kann somit 256 verschiedene Zeichen darstellen. Diese genügen für einen erweiterten ASCII-Code, welcher zum Beispiel auch deutsche Umlaute definiert. Für Unicode-Zeichen gibt es die Datentypen char16_t mit einer Größe von 2 Byte und char32_t mit einer Größe von 4 Byte. Früher nutzte man für Unicode auch den Datentyp wchar_t, welcher je nach System 2 oder 4 Byte groß war. Dieser Datentyp sollte jedoch nicht mehr eingesetzt werden. Die folgende Liste enthält einige nützliche Links zu Artikeln der Wikipedia:

Es gibt in C++ 4 eingebaute Datentypen für Zeichen:

  • char
  • char16_t
  • char32_t
  • wchar_t (veraltet)

Ganzzahlen[Bearbeiten]

C++ definiert folgende eingebaute Datentypen für Ganzzahlen:

Schreibweise Typ Anzahl Bits nach data model
C++ standard LP32 ILP32 LLP64 LP64
signed char signed char mindestens
8
8 8 8 8
unsigned char unsigned char
short short mindestens
16
16 16 16 16
short int
signed short
signed short int
unsigned short unsigned short
unsigned short int
int int mindestens
16
16 32 32 32
signed
signed int
unsigned unsigned
unsigned int
long long mindestens
32
32 32 32 64
long int
signed long
signed long int
unsigned long unsigned long
unsigned long int
long long long long mindestens
64
64 64 64 64
long long int
signed long long
signed long long int
unsigned long long unsigned long long
unsigned long long int

Alle Schreibweisen sind identisch zu dem jeweils zugeordneten Typ. Die Schreibweise, die in der Typ-Spalte verwendet wird, ist die in diesem Buch genutzte Schreibweise. In der Praxis finden sie aber, je nachdem wer den Code geschrieben hat, auch die äquivalenten Schreibweisen der ersten Spalte.

Die genaue Anzahl der Bits hängt von der Implementierung ab und wird gemeinhin als data model bezeichnet. Vier data models sind weit verbreitet:

  • 32 Bit Systeme
    • LP32 oder 2/4/4 (int hat 16 Bits, long und Zeiger haben 32 Bits)
      • Win16 API
    • ILP32 oder 4/4/4 (int, long und Zeiger haben 32 Bits)
      • Win32 API
      • Unix und Unixoide Systeme (Linux, Mac OS X)
  • 64 Bit Systeme
    • LLP64 oder 4/4/8 (int und long haben 32 Bits, Zeiger haben 64 Bits)
      • Win64 API
    • LP64 oder 4/8/8 (int hat 32 Bits, long und Zeiger haben 64 Bits)
      • Unix und Unixoide Systeme (Linux, Mac OS X)

Der Wertebereich von vorzeichenbehafteten Typen (»signed«) berechnet sich durch:

Für vorzeichenlose Typen (»unsigned«) berechnet er sich durch:

Auffällig sind in der Tabelle die beiden char-Datentypen. Im Gegensatz zu den anderen Datentypen gibt es hier keine Schreibweise, in der am Ende ein int steht. Und was noch wichtiger ist, signed char darf nicht mit char abgekürzt werden! Das liegt daran, dass char ein Datentyp für Zeichen ist, während signed char und unsigned char üblicherweise Zahlen repräsentieren. Historisch bedingt ist die Trennung zwischen Zeichen und Zahlen in C++ leider sehr unsauber, was sich vor allem bei den char-Datentypen zeigt.

Sowohl signed char, als auch unsigned char werden bei der Ein- und Ausgabe als Zeichen behandelt, weshalb hier immer zuvor nach int gecasted (umgewandelt, Näheres im Kapitel Casts) werden muss. Der Datentyp char kann vom Wertebereich her je nach Compiler entweder zu signed char oder zu unsigned char identisch sein. Zu beachten ist jedoch, dass char dennoch ein eigenständiger Typ ist! Für den Augenblick ist diese Unterscheidung nicht so wichtig, wir werden jedoch noch einmal auf dieses (im Kontext von Templates wichtige) Detail zu sprechen kommen.

Für den Augenblick sollten Sie sich merken: Wenn Sie eine Zahl mit einer 1-Byte-Variablen repräsentieren wollen, dann nutzen Sie signed char oder unsigned char, wenn Sie ein Zeichen repräsentieren wollen, verwenden Sie char.

Wählen Sie ein int, wenn dieser Typ alle Zahlen des nötigen Wertebereichs aufnehmen kann, bei vorzeichenlosen Zahlen verwenden Sie unsigned. Reicht dieser Wertebereich nicht aus und ist long größer, dann nehmen Sie long (bzw. unsigned long). short und unsigned short sollte nur Verwendung finden, wenn Speicherplatz knapp ist, etwa bei Verwendung großer Arrays, oder wenn Low-Level-Datenstrukturen festgelegter Größe benutzt werden müssen. Achten Sie darauf, dass der theoretisch größte Wert, welcher für Ihre Variable auftreten könnte, den größten möglichen Wert nicht überschreitet. Selbiges gilt natürlich auch für die Unterschreitung des kleinstmöglichen Wertes.

Ein Unter- oder Überlauf ist übrigens durchaus möglich. Die meisten Compiler bieten zwar eine Option an, um in einem solchen Fall einen Fehler zu erzeugen, aber diese Option ist standardmäßig nicht aktiv. Im folgenden kleinen Beispiel werden die Datentypen short (min: -32768, max: 32767) und unsigned short benutzt und bei beiden wird je ein Unter- und ein Überlauf ausgeführt:

Nuvola-inspired-terminal.svg

Davon ausgehend, dass short eine Größe von 2 Byte hat, finden je zwei Über- bzw. Unterläufe statt.


 1 #include <iostream>
 2 
 3 int main(){
 4     short variable1 = 15000;
 5     unsigned short variable2 = 15000;
 6 
 7     std::cout << "short Variable:          " << variable1 << std::endl
 8               << "unsigned short Variable: " << variable2 << std::endl
 9               << "+30000\n\n";
10 
11     variable1 += 30000;
12     variable2 += 30000;
13 
14     std::cout << "short Variable:          " << variable1 << " (Überlauf)" << std::endl
15               << "unsigned short Variable: " << variable2 << std::endl
16               << "+30000\n\n";
17 
18     variable1 += 30000;
19     variable2 += 30000;
20 
21     std::cout << "short Variable:          " << variable1 << std::endl
22               << "unsigned short Variable: " << variable2 << " (Überlauf)" << std::endl
23               << "-30000\n\n";
24 
25     variable1 -= 30000;
26     variable2 -= 30000;
27 
28     std::cout << "short Variable:          " << variable1 << std::endl
29               << "unsigned short Variable: " << variable2 << " (Unterlauf)" << std::endl
30               << "-30000\n\n";
31 
32     variable1 -= 30000;
33     variable2 -= 30000;
34 
35     std::cout << "short Variable:          " << variable1 << " (Unterlauf)" << std::endl
36               << "unsigned short Variable: " << variable2 << std::endl;
37 }
Crystal Clear app kscreensaver.svg
Ausgabe:
 1 short Variable:          15000
 2 unsigned short Variable: 15000
 3 +30000
 4 
 5 short Variable:          -20536 (Überlauf)
 6 unsigned short Variable: 45000
 7 +30000
 8 
 9 short Variable:          9464
10 unsigned short Variable: 9464 (Überlauf)
11 -30000
12 
13 short Variable:          -20536
14 unsigned short Variable: 45000 (Unterlauf)
15 -30000
16 
17 short Variable:          15000 (Unterlauf)
18 unsigned short Variable: 15000

Verständlicher wird dieses Phänomen, wenn man die Zahlen binär (Duales Zahlensystem) darstellt. Der Einfachheit halber beginnen wir mit der Darstellung der unsigned short Variablen, die ersten beiden Additionen von jeweils 30000:

Addition im Dualsystem mit unsigned short als Datentyp

Rechnung 1
        |0011101010011000| 15000
     +  |0111010100110000| 30000
--------------------------------
Merker  |111      11     |
--------------------------------
     =  |1010111111001000| 45000

Rechnung 2
        |1010111111001000| 45000
     +  |0111010100110000| 30000
--------------------------------
Merker 1|1111111         |
--------------------------------
     = 1|0010010011111000| 9464

Die beiden Rechnungen weisen keinerlei Besonderheiten auf. Da nur die letzten 16 Ziffern beachtet werden (2 Byte = 16 Bit), entfällt in der zweiten Rechnung die 1 vor dem Vertikalstrich, wodurch das Ergebnis (in dezimaler Schreibweise) 9464 und nicht 75000 lautet. Anschließend werden von der unsigned short -Ganzzahl zwei Mal jeweils 30000 subtrahiert:

Subtraktion im Dualsystem mit unsigned short als Datentyp

Rechnung 3
          |0010010011111000| 9464
     -    |0111010100110000| 30000
----------------------------------
Merker...1|1111111         |
----------------------------------
     =...1|1010111111001000| 45000

Rechnung 4
          |1010111111001000| 45000
     -    |0111010100110000| 30000
----------------------------------
Merker    |111      11     |
----------------------------------
     =    |0011101010011000| 15000

In diesem Fall ist die zweite Rechnung unauffällig. In der ersten Rechnung wird hingegen eine große Zahl von einer kleineren abgezogen, was zu einem negativen Ergebnis führt – oder besser – führen würde, denn die Untergrenze ist in diesem Fall 0. Dort wo die 3 Punkte stehen, folgt eine unendliche Anzahl von Einsen. Dies ist keineswegs nur bei Dualzahlen der Fall. Wenn Sie im dezimalen System eine große Zahl von einer kleineren nach den üblichen Regeln der schriftlichen Subtraktion abziehen, so erhalten Sie ein ähnliches Ergebnis:

          24
     -    31
------------
Merker...1
------------
     =...993

Im Programm werden mit der Vorzeichen-behafteten Ganzzahl, der short-Variablen, ebenfalls vier Rechnungen durchgeführt. Deren duale Darstellung wird Ihnen sehr bekannt vorkommen:

Addition im Dualsystem mit short als Datentyp

Rechnung 1
        |0|011101010011000| 15000
     +  |0|111010100110000| 30000
--------------------------------
Merker  |1|11      11     |
--------------------------------
     =  |1|010111111001000| -20536

Rechnung 2
        |1|010111111001000| -20536
     +  |0|111010100110000| 30000
--------------------------------
Merker 1|1|111111         |
--------------------------------
     = 1|0|010010011111000| 9464

Subtraktion im Dualsystem mit short als Datentyp

Rechnung 3
          |0|010010011111000| 9464
     -    |0|111010100110000| 30000
----------------------------------
Merker...1|1|111111         |
----------------------------------
     =...1|1|010111111001000| -20536

Rechnung 4
          |1|010111111001000| -20536
     -    |0|111010100110000| 30000
----------------------------------
Merker    |1|11      11     |
----------------------------------
     =    |0|011101010011000| 15000

Die dualen Ziffern sind die gesamte Zeit über exakt die gleichen, der einzige Unterschied besteht darin, dass negative Zahlen in Zweierkomplement-Darstellung repräsentiert werden. Dies führt zu einer veränderten Darstellung im Dezimalsystem.

Meist ist es besser, wenn man die genaue Größe der Datentypen festlegt. Hierfür muss der Header cstdint eingebunden werden. Darin sind Alias-Namen für die eingebauten Datentypen definiert:

  • std::int8_t optional
  • std::int16_t optional
  • std::int32_t optional
  • std::int64_t optional
  • std::int_fast8_t
  • std::int_fast16_t
  • std::int_fast32_t
  • std::int_fast64_t
  • std::int_least8_t
  • std::int_least16_t
  • std::int_least32_t
  • std::int_least64_t
  • std::intmax_t
  • std::intptr_t optional
  • std::uint8_t optional
  • std::uint16_t optional
  • std::uint32_t optional
  • std::uint64_t optional
  • std::uint_fast8_t
  • std::uint_fast16_t
  • std::uint_fast32_t
  • std::uint_fast64_t
  • std::uint_least8_t
  • std::uint_least16_t
  • std::uint_least32_t
  • std::uint_least64_t
  • std::uintmax_t
  • std::uintptr_t optional

Alle Datentypen, die mit int beginnen, stehen für signed Datentypen, alle, die mit uint beginnen, für unsigned Datentypen. Die mit »optional« gekennzeichneten Datentypen sind nur definiert, wenn sie durch die Plattform auch nativ unterstützt werden. Dies ist jedoch auf den schon oben referenzierten Systemen immer der Fall. Lediglich auf Mikrocontrollern oder ähnlichem kann es hier zu Problemen kommen.

Die least-Datentypen entsprechen dem kleinstem Typ, der mindestens so viele Bits hat, die fast-Datentypen dem schnellsten Datentyp, der mindestens so viele Bits hat. Die max-Datentypen entsprechen dem jeweils größten verfügbaren Datentyp. Die ptr-Datentypen haben exakt so viele Bit wie ein Zeiger (siehe Kapitel Zeiger) und sind daher ebenfalls nur verfügbar, wenn die Hardware einen entsprechenden Integer-Datentyp nativ unterstützt.

In der Regel ist es am sinnvollsten die exakten Datentypen zu verwenden, also etwa std::uint16_t, wenn man einen Datentyp möchte, der 16 Bit hat und vorzeichenlos ist. Die fast-Datentypen können nötigenfalls zur Geschwindigkeitsoptimierung innerhalb von Funktionen eingesetzt werden.

Gleitkommazahlen[Bearbeiten]

Eine Gleitkommavariable kann sich eine bestimmte Anzahl Ziffern merken und dazu die Position des Kommas. Das Wissen über den internen Aufbau einer solchen Zahl werden Sie wahrscheinlich eher selten bis nie brauchen, daher sei an dieser Stelle auf den Wikipediaartikel über Gleitkommazahlen verwiesen. In C++ werden Sie Gleitkommazahlen/-variablen für das Rechnen mit Kommazahlen verwenden. Es gibt drei Datentypen für Gleitkommazahlen, die in der folgenden Tabelle mit ihren üblichen Werten aufgelistet sind:

Typ Speicherplatz Wertebereich kleinste positive Zahl Genauigkeit
float 4 Byte 6 Stellen
double 8 Byte 12 Stellen
long double 10 Byte 18 Stellen

Die Auswahl eines Gleitkommadatentyps ist weniger einfach als die einer Ganzzahl. Wenn Sie nicht genau wissen, was Sie nehmen sollen, ist double in der Regel eine gute Wahl. Sobald Sie erst einmal ausreichend Erfahrung haben, wird es Ihnen leichter fallen abzuschätzen, ob float oder long double für Ihr Problem vielleicht eine bessere Wahl ist.

Variablen[Bearbeiten]

Bevor eine Variable verwendet werden kann, muss sie dem Compiler bekannt gegeben werden. Dies bezeichnet man als Deklaration der Variablen. Das eigentliche Anlegen einer Variablen, so dass der Compiler Speicherplatz für sie reserviert, wird Definition genannt. Eine Definition ist immer auch eine Deklaration und bei Variablen ist der Unterschied zwischen Deklaration und Definition etwas zu kompliziert, um ihn an dieser Stelle bereits zu erklären. Sie werden die Begriffe zunächst in Zusammenhang mit Funktionen kennenlernen und später auch für Variablen. Sie sollten sich jedoch jetzt bereits merken, dass es sich beim Anlegen der Variablen, die wir verwenden, immer um Definitionen handelt. Dies ist insofern wichtig, als dass eine Definition immer nur einmal geschrieben werden darf, während eine Deklaration beliebig oft vorgenommen werden kann. Um einen Vergleich zur realen Welt zu ziehen, wollen wir das Entstehen neuen Lebens betrachten. Sie können beliebig oft erzählen, dass ein bestimmtes Kind geboren wird. Tatsächlich geschehen kann dies aber nur einmal. Im vorherigen Kapitel haben wir bereits mit Variablen vom Typ int gerechnet. Nun sollen Sie lernen, wie Variablen in C++ angelegt werden. Die allgemeine Syntax lautet:

Crystal Project Tutorials.png
Syntax:
«Datentyp» «Name»;
«Nicht-C++-Code», »optional«

Außerdem ist es möglich, mehrere Variablen des gleichen Typs hintereinander anzulegen:

Crystal Project Tutorials.png
Syntax:
«Datentyp» «Variable1», «Variable2», «Variable3»;
«Nicht-C++-Code», »optional«

Auch kann man einer Variablen einen Anfangswert geben, dies bezeichnet man als Initialisierung. Es gibt zwei syntaktische Möglichkeiten (Schreibweisen) für Initialisierungen, welche anhand einer int Variable gezeigt werden soll:

Nuvola-inspired-terminal.svg
1 int zahl=100;  // Möglichkeit 1
2 int zahl(100); // Möglichkeit 2

Die erste Variante ist weit verbreitet aber nicht zwingend besser. Bei den fundamentalen Datentypen von C++ spielt es keine Rolle, welche Variante Sie verwenden, aber bei komplexeren Datentypen (Klassen) kann es zu Verwechslungen mit dem Zuweisungsoperator kommen, wenn Sie Möglichkeit 1 benutzen. Den genauen Unterschied zwischen einer Initialisierung und einer Zuweisung werden Sie kennenlernen, sobald es um Klassen geht. Für den Moment sollten Sie sich für eine der beiden Varianten entscheiden. Für Möglichkeit 1 spricht die große Verbreitung und die damit verbundene intuitive Nutzung. In diesem Buch werden wir diese erste Methode verwenden und in Zusammenhang mit Klassen auch eine Empfehlung geben, wann diese Methode zur besseren Übersicht im Quellcode beitragen kann. Für Möglichkeit 2 spricht hingegen, dass diese Syntax für Initialisierungen immer gültig ist. Nebenbei wird bei dieser Methode deutlich, dass es sich um eine Initialisierung handelt.

Variablen mit Anfangswerten können natürlich auch hintereinander angelegt werden, sofern sie den gleichen Datentyp besitzen, allerdings ist davon aus Gründen der Übersichtlichkeit abzuraten.

Nuvola-inspired-terminal.svg
1 int zahl1(77), zahl2, zahl3=58; // Drei int-Variablen, von denen zwei Anfangswerte haben

Wenn Sie einer Variablen keinen Anfangswert geben, müssen Sie ihr später im Programm noch einen Wert zuweisen, bevor Sie mit ihr arbeiten (also damit rechnen oder den Inhalt ausgeben lassen). Weisen Sie einer solchen Variablen keinen Wert zu und benutzen sie, so kann der Inhalt zufällig sein. Genaugenommen handelt es sich dann um die Bitfolge, die an der Stelle im Speicher stand, an der Ihre Variable angelegt wurde. Es gibt in C++ Regeln, in welchen Fällen der Compiler eine Variable ohne explizite Initialisierung implizit mit 0 initialisiert und wann stattdessen einfach der aktuelle Speicherinhalt stehen bleibt. Allerdings sind diese Regeln so kompliziert, dass es sich nicht lohnt, sie sich zu merken. Denn sollte je ein anderer Programmierer Ihren Code lesen, so muss auch dieser die Regeln kennen, um den Code sofort verstehen zu können. Das nachfolgende kleine Programm zeigt einen Fall, in dem C++ besagt, dass keine implizite Initialisierung mit 0 stattfindet.

Nuvola-inspired-terminal.svg
 1 #include <iostream>                                         // Ein-/Ausgabe
 2 
 3 int main(){
 4     int zahl;                                               // Ganzzahlige Variable
 5     double kommazahl1, kommazahl2;                          // Gleitkommavariablen
 6     char zeichen;                                           // Zeichenvariable
 7 
 8     std::cout << "zahl: "       << zahl       << std::endl  // Ausgabe der Werte
 9               << "kommazahl1: " << kommazahl1 << std::endl  // welche jedoch
10               << "kommazahl2: " << kommazahl2 << std::endl  // nicht festgelegt
11               << "zeichen: "    << zeichen    << std::endl; // wurden
12 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 zahl: -1211024315
2 kommazahl1: 4.85875e-270
3 kommazahl2: -3.32394e-39
4 zeichen: f

Die Ausgabe kann bei jedem Ausführen des Programms anders lauten. Sollte dies bei Ihnen nicht der Fall sein, so stehen nur zufällig die gleichen Werte an der Stelle im Speicher, welchen die jeweilige Variable belegt. Spätestens nach einem Neustart Ihres Rechners haben Sie höchstwahrscheinlich eine andere Ausgabe. Variablen keinen Anfangswert zu geben, ist beispielsweise sinnvoll, wenn Sie vorhaben, über std::cin einen Wert in die Variable einzulesen. Dennoch würde es auch in diesem Fall keinen Schaden anrichten, wenn Sie die Variablen explizit mit 0 initialisieren.

Nuvola-inspired-terminal.svg
 1 #include <iostream>                                         // Ein-/Ausgabe
 2  
 3 int main(){
 4     int zahl;                                               // Ganzzahlige Variable
 5     double kommazahl1, kommazahl2;                          // Gleitkommavariablen
 6     char zeichen;                                           // Zeichenvariable
 7 
 8     std::cout << "Geben Sie bitte durch Leerzeichen getrennt eine Ganzzahl, zwei Kommazahlen "
 9             "und ein Zeichen ein:\n";
10 
11     std::cin >> zahl                                        // Eingabe von Werten
12              >> kommazahl1                                  // mit denen die vier
13              >> kommazahl2                                  // Variablen gefüllt
14              >> zeichen;                                    // werden
15 
16     std::cout << "Zahl: "       << zahl       << std::endl  // Ausgabe der Werte
17               << "Kommazahl1: " << kommazahl1 << std::endl  // welche zuvor
18               << "Kommazahl2: " << kommazahl2 << std::endl  // eingegeben
19               << "Zeichen: "    << zeichen    << std::endl; // wurden
20 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Geben Sie bitte durch Leerzeichen getrennt eine Ganzzahl, zwei Kommazahlen und ein Zeichen ein:
2 Benutzereingabe: 6 8.4 6.0 g
3 Zahl: 6
4 Kommazahl1: 8.4
5 Kommazahl2: 6
6 Zeichen: g

Konstanten[Bearbeiten]

Konstanten sind, wie schon oben beschrieben, Variablen, welche ihren Wert nicht verändern. Daraus folgt, dass einer Konstanten nur genau ein Mal ein Wert zugewiesen werden kann; in C++ muss dies das Initialisieren mit einem Anfangswert sein, andernfalls hätten Sie eine Konstante mit einem zufälligen Wert und das ergibt kaum einen Sinn. Das Schlüsselwort, um eine Variable zu einer Konstanten zu machen, ist const. Es gehört immer zu dem, was links davon steht, es sei denn, links von ihm steht nichts mehr, dann gehört 'const' zu dem Begriff auf dessen rechter Seite. Dies klingt zwar kompliziert, ist es aber eigentlich gar nicht. Für uns bedeutet es im Moment nur, dass Sie zwei Möglichkeiten haben, eine Variable zu einer Konstanten zu machen:

Nuvola-inspired-terminal.svg
1 const int zahl(400); // Alternativ: const int zahl=400;
2 // oder
3 int const zahl(400); // Alternativ: int const zahl=400;

Beides hat die gleiche Wirkung, wieder ist die erste Variante weit verbreitet und wieder ist die zweite Variante der besseren Lesbarkeit bei komplexeren Datentypen (Arrays von Zeigern Konstante auf Memberfunktionen…) vorzuziehen. Entscheiden Sie sich für die Variante, die Ihnen besser gefällt und verwenden Sie diese. Wichtig ist, dass Sie der Variante, für die Sie sich entscheiden, treu bleiben, wenigstens für die Dauer eines Projekts. Denn Code, in dem sich der Schreibstil ständig ändert, ist schwieriger zu lesen.

Literale und ihre Datentypen[Bearbeiten]

Ein Literal ist eine Angabe im Quellcode, die einen konkreten Wert angibt und einen der oben beschriebenen Datentypen besitzt.

Nuvola-inspired-terminal.svg
1 #include <iostream>                 // Ein-/Ausgabe
2 
3 int main() {
4     std::cout << 100  << std::endl  // 100 ist ein int-Literal
5               << 4.7  << std::endl  // 4.7 ist ein double-Literal
6               << 'h'  << std::endl  // 'h' ist ein char-Literal
7               << true << std::endl; // true ist ein bool-Literal
8 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 100
2 4.7
3 h
4 1

Bei der Ausgabe ist zu beachten, dass Boolean-Werte als 0 (false) bzw. 1 (true) ausgegeben werden.

Automatische Bestimmung des Datentyps[Bearbeiten]

Da die Bestimmung des Typs für einen ganzzahligen Wert etwas schwieriger ist als bei den übrigen, werden wir diese zuletzt behandeln. Bei Gleitkommaliteralen ist festgelegt, dass es sich um double-Werte handelt. Um einen Gleitkommaliteral mit einem anderen Typ zu erhalten, ist ein so genanntes Suffix nötig.

Nuvola-inspired-terminal.svg
1 5.0  // double
2 6.7f // float
3 2.6F // float
4 9.4l // long double
5 4.0L // long double

Eine Zahl mit Komma (.) ist also ein double-Wert. Folgt der Zahl ein f oder ein F wird sie zu einem float-Wert und folgt ihr ein l oder ein L wird sie zu einem long double-Wert. Gleitpunktzahlen können auch in der wissenschaftlichen Schreibweise dargestellt werden.

Nuvola-inspired-terminal.svg
1 5.7e10
2 3.3e-3
3 8.7e876L
4 4.2e-4F

Wie die letzten beiden Beispiele zeigen, können auch hierbei die Suffixe für den Datentyp genutzt werden.

Um ein Zeichen beziehungsweise eine Zeichenkette als char16_t bzw. char32_tzu kennzeichnen, stellt man ein kleines u bzw. großes U voran. Für wchar_t nutzt man ein großes L.

Nuvola-inspired-terminal.svg
1 'a'                 // char
2 u'b'                // char16_t
3 U'b'                // char32_t
4 L'b'                // wchar_t
5 "Ich bin ein Text"  // char const*
6 u"Ich bin ein Text" // char16_t const*
7 U"Ich bin ein Text" // char32_t const*
8 L"Ich bin ein Text" // wchar_t const*

Was das Sternchen (*) hinter dem Datentyp im Kommentar bedeutet, werden Sie in einem späteren Kapitel erfahren. bool kann nur zwei Zustände annehmen, entsprechend gibt es auch nur zwei bool-Literale: true und false.

Nun zu den Ganzzahlen. Neben der dezimalen Darstellung von Zahlen gibt es in C++ auch die Möglichkeit der Binären, Oktalen und Hexadezimalen Darstellung. Um eine Zahl als Binär zu kennzeichnen, wird ein 0b oder 0B vorangestellt, für Oktal wird nur eine 0 (Null) vorangestellt und für eine Hexadezimalzahl wird 0x oder 0X vorangestellt. Die Groß-/Kleinschreibung der hexadezimalen Ziffern a bis f spielt keine Rolle.

Nuvola-inspired-terminal.svg
1 756        // Dezimal,     Dezimal: 756
2 0b10       // Binär,       Dezimal: 2
3 0B111      // Binär,       Dezimal: 7
4 046        // Oktal,       Dezimal: 38
5 0757       // Oktal,       Dezimal: 495
6 0xffff     // Hexadezimal, Dezimal: 65535
7 0X1234ABcd // Hexadezimal, Dezimal: 305441741

Der Datentyp wird durch die Größe des Wertes bestimmt, wobei die folgende Reihenfolge gilt: int, unsigned int, long, unsigned long, long long, unsigned long long. Weiterhin kann jeder Ganzzahl auch explizit das Suffix u oder U für unsigned und ein l oder L für long bzw. ein ll oder LL für long long angehängt werden. Die Reihenfolge ändert sich entsprechend den durch die Suffixe festgelegten Kriterien.

übersichtlichere int-Schreibweise[Bearbeiten]

Es ist außerdem möglich, Integer-Literale an beliebigen Stellen durch das Zeichen ' zu trennen, um die Übersicht zu verbessern. Dies kann insbesondere bei binären Literalen nützlich sein, da diese oft sehr lang sind.

Nuvola-inspired-terminal.svg
1 9'756'432'108         // ' als Tausender-Trennzeichen
2 978'3'446'43981'8     // ' als Trennzeichen für eine ISBN-Nummer
3 0B1111'0000'1010'0101 // ' als Trennzeichen für einen 16 Bit Wert mit 4 Gruppen

Das Wissen über die Datentypen von Literalen werden Sie wahrscheinlich eher selten benötigen, daher reicht es „mal etwas davon gehört zu haben“ und es, wenn nötig, nachzuschlagen.

Rechnen mit unterschiedlichen Datentypen [Bearbeiten]

Sie kennen nun die Datentypen in C++ und haben auch schon mit int-Variablen gerechnet. In diesem Kapitel erfahren Sie, wie man mit Variablen unterschiedlichen Typs rechnet. Es geht also weniger um das Ergebnis selbst, als viel mehr darum, wie der Ergebnisdatentyp lautet.

Ganzzahlen[Bearbeiten]

Das Rechnen mit Ganzzahlen ist leicht zu begreifen. Die „kleinen“ Datentypen werden als int behandelt. Bei den größeren entscheidet der größte Datentyp über den Ergebnistyp. Die folgende Liste zeigt die Zusammenhänge:

char        + char           => int              |    wchar_t        + char           => int
char        + wchar_t        => int              |    wchar_t        + wchar_t        => int
char        + signed char    => int              |    wchar_t        + signed char    => int
char        + unsigned char  => int              |    wchar_t        + unsigned char  => int
char        + short          => int              |    wchar_t        + short          => int
char        + unsigned short => int              |    wchar_t        + unsigned short => int
char        + int            => int              |    wchar_t        + int            => int
char        + unsigned int   => unsigned int     |    wchar_t        + unsigned int   => unsigned int
char        + long           => long             |    wchar_t        + long           => long
char        + unsigned long  => unsigned long    |    wchar_t        + unsigned long  => unsigned long

signed char + char           => int              |    unsigned char  + char           => int
signed char + wchar_t        => int              |    unsigned char  + wchar_t        => int
signed char + signed char    => int              |    unsigned char  + signed char    => int
signed char + unsigned char  => int              |    unsigned char  + unsigned char  => int
signed char + short          => int              |    unsigned char  + short          => int
signed char + unsigned short => int              |    unsigned char  + unsigned short => int
signed char + int            => int              |    unsigned char  + int            => int
signed char + unsigned int   => unsigned int     |    unsigned char  + unsigned int   => unsigned int
signed char + long           => long             |    unsigned char  + long           => long
signed char + unsigned long  => unsigned long    |    unsigned char  + unsigned long  => unsigned long

short       + char           => int              |    unsigned short + char           => int
short       + wchar_t        => int              |    unsigned short + wchar_t        => int
short       + signed char    => int              |    unsigned short + signed char    => int
short       + unsigned char  => int              |    unsigned short + unsigned char  => int
short       + short          => int              |    unsigned short + short          => int
short       + unsigned short => int              |    unsigned short + unsigned short => int
short       + int            => int              |    unsigned short + int            => int
short       + unsigned int   => unsigned int     |    unsigned short + unsigned int   => unsigned int
short       + long           => long             |    unsigned short + long           => long
short       + unsigned long  => unsigned long    |    unsigned short + unsigned long  => unsigned long

int         + char           => int              |    unsigned int   + char           => unsigned int
int         + wchar_t        => int              |    unsigned int   + wchar_t        => unsigned int
int         + signed char    => int              |    unsigned int   + signed char    => unsigned int
int         + unsigned char  => int              |    unsigned int   + unsigned char  => unsigned int
int         + short          => int              |    unsigned int   + short          => unsigned int
int         + unsigned short => int              |    unsigned int   + unsigned short => unsigned int
int         + int            => int              |    unsigned int   + int            => unsigned int
int         + unsigned int   => unsigned int     |    unsigned int   + unsigned int   => unsigned int
int         + long           => long             |    unsigned int   + long           => long oder unsigned long
int         + unsigned long  => unsigned long    |    unsigned int   + unsigned long  => unsigned long

long        + char           => long             |    unsigned long  + char           => unsigned long
long        + wchar_t        => long             |    unsigned long  + wchar_t        => unsigned long
long        + signed char    => long             |    unsigned long  + signed char    => unsigned long
long        + unsigned char  => long             |    unsigned long  + unsigned char  => unsigned long
long        + short          => long             |    unsigned long  + short          => unsigned long
long        + unsigned short => long             |    unsigned long  + unsigned short => unsigned long
long        + int            => long             |    unsigned long  + int            => unsigned long
long        + unsigned int   => unsigned long    |    unsigned long  + unsigned int   => unsigned long
long        + long           => long             |    unsigned long  + long           => unsigned long
long        + unsigned long  => unsigned long    |    unsigned long  + unsigned long  => unsigned long


Zugegebenermaßen wirkt dies erst einmal erschlagend aber es ist eigentlich nicht schwierig zu begreifen. Bei jeder Rechenoperation hat jeder der 2 Operanden, sowie das Ergebnis der Rechnung, einen Datentyp:

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 
3 int main(){
4     char  zahl1=22;
5     short zahl2=40;
6 
7     std::cout << zahl1 * zahl2 << std::endl; // 22   * 40    =  880
8                                              // char + short => int
9 }

Gleitkommarechnen[Bearbeiten]

Beim Rechnen mit Gleitkommazahlen gelten im Grunde die gleichen Regeln wie bei Ganzzahlen. Der Ergebnistyp entspricht auch hier dem des Operanden mit dem „größeren“ Typ. Die aufsteigende Reihenfolge lautet: float, double, long double. Es gilt also:

float       + float       => float
float       + double      => double
float       + long double => long double

double      + float       => double
double      + double      => double
double      + long double => long double

long double + float       => long double
long double + double      => long double
long double + long double => long double

Casting[Bearbeiten]

Casting bedeutet in diesem Zusammenhang die Umwandlung eines Datentyps in einen anderen. Diese Typumwandlung kann sowohl automatisch (implizit) stattfinden, als auch vom Programmierer angegeben (explizit) werden.

Implizite Typumwandlung[Bearbeiten]

Mit impliziter Typumwandlung hatten Sie bereits reichlich zu tun, denn es kann ausschließlich mit Zahlen gerechnet werden, die den gleichen Typ besitzen.

Beispiele:

char  + int          => int          | int          + int          => int
short + unsigned int => unsigned int | unsigned int + unsigned int => unsigned int
float + double       => double       | double       + double       => double

Umformungsregeln[Bearbeiten]

Viele binäre Operatoren, die arithmetische oder Aufzählungsoperanden erwarten, verursachen Umwandlungen und ergeben Ergebnistypen auf ähnliche Weise. Der Zweck ist, einen gemeinsamen Ergebnistyp zu finden. Dieses Muster wird "die üblichen arithmetischen Umwandlungen" genannt, die folgendermaßen definiert sind:

„Gleitkomma geht vor“:

  • Wenn ein Operand vom Typ long double ist, dann wird der andere zu long double konvertiert.
  • Andernfalls, wenn ein Operand vom Typ double ist, dann wird der andere zu double konvertiert.
  • Andernfalls, wenn ein Operand vom Typ float ist, dann wird der andere zu float konvertiert.

Ist kein Gleitkommatyp beteiligt, dann werden folgende Ganzzahl-Umwandlungen auf beide Operanden angewendet:

  • Wenn ein Operand vom Typ unsigned long ist, dann wird der andere zu unsigned long konvertiert.
  • Andernfalls, wenn ein Operand vom Typ long und der andere vom Typ unsigned int, dann wird, falls ein long alle Werte eines unsigned int darstellen kann, der unsigned int-Operand zu long konvertiert; andernfalls werden beide Operanden zu unsigned long konvertiert.
  • Andernfalls, wenn ein Operand vom Typ long ist, dann wird der andere zu long konvertiert.
  • Andernfalls, wenn ein Operand vom Typ unsigned int ist, dann wird der andere zu unsigned int konvertiert.

Hinweis: Der einzig verbleibende Fall ist, dass beide Operanden vom Typ int sind.

Diese Regeln wurden so aufgestellt, dass dabei stets ein Datentyp in einen anderen Datentyp mit "größerem" Wertebereich umgewandelt wird. Das stellt sicher, dass bei der Typumwandlung keine Wertverluste durch Überläufe entstehen. Es können allerdings bei der Umwandlung von Ganzzahlen in float-Werte Rundungsfehler auftreten:

Nuvola-inspired-terminal.svg

Bei dem Beispiel wird von float mit 32 Bit ausgegangen.


1 std::cout << "17000000 + 1.0f = " << std::fixed << 17000000 + 1.0f << std::endl;
Crystal Clear app kscreensaver.svg
Ausgabe:
1 17000000 + 1.0f = 17000000.000000

Für die Berechnung werden zunächst beide Operanden in den Datentyp float konvertiert und anschließend addiert. Das Ergebnis ist wiederum ein float und somit aber nicht in der Lage, Zahlen in der Größenordnung von 17 Millionen mit der nötigen Genauigkeit zu speichern, um zwischen 17000000 und 17000001 zu unterscheiden. Das Ergebnis der Addition ist daher wieder 17000000.

Explizite Typumwandlung[Bearbeiten]

In C++ gibt es dafür zwei Möglichkeiten. Zum einen den aus C übernommenen Cast (Typ)Wert und zum anderen die vier (neuen) C++ Casts.

Nuvola-inspired-terminal.svg
1 static_cast< Zieltyp >(Variable)
2 const_cast< Zieltyp >(Variable)
3 dynamic_cast< Zieltyp >(Variable)
4 reinterpret_cast< Zieltyp >(Variable)
Symbol confirmed.svg
Tipp

Die Leerzeichen zwischen dem Zieltyp und den spitzen Klammern sind nicht zwingend erforderlich, Sie sollten sich diese Notation jedoch angewöhnen. Speziell wenn Sie später mit Templates oder Namensräumen arbeiten, ist es nützlich, Datentypen ein wenig von ihrer Umgebung zu isolieren. Sie werden an den entsprechenden Stellen noch auf die ansonsten möglichen Doppeldeutigkeiten hingewiesen.

Symbol move vote.svg
Thema wird später näher erläutert…

Im Moment benötigen Sie nur den static_cast. Was genau die Unterschiede zwischen diesen Casts sind und wann man welchen einsetzt, erfahren Sie im Kapitel Casts. Auf C-Casts wird in diesem Kapitel ebenfalls eingegangen, merken Sie sich jedoch schon jetzt, dass Sie diese nicht einsetzen sollten. Natürlich müssen Sie sie als C++-Programmierer dennoch kennen, falls Sie einmal auf einen solchen stoßen sollten.

Ganzzahlen und Gleitkommazahlen[Bearbeiten]

Wird mit einer Ganzzahl und einer Gleitkommazahl gerechnet, so ist das Ergebnis vom gleichen Typ wie die Gleitkommazahl.

Rechnen mit Zeichen[Bearbeiten]

Mit Zeichen zu rechnen, ist besonders praktisch. Um beispielsweise das gesamte Alphabet auszugeben, zählen Sie einfach vom Buchstaben 'A' bis einschließlich 'Z':

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 
3 int main(){
4     for(char i = 'A'; i <= 'Z'; ++i){
5         std::cout << i;
6     }
7 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 ABCDEFGHIJKLMNOPQRSTUVWXYZ

Für eine Erklärung des obigen Quellcodes lesen Sie bitte das Kapitel Schleifen.

Wenn Sie binäre Operatoren auf Zeichen anwenden, ist das Ergebnis (mindestens) vom Typ int. Im folgenden Beispiel wird statt eines Buchstabens der dazugehörige ASCII-Wert ausgegeben. Um also wieder ein Zeichen auszugeben, müssen Sie das Ergebnis wieder in den Zeichentyp casten. (Beachten Sie im folgenden Beispiel, dass die Variable i – im Gegensatz zum vorherigen Beispiel – nicht vom Typ char ist):

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main(){
 4     char zeichen = 'A';
 5 
 6     for(int i = 0; i < 26; ++i){
 7         std::cout << zeichen + i << ' ';               // Ergebnis int
 8     }
 9 
10     std::cout << std::endl;
11 
12     for(int i = 0; i < 26; ++i){
13         std::cout << static_cast< char >(zeichen + i); // Ergebnis char
14     }
15 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
2 ABCDEFGHIJKLMNOPQRSTUVWXYZ

Verzweigungen [Bearbeiten]

Eine Verzweigung (bedingte Anweisung, conditional statement) dient dazu, ein Programm in mehrere Pfade aufzuteilen. Beispielsweise kann so auf Eingaben des Benutzers reagiert werden. Je nachdem, was der Benutzer eingibt, ändert sich der Programmablauf.

Falls[Bearbeiten]

Verzweigungen werden mit dem Schlüsselwort if begonnen. In der einfachsten Form sieht das so aus:

Crystal Project Tutorials.png
Syntax:
if(«Bedingung») «Anweisung»
«Nicht-C++-Code», »optional«

Wenn die Bedingung erfüllt ist, wird die Anweisung ausgeführt, ansonsten wird sie übersprungen. Sollen nicht nur eine, sondern mehrere Anweisungen ausgeführt werden, fassen Sie diese mit {...} zu einer Blockanweisung zusammen:

Crystal Project Tutorials.png
Syntax:
if(«Bedingung»){
    «Anweisungen»
}
«Nicht-C++-Code», »optional«

Als Bedingung darf jeder Ausdruck verwendet werden, der einen bool zurückgibt oder dessen Ergebnis sich in einen bool umwandeln lässt. Ganzzahlige und Gleitkommadatentypen lassen sich nach bool umwandeln, die Regel lautet: Ist eine Zahl (exakt) gleich 0, so wird sie als false ausgewertet, andernfalls als true.

Nuvola-inspired-terminal.svg
1 int i;
2 cin >> i;
3 if(i){
4     cout << "Der Benutzer hat einen Wert ungleich 0 eingegeben\n";
5 }

Andernfalls[Bearbeiten]

Das Schlüsselwort else erweitert die Einsatzmöglichkeiten der Verzweigung. Während ein normales (also einzelnes) if einen bestimmten Teil des Codes ausführt, falls eine Bedingung erfüllt ist, stellt else eine Erweiterung dar, anderen Code auszuführen, falls die Bedingung nicht erfüllt ist.

Nuvola-inspired-terminal.svg
1 int i;
2 cin >> i;
3 if (i)
4     cout << "Sie haben einen Wert ungleich 0 eingegeben!\n";
5 else
6     cout << "Sie haben 0 eingegeben!\n";

Natürlich könnten auch hier, sowohl für die if-Anweisung, als auch für die else-Anweisung, ein Anweisungsblock stehen. Wenn Sie Pascal oder eine ähnliche Programmiersprache kennen, wird Ihnen auffallen, dass auch die Anweisung vor dem else mit einem Semikolon abgeschlossen wird. Da auf eine if- oder else-Anweisung immer nur eine Anweisung oder ein Anweisungsblock stehen kann, muss zwangsläufig direkt danach ein else stehen, um dem if zugeordnet zu werden.

Sie können in einer Verzweigungsanweisung auch mehr als zwei Alternativen angeben:

Nuvola-inspired-terminal.svg
1 int i;
2 cin >> i; 
3 if (i == 10)
4     cout << "Sie haben zehn eingegeben\n";
5 else
6     if (i == 11)
7         cout << "Sie haben elf eingegeben\n";
8     else
9         cout << "Sie haben weder zehn noch elf eingegeben\n";

Es können beliebig viele Zweige mit else if vorkommen. Allerdings ist es üblich, eine andere Einrückung zu wählen, wenn solche „if-else-Bäume“ ausgebaut werden:

Nuvola-inspired-terminal.svg
1 int i;
2 cin >> i; 
3 if (i == 10)
4     cout << "Sie haben zehn eingegeben\n";
5 else if (i == 11)
6     cout << "Sie haben elf eingegeben\n";
7 else
8     cout << "Sie haben weder zehn noch elf eingegeben\n";

Außerdem ist es zu empfehlen, auch bei einer Anweisung einen Anweisungsblock zu benutzen. Letztlich ist die Funktionalität immer die gleiche, aber solche Blöcke erhöhen die Übersichtlichkeit und wenn Sie später mehrere Anweisungen, statt nur einer angeben möchten, brauchen Sie sich um etwaige Klammern keine Gedanken zu machen, weil sie sowieso schon vorhanden sind.

Nuvola-inspired-terminal.svg
1 int i;
2 cin >> i; 
3 if (i == 10) {
4     cout << "Sie haben zehn eingegeben\n";
5 } else if(i == 11) {
6     cout << "Sie haben elf eingegeben\n";
7 } else {
8     cout << "Sie haben weder zehn noch elf eingegeben\n";
9 }

Sie werden für die Positionierung der Klammern übrigens auch oft auf eine andere Variante treffen:

Nuvola-inspired-terminal.svg
 1 int i;
 2 cin >> i; 
 3 if (i == 10)
 4 {
 5     cout << "Sie haben zehn eingegeben\n";
 6 }
 7 else
 8 {
 9     if (i == 11)
10     {
11         cout << "Sie haben elf eingegeben\n";
12     }
13     else
14     {
15         cout << "Sie haben weder zehn noch elf eingegeben\n";
16     }
17 }

Einige Programmierer finden dies übersichtlicher, für dieses Buch wurde jedoch die Variante mit den öffnenden Klammern ohne Extrazeile verwendet. Das hat den Vorteil, dass weniger Platz benötigt wird und da die Einrückung ohnehin die Zugehörigkeit andeutet, ist eine zusätzliche Kennzeichnung nicht unbedingt nötig.

Die Einrückung von Quelltextzeilen hat für den Compiler übrigens keine Bedeutung. Sie ist lediglich eine grafische Darstellungshilfe für den Programmierer. Auch die in diesem Buch gewählte Einrückungstiefe von vier Leerzeichen ist optional, viele Programmierer verwenden etwa nur zwei Leerzeichen. Andere hingegen sind davon überzeugt, dass acht die ideale Wahl ist. Aber egal, wofür Sie sich entscheiden, wichtig ist, dass Sie Ihren Stil einhalten und nicht ständig ihren Stil wechseln. Das verwirrt nicht nur, sondern sieht auch nicht schön aus.

Symbol confirmed.svg
Tipp

Wenn es Sie nicht stört, in Ihrem Texteditor Tabulatorzeichen und Leerzeichen anzeigen zu lassen, dann sollten Sie für die Einrückung Tabulatorzeichen verwenden und für alles hinter der normalen Einrückung (etwa den Abstand bis zum Kommentar) Leerzeichen. Das hat den Vorteil, dass Sie die Einrückungstiefe jederzeit ändern können, indem Sie angeben wie viele Leerzeichen einem Tabulatorzeichen entsprechen.
Nachteil: Wenn Sie den Quelltext in verschiedenen Editoren bearbeiten oder weitergeben, muss in jedem Editor eingestellt werden, was die Tabulator-Breite sein soll. Beim Verwenden von Leerzeichen bleibt die Einrückung immer gleich, auch wenn die Tabulatorbreite verschieden eingestellt sein sollte.

Vergleichsoperatoren[Bearbeiten]

Im obigen Beispiel kam schon der Vergleichsoperator == zum Einsatz. In C++ gibt es insgesamt sechs Vergleichsoperatoren. Sie liefern jeweils den Wert true, wenn die beiden Operanden (die links und rechts des Operators stehen) dem Vergleichskriterium genügen, ansonsten den Wert false.

== identisch
<= ist kleiner (oder) gleich
>= ist größer (oder) gleich
< ist kleiner
> ist größer
!= ist ungleich
Symbol opinion vote.svg
Hinweis

Der Vergleichsoperator == wird von Anfängern oft mit dem Zuweisungsoperator = verwechselt. Da es absolut legal ist, eine Zuweisung innerhalb einer if-Bedingung zu machen, führt das oft zu schwer zu findenden Fehlern. Eine Zuweisung wird ausgewertet zum zugewiesenen Wert. Problem-Beispiel:

Nuvola-inspired-terminal.svg
1 int a = 5, b = 8;
2 if (a = b) cout << "5 ist gleich 8.";
Crystal Clear app kscreensaver.svg
Ausgabe:
1 5 ist gleich 8.

Die „Bedingung“ weist den Wert von b an die Variable a zu (a = 8). Für das if wird der Gesamtausdruck ausgewertet (also 8), was true bedeutet.

Prüfen Sie bei seltsamen Verhalten also immer, ob vielleicht der Zuweisungsoperator = statt des Gleichheitsoperators == verwendet wurde.

Eine weitere Falle ist der Ungleichheitsoperator !=, wenn er falsch herum geschrieben wird (=!). Letzteres sind in Wahrheit zwei Operatoren, nämlich die Zuweisung = und die logische Negierung !, die Sie gleich kennen lernen werden. Um das zu unterscheiden, machen Sie sich einfach klar, was das in Worten heißt:

  • != – nicht gleich
  • =! – gleich nicht

Logische Operatoren[Bearbeiten]

Mit logischen Operatoren können Sie mehrere Bedingungen zu einem Ausdruck verknüpfen. C++ bietet folgende Möglichkeiten:

! Logisches Nicht Resultat wahr, wenn der Operand falsch ist
&& Logisches Und Resultat wahr, wenn beide Operanden wahr sind
|| Logisches Oder Resultat wahr, wenn mindestens ein Operand wahr ist (inclusive-or)

Die Operatoren lassen sich übersichtlich mit Wahrheitstafeln beschreiben (bei der hier gewählten Darstellung ist jede Spalte für sich zu lesen):

Logisches Und (&&)
a true true false false
b true false true false
a && b true false false false

Beispiel für die dritte Spalte: Mit a = false und b = true gilt a && b -> false.

Logisches Oder (||)
a true true false false
b true false true false
a || b true true true false
Logisches Nicht (!)
a true false
!a false true

Beispiel:

Nuvola-inspired-terminal.svg
1 int i = 10, j = 20;
2 if (i == 10 && j == 10) {
3     cout << "Beide Werte sind gleich zehn\n";
4 }
5 if (i == 10 || j == 10) {
6     cout << "Ein Wert oder beide Werte sind gleich zehn\n";
7 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Ein Wert oder beide Werte sind gleich zehn

Aus Gründen der Lesbarkeit sollten Vergleichsausdrücke grundsätzlich von Klammern umgeben sein. Der obige Code würde folglich so aussehen:

Nuvola-inspired-terminal.svg
1 int i = 10, j = 20;
2 if ((i == 10) && (j == 10)) {
3     cout << "Beide Werte sind gleich zehn\n";
4 }
5 if ((i == 10) || (j == 10)) {
6     cout << "Ein Wert oder beide Werte sind gleich zehn\n";
7 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Ein Wert oder beide Werte sind gleich zehn

Sowohl beim &&-Operatoren (Logik-und) als auch beim ||-Operator (Logik-oder) werden die Teilausdrücke von links nach rechts bewertet, und zwar nur so lange, bis das Resultat feststeht. Wenn z. B. bei einer &&-Verknüpfung A && B && C schon die erste Bedingung 'A' falsch ist, werden 'B' und 'C' gar nicht mehr untersucht, da bei && ja alle Bedingungen true sein müssen. Der Rückgabewert der beiden Operatoren ist vom Typ bool.

Gelegentlich ist daher anzutreffen:

Nuvola-inspired-terminal.svg
1 if ( (variable_ist_gueltig) && (variable_erfuellt_zusaetzliche_detailbedingung) ) { /* mache etwas */ }

Ob die Variable die Detailbedingung erfüllt, kann nur geprüft werden, wenn sie einen gültigen Wert enthält. Die erste Bedingung auf Gültigkeit schützt somit die nachfolgende davor, mit ungültigen Werten arbeiten zu müssen.

Symbol opinion vote.svg
Hinweis

Beachten Sie bitte, dass der UND-Operator (&&) eine höhere Priorität als der ODER-Operator (||) hat. Das heißt, Sie müssen bei Ausdrücken wie dem Folgenden vorsichtig sein.

Nuvola-inspired-terminal.svg
1 int i = 10, j = 20;
2 // Erwartete Reihenfolge    ((((i == 10) || (j == 20)) && (j == 20)) && (i == 5))
3 // Tatsächliche Reihenfolge ((i == 10) || (((j == 20) && (j == 20)) && (i == 5)))
4 if (i == 10 || j == 20 && j == 20 && i == 5) {
5     cout << "i ist Zehn und fünf oder (j ist Zwanzig und i fünf)!\n";
6 } else {
7     cout << "i ist nicht Zehn oder (j ist Zwanzig oder i nicht fünf)!\n";
8 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 i ist Zehn und fünf oder (j ist Zwanzig und i fünf)!

Die Ausgabe ist von der Logik her falsch, weil der Ausdruck in der Reihenfolge ((i == 10) || (((j == 20) && (j == 20)) && (i == 5))) ausgewertet wird. Solche Fehler sind sehr schwer zu finden, also sollten Sie sie auch nicht machen. Daher der Tipp: Verwenden Sie bei solch komplexen Bedingungen immer Klammern, um klar zu machen, in welcher Reihenfolge Sie die Ausdrücke auswerten wollen. Das ist unmissverständlich, und der menschliche Leser liest den Ausdruck genauso wie der Compiler. Um zu erkennen, an welcher Stelle eine Klammer wieder geschlossen wird, beherrschen die meisten Editoren das sogenannte Bracket Matching. Dabei hebt der Editor (automatisch oder über einen bestimmten Hotkey) die schließende Klammer hervor.

Symbol confirmed.svg
Tipp

Wenn Sie mit mehreren && und || arbeiten, dann schreiben Sie den Ausdruck, der am wahrscheinlichsten zutrifft, auch am weitesten links, also vor den anderen Ausdrücken. Das ist eine (zugegebenermaßen) sehr geringfügige Optimierung, aber es gibt Situationen in denen sie trotzdem sinnvoll ist. Beispielsweise wenn die Bedingung innerhalb einer Schleife sehr oft ausgeführt wird.

Hinweis für fortgeschrittene Leser: Beachten Sie bitte, dass für überladende Operatoren andere Regeln gelten. Alle diejenigen, die noch nicht wissen, was überladende Operatoren sind, brauchen sich um diesen Hinweis (noch) nicht zu kümmern.

Bedingter Ausdruck[Bearbeiten]

Häufig werden Verzweigungen eingesetzt, um abhängig vom Wert eines Ausdrucks eine Zuweisung vorzunehmen. Das können Sie mit dem Auswahloperator ? ... : ... auch einfacher formulieren:

Nuvola-inspired-terminal.svg
1 min = a < b ? a : b;
2 // Alternativ ginge:
3 if (a < b) {
4     min = a;
5 } else {
6     min = b;
7 }

Grafisch sieht das so aus:

KonditionalOperator1.png

Der Variablen min wird der kleinere, der beiden Werte a und b zugewiesen. Analog zum Verhalten der logischen Operatoren wird nur derjenige „Zweig“ bewertet, der nach Auswertung der Bedingung (a < b) tatsächlich ausgeführt wird.


Der Bedingungsoperator kann auch wie folgt verwendet werden:

Nuvola-inspired-terminal.svg
1 (zahl%2) ? printf("ungerade") : printf("gerade");

Im Gegensatz zur if...else-Anweisung ist es hier aber nicht möglich, in Abhängigkeit zu einer Bedingung, nur eine Anweisung auszugeben, indem man die else-Anweisung einfach weg lässt:

Nuvola-inspired-terminal.svg
1 if(a) make(b); 	//richtig
2 
3 (a) ? make(b);	//falsch

Das liegt daran, dass der Bedingungsoperator ?: keine Kontrollstruktur im eigentlichen Sinne ist.

Vielmehr wird mit (a) ? make(b) : make(c); ein Ausdruck „berechnet“, der einen Wert aufweisen muss, während sich die if-Anweisung logisch in einen "Tu-nichts-Pfad" auflösen kann.

Schleifen [Bearbeiten]

Mit dem, was Sie bis jetzt gelernt haben, sollte es für Sie eine leichte Übung sein, die Zahlen von eins bis zehn ausgeben zu lassen. So könnte ein Programm aussehen, das dies tut:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main() {
 4     std::cout << "1\n";
 5     std::cout << "2\n";
 6     std::cout << "3\n";
 7     std::cout << "4\n";
 8     std::cout << "5\n";
 9     std::cout << "6\n";
10     std::cout << "7\n";
11     std::cout << "8\n";
12     std::cout << "9\n";
13     std::cout << "10\n";
14 }
Crystal Clear app kscreensaver.svg
Ausgabe:
 1 1
 2 2
 3 3
 4 4
 5 5
 6 6
 7 7
 8 8
 9 9
10 10

Dieses Programm ist einfach – aber was wäre, wenn die Zahlen eins bis einer Million ausgegeben werden sollen? Oder schlimmer noch – ja, es geht noch schlimmer: die Ausgabe hängt von der Benutzereingabe ab. Dann müssten Sie von der größtmöglichen Zahl ausgehen (bei unsigned int üblicherweise 4.294.967.295) und zusätzlich noch nach jeder Ausgabe überprüfen, ob die vom Benutzer eingegebene Zahl erreicht ist.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main() {
 4     unsigned i = 1;                  // 2 Variablen anlegen
 5     unsigned benutzer = 0;
 6 
 7     std::cin >> benutzer;            // Benutzer gibt Zahl ein
 8 
 9     if (i <= benutzer) {             // Benutzereingabe erreicht?
10         std::cout << "1\n";          // Ausgabe der Zahl 1
11         ++i;                         // Ausgegebene Zahlen mitzählen
12     } else {
13         return 0;                    // Anwendung beenden
14     }
15 
16     if (i <= benutzer) {             // Benutzereingabe erreicht?
17         std::cout << "2\n";          // Ausgabe der Zahl 2
18         ++i;                         // Ausgegebene Zahlen mitzählen
19     } else {
20         return 0;                    // Anwendung beenden
21     }
22 
23     // ...
24 
25     if (i <= benutzer) {             // Benutzereingabe erreicht?
26         std::cout << "4294967295\n"; // Ausgabe der Zahl 4294967295
27         ++i;                         // Ausgegebene Zahlen mitzählen
28     } else {
29         return 0;                    // Anwendung beenden
30     }
31 
32     // Wenn Ihr Compiler diese Stelle erreichen soll, brauchen Sie einen leistungsstarken
33     // Rechner und ein robustes Betriebssystem.
34     // Um dieses Problem zu lösen, setzen Sie sich einfach in die nächste Zeitmaschine
35     // und bestellen Sie sich einen Rechner aus dem Jahr 2020!
36 }

Insgesamt würden sich über 17,1 Milliarden Zeilen Code ergeben.

An diesem Punkt kommen Schleifen ins Spiel. Bis jetzt wurden alle Programme einfach der Reihe nach abgearbeitet und zwischendurch wurde eventuell mal verschiedenen Zweigen gefolgt. Mit einer Schleife können Sie erreichen, dass ein Programmteil mehrfach abgearbeitet wird. C++ stellt drei Schleifenkonstrukte zur Verfügung. Die kopfgesteuerte while-Schleife, die fußgesteuerte do-while-Schleife und die (ebenfalls kopfgesteuerte) for-Schleife. Was kopf- und fußgesteuerte Schleife bedeutet erfahren Sie in Kürze. Vielleicht wissen Sie es aber auch schon aus dem Kapitel „Grundlegende Elemente“, aus dem Abschnitt „Für Programmieranfänger“.

Die while-Schleife[Bearbeiten]

Eine while-Schleife hat die folgende allgemeine Form:

Crystal Project Tutorials.png
Syntax:
while(«Bedingung») «Anweisung»
«Nicht-C++-Code», »optional«

Natürlich können Sie, wie bei den Verzweigungen auch, hier wieder mehrere Anweisungen zu einem Anweisungsblock zusammenfassen, da diese als eine Anweisung gilt:

Crystal Project Tutorials.png
Syntax:
while(«Bedingung») {
    «Anweisungen»
}
«Nicht-C++-Code», »optional«

Solange die Bedingung erfüllt ist, wird die Anweisung oder der Anweisungsblock ausgeführt. Da es sich hier um eine kopfgesteuerte Schleife handelt, wird erst die Bedingung ausgewertet. Ist diese erfüllt, so wird dann die Anweisung ausgeführt. Ist die nächste Überprüfung der Bedingung positiv, so wird der Schleifenrumpf erneut ausgeführt und so fort. Ist die Bedingung nicht erfüllt, wird der Schleifeninhalt übersprungen und mit dem Quelltext nach der Schleife fortgesetzt. Es kann daher vorkommen, dass der Schleifenrumpf gar nicht ausgeführt wird - wenn die Bedingung schon zu Beginn nicht erfüllt wird.

Was eine fußgesteuerte Schleife macht, erfahren Sie unter der Überschrift do-while. Eine Gegenüberstellung der beiden Schleifen gibt es in der Zusammenfassung dieses Kapitels.

Symbol confirmed.svg
Tipp

Wie Bedingungen ausgewertet werden, können Sie im Kapitel „Verzweigungen“ nachlesen - das vorherige Kapitel.

Symbol opinion vote.svg
Hinweis

Beachten Sie, dass Schleifen so lange ausgeführt werden, bis die Bedingung nicht mehr erfüllt ist. Wenn Sie also nicht innerhalb der Schleife dafür sorgen, dass die Bedingung irgendwann nicht mehr erfüllt ist, dann haben Sie eine sogenannte Endlosschleife. Das heißt, der Schleifenrumpf (so nennt man die Anweisung oder den Anweisungsblock einer Schleife) wird immer wieder ausgeführt. Das Programm kann nur durch Abbrechen beendet werden. In Kombination mit einem Schlüsselwort, das Sie in Kürze kennen lernen werden, kann eine solche Endlosschleife durchaus gewollt und sinnvoll sein (der Befehl kann die Schleife abbrechen), aber in der Regel entsteht so etwas versehentlich. Wenn Ihr Programm also mal „abgestürzt“ ist, im Sinne von „Es reagiert nicht mehr! Wie schrecklich!“, dann haben Sie vermutlich irgendwo eine Endlosschleife eingebaut.

Nun aber zurück zu unserer Schleifenaufgabe mit 17,1 Milliarden Zeilen Code. Da Ihr Compiler immer noch nicht damit fertig ist, die oben vorgestellte Lösung zu übersetzen, versuchen wir jetzt mal das ganze mit einer while-Schleife zu lösen.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main() {
 4     unsigned i = 1;                  // 2 Variablen anlegen
 5     unsigned benutzer = 0;
 6 
 7     std::cin >> benutzer;            // Benutzer gibt Zahl ein
 8 
 9     while (i <= benutzer) {          // Benutzereingabe erreicht?
10         std::cout << i << std::endl; // Ausgabe von i und einem Zeilenumbruch
11         i++;                         // i um eins erhöhen (-> ausgegebene Zahlen mitzählen)
12     }
13 }

Nun ja, das sieht dem Programm von oben doch irgendwie ähnlich, nur die knapp 4,3 Milliarden if-Anweisungen sind weggefallen und haben einer vom Aufbau fast identischen while-Schleife Platz gemacht. Nun haben wir natürlich ein Problem: Ihr Superrechner aus dem Jahr 2020 ist immer noch mit der Übersetzung der ersten Programmversion beschäftigt und wird es wohl auch noch bis zu seiner Erfindung bleiben. Aber zum Glück haben Sie ja noch einen alten Rechner von 1980. Also versuchen Sie das Programm auf diesem zu übersetzen und auszuführen. Tatsächlich. Es funktioniert. Erstaunlich, dass so eine alte Kiste einen Rechner überholt, den Sie sich extra aus der Zukunft haben liefern lassen, um die maximale Leistungsstärke zu bekommen.

Wenn Sie Schwierigkeiten haben das Beispiel nachzuvollziehen, dann sehen Sie sich noch mal die Schleifen-Version für die Zahlen von 1 bis 10 an.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main() {
 4     int i = 1;                       // Anlegen von i
 5 
 6     while (i <= 10) {                // Ist i noch kleiner-gleich 10?
 7         std::cout << i << std::endl; // Ausgabe von i und neue Zeile
 8         i++;                         // i um eins erhöhen
 9     }
10 }
Crystal Clear app kscreensaver.svg
Ausgabe:
 1 1
 2 2
 3 3
 4 4
 5 5
 6 6
 7 7
 8 8
 9 9
10 10

So sieht das Ganze schon viel kompakter und vielleicht auch übersichtlicher aus als die Version von ganz oben. Die Ausgabe dagegen ist völlig identisch. Hier wird i am Anfang auf eins gesetzt. Somit ist die Bedingung (eins ist kleiner oder gleich zehn) erfüllt. Damit wird der Schleifenrumpf ausgeführt. „1“ wird ausgegeben. Es folgt ein Zeilenumbruch. Danach wird der Wert von i um eins erhöht. Danach wird wieder geprüft, ob die Bedingung erfüllt ist. Da i jetzt zwei ist, lautet die Bedingung „zwei ist kleiner oder gleich zehn“, da dies eine wahre Aussage ist, wird wieder der Schleifenrumpf ausgeführt. Das wiederholt sich bis i Schließlich den Wert elf hat. Die Bedingung lautet dann „elf ist kleiner oder gleich zehn“, diese Aussage ist zweifellos falsch. Daher wird der Schleifenrumpf nun übersprungen und mit dem Code dahinter weitergemacht. Da in unserem Beispiel dort aber kein Code mehr folgt, wird das Programm beendet.

Zusammengefasst:

  1. Quelltext vor der Schleife
  2. Schleifen Bedingung
    • Erfüllt:
      1. Schleifenrumpf
      2. weiter mit 2
    • Nicht Erfüllt:
      1. weiter mit 3
  3. Quelltext nach der Schleife

Die do-while-Schleife[Bearbeiten]

Wie versprochen lüften wir nun das Geheimnis um die fußgesteuerten Schleifen. do-while ist eine fußgesteuerte Schleife, das heißt, als erstes wird der Schleifenrumpf ausgeführt, danach die Bedingung überprüft und dann abhängig von der Bedingung, wieder der Rumpf ausgeführt (Bedingung erfüllt) oder mit dem Quelltext nach der Schleife fortgesetzt (Bedingung nicht erfüllt). Eine fußgesteuerte Schleife zeichnet sich also dadurch aus, dass der Schleifenrumpf mindestens ein mal ausgeführt wird.

Crystal Project Tutorials.png
Syntax:
do «Anweisung» while(«Bedingung»);
«Nicht-C++-Code», »optional«

Bei dieser Schleife finden wir die obige Syntax nur selten, da der Schleifenrumpf hier zwischen den beiden Schlüsselwörtern do und while steht, wird fast immer ein Anweisungsblock benutzt, auch wenn nur eine Anweisung vorhanden ist. Für Ihren Compiler spielt das natürlich keine Rolle, aber für einen Menschen der den Quelltext liest, ist es übersichtlicher.

Crystal Project Tutorials.png
Syntax:
do{
    «Anweisungen»
} while(«Bedingung»);
«Nicht-C++-Code», »optional«

Unser anfängliches Riesenprogramm sieht mit einer do-while Schleife so aus:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main() {
 4     unsigned i = 1;                  // 2 Variablen anlegen
 5     unsigned benutzer = 0;
 6 
 7     std::cin >> benutzer;            // Benutzer gibt Zahl ein
 8 
 9     do {                             // Schleifenanfang
10         std::cout << i << std::endl; // Ausgabe von i
11         ++i;                         // Ausgegebene Zahlen mitzählen
12     } while (i <= benutzer);         // Benutzereingabe erreicht?
13 }

Sie werden feststellen, dass die Ausgabe dieses Programms mit der Ausgabe in der while-Schleifen Version übereinstimmt. Den Unterschied bemerken Sie, wenn Sie 0 eingeben: Während die while-Version keine Ausgabe macht, gibt diese do-while-Version „1“ und einen Zeilenumbruch aus, denn der Schleifenrumpf wird immer erst einmal ausgeführt, erst danach wird die Bedingung überprüft und entschieden ob er noch einmal ausgeführt werden muss.

Zusammengefasst:

  1. Quelltext vor der Schleife
  2. Schleifenrumpf
  3. Schleifen Bedingung
    • Erfüllt: weiter mit 2
    • Nicht Erfüllt: weiter mit 4
  4. Quelltext nach der Schleife

Die for-Schleife[Bearbeiten]

Die for-Schleife ist etwas komplexer als die vorherigen beiden Schleifen. Sie gliedert sich in Teile:

Crystal Project Tutorials.png
Syntax:
for(«Initialisierungsteil»; «Bedingungsteil»; «Anweisungsteil») «Schleifenrumpf»
«Nicht-C++-Code», »optional«

Der Schleifenrumpf kann wie immer eine einzelne Anweisung oder ein {}-Anweisungsblock sein. Der Bedingungsteil verhält sich genau wie bei der while- und der do-while-Schleife oder sagen wir fast genau so, denn einen kleinen aber feinen Unterschied gibt es doch. Während while und do-while immer eine Bedingung erwarten, muss bei einer for-Schleife nicht unbedingt eine Bedingung angegeben werden. Wenn keine Bedingung angegeben ist, wird einfach angenommen, dass die Bedingung immer erfüllt ist, Sie erhalten eine Endlosschleife. Wie das sinnvoll eingesetzt wird erfahren Sie in Kürze.

Im Anweisungsteil können Sie eine beliebige Anweisung ausführen, dieser Teil wird oft verwendet, um Variablen bei jedem Schleifendurchlauf hoch oder runter zu zählen. Im nächsten Beispiel wird dies auch demonstriert. Es ist auch möglich, mehrere solcher „hoch- oder runter-Zähl“-Anweisungen durch Komma getrennt anzugeben, das wird im nächstem Beispiel aber nicht gemacht. Der Anweisungsteil wird übrigens direkt nach dem Schleifenrumpf und vor dem nächsten Bedingungstest ausgeführt. Der Initialisierungsteil ist dem Anweisungsteil dahingehend ähnlich, als dass auch hier eine beliebige Anweisung ausgeführt werden kann. Zusätzlich ist es hier aber noch möglich Variablen eines Datentyps anzulegen. Sie können also problemlos 2 int-Variablen anlegen, aber nicht eine int- und eine char-Variable. Der Initialisierungsteil wird nur einmal am Beginn der Schleife ausgeführt.

Symbol move vote.svg
Thema wird später näher erläutert…

Im Kapitel Lebensdauer und Sichtbarkeit von Objekten werden Sie noch etwas genaueres darüber erfahren wo Sie die im Initialisierungsteil der Schleife angelegten Variablen verwenden können. Dort werden Sie auch erfahren wie eine for-Schleife mit Hilfe einer while-Schleife „nachgebaut“ werden kann.

Jetzt sollten Sie sich jedoch merken, dass Sie eine solche Variable nur innerhalb der Schleife verwenden können, also nicht mehr nach ihrem Verlassen.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main() {
 4     unsigned benutzer = 0;                   // Variablen für Benutzereingabe
 5 
 6     std::cin >> benutzer;                    // Benutzer gibt Zahl ein
 7 
 8     for(unsigned i = 1; i <= benutzer; ++i)  // for-Schleife
 9         std::cout << i << std::endl;         // Ausgabe von i
10 }

Zusammengefasst:

  1. Quelltext vor der Schleife
  2. Initialisierungsteil der Schleife
  3. Schleifen Bedingung
    • Erfüllt:
      a) Schleifenrumpf
      b) Anweisungsteil
      c) weiter mit 3
    • Nicht Erfüllt: weiter mit 4
  4. Quelltext nach der Schleife
Symbol move vote.svg
Thema wird später näher erläutert…

Seit C++11 gibt noch eine weitere Form der for-Schleife. In vielen anderen Programmiersprachen nennt man diese Form die »foreach«-Schleife:

Crystal Project Tutorials.png
Syntax:
for(«Element»: «Container») «Schleifenrumpf»
«Nicht-C++-Code», »optional«

An dieser Stelle des Buches lässt sich die Funktionsweise noch schwer erklären, da die Datenstrukturen (welche hier mit «Container» angedeutet sind) noch nicht behandelt wurden. Daher wird erst später genauer auf diese Form der for-Schleife eingegangen.

Zu erkennen ist sie daran, das es keine zwei Semikolons zwischen den Klammern gibt, sondern einen Doppelpunkt.

Die break-Anweisung[Bearbeiten]

Jetzt ist es an der Zeit, das Geheimnis um die sinnvolle Verwendung von Endlosschleifen zu enthüllen. Die break-Anweisung wird innerhalb von Schleifen verwendet, um die Schleife sofort zu beenden. Der Quelltext wird dann ganz normal nach der Schleife fortgesetzt. break können Sie in jeder der drei Schleifen verwenden. Das folgende Beispiel demonstriert den Einsatz von break, anhand unseres Lieblingsprogramms in diesem Kapitel.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main() {
 4     unsigned i = 1;                // 2 Variablen anlegen
 5     unsigned benutzer = 0;
 6 
 7     std::cin >> benutzer;          // Benutzer gibt Zahl ein
 8 
 9     for(;;){                       // Endlos-for-Schleife
10         std::cout << i << "\n";    // Ausgabe von i
11         ++i;                       // Variable erhöhen
12         if(i > benutzer) break;    // Abbrechen, wenn Bedingung erfüllt
13     }
14 }

Sie können aus jeder Schleife eine Endlosschleife machen, hier wurde die for-Schleife gewählt um zu zeigen wie Sie ohne Bedingung aussieht. Bei einer while- oder do-while-Schleife könnten Sie beispielsweise true als Bedingung angeben. Die for-Schleife legt jetzt übrigens das gleiche Verhalten an den Tag, wie eine do-while-Schleife. Sie können auch problemlos nur einen oder zwei Teile des Schleifenkopfes bei for-Schleife übergeben, wichtig ist nur, dass Sie die beiden Semikolons immer angeben, da Sie dem Compiler mitteilen, was welcher Teil des Schleifenkopfes ist.

Nun wissen Sie wieder etwas mehr über for, dabei sollte es unter dieser Überschrift doch eigentlich um break gehen. Wie Sie aber sehen, hängt letztlich alles mit allem zusammen und so ist es oft schwer eine richtige Abgrenzung zu schaffen.

Die continue-Anweisung[Bearbeiten]

Das zweite wichtige Schlüsselwort für Schleifen ist continue. Es wird genau so verwendet wie break, bricht die Schleife allerdings nicht völlig ab, sondern setzt die Codeausführung am Ende des Schleifenrumpfes fort. Für while und do-while bedeutet das beim Bedingungstest, für die for-Schleife beim Anweisungsteil. Mit continue können Sie also den Rest des aktuellen Schleifendurchlaufs überspringen. Wir sehen uns das wieder anhand des Beispiels an.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main() {
 4     unsigned benutzer = 0;                    // Variablen für Benutzereingabe
 5 
 6     std::cin >> benutzer;                     // Benutzer gibt Zahl ein
 7 
 8     for(unsigned i = 1; i <= benutzer; ++i) { // for-Schleife
 9         if (i % 2 == 0) continue;             // alle geraden Zahlen überspringen
10         std::cout << i << std::endl;          // Ausgabe von i
11     }
12 }

Hier werden nur ungrade Zahlen ausgegeben, da der %-Operator (liefert den Rest einer Ganzzahligen Division) bei allen geraden Zahlen, (teilt man durch 2 ist als Rest ja nur 0 oder 1 möglich,) 0 zurückliefert und somit continue ausgeführt wird.

Natürlich könnten Sie das auch noch auf eine andere Weise realisieren. Aber es gibt ja beim Programmieren viele Wege, die nach Rom führen, wie in diesem Kapitel anhand der verschieden Schleifen schon bewiesen wurde. Leider gibt es aber noch mehr Wege, die auf direktem Wege an Rom vorbeiführen... Aber hier ist für das Beispiel von eben noch ein Pfad, der sicher nach Rom führt:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main() {
 4     unsigned int benutzer = 0;                 // Variablen für Benutzereingabe
 5 
 6     std::cin >> benutzer;                      // Benutzer gibt Zahl ein
 7 
 8     for(unsigned i = 1; i <= benutzer; i += 2) // for-Schleife mit 2er Schritten
 9         std::cout << i << std::endl;           // Ausgabe von i
10 }

Strukturierte Programmierung[Bearbeiten]

Die Anweisungen 'break' und 'continue' gelten als „unsauber“, sie erschweren fast immer das Verständnis des Programms. Die Verwendung von 'break' ist oft ein Zeichen dafür, dass die Schleifenbedingung unvollständig ist - und man daher nicht einzig aus der Schleifenbedingung ersehen kann, wie lange die Schleife läuft. Die 'continue'-Anweisung kann meist durch eine 'if'-Anweisung ersetzt werden - oder ebenfalls durch eine exaktere Schleifenbedingung. In als „gut“ erachteten Programmen kommen 'break' und 'continue' möglichst gar nicht vor.

Kapitelanhang[Bearbeiten]

Crystal source cpp.png

Im Anhang zu diesem Kapitel finden Sie:

  • Aufgaben und zugehörige Musterlösungen.
Aufgaben
Symbol neutral vote.svg Aufgabe 1: Schreiben Sie mithilfe einer Schleife ein kleines Spiel. Der Spielablauf lautet:
  • Am Anfang gibt der Spieler einen Zahlenbereich ein. (Zum Beispiel: 1-100)
  • Der Spieler muss sich innerhalb dieses Bereiches eine Zahl merken (eingegebene Grenzzahlen sind nicht zulässig).
  • Das Programm soll dann die Zahl erraten. Der Benutzer teilt dem Programm mit, ob die Zahl an die er denkt kleiner, größer oder gleich der vom Programm geratenen Zahl ist. Die kann zum Beispiel über die Eingabe von <, > und = erfolgen.

Es gibt natürlich viele Wege dieses Problem zu lösen und Sie sehen ja ob Ihr Programm funktioniert oder nicht. Hier wird nur eine Musterlösung vorgestellt, falls Sie überhaupt nicht zurechtkommen oder sich einfach dafür interessieren wie der Autor an das Problem herangegangen ist.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main() {
 4     int min, max; // Variablen für den möglichen Zahlenbereich
 5     int zahl;     // Zahl die der Rechner vermutet
 6 
 7     std::cout << "Wo fängt die Zahlenreihe an?: ";     // Zahlenbereich abfragen
 8     std::cin >> min;                                   // Benutzereingabe einlesen
 9 
10     std::cout << "Wo hört die Zahlenreihe auf?: ";     // Zahlenbereich abfragen
11     std::cin >> max;                                   // Benutzereingabe einlesen
12 
13     for (char eingabe = '0'; eingabe != '=';) {        // Abbrechen wenn eingabe '=' ist
14         zahl = min + (max - min) / 2;                  // Mittlere Zahl berechnen
15         std::cout << "Denken Sie an " << zahl << "? "; // Vermutung ausgeben
16         std::cin >> eingabe;                           // Antwort einlesen
17 
18         if (eingabe == '<')                        // Ist die Zahl kleiner?
19             max = zahl;                            // Setzte max auf den zu großen Wert zahl
20         else if (eingabe == '>')                   // Ist die Zahl größer?
21             min = zahl;                            // Setzte min auf den zu kleinen Wert zahl
22         else if (eingabe != '=')                   // Ist Eingabe auch kein Gleichheitszeichen
23             std::cout << "Sie haben ein unzulässiges Zeichen eingegeben!\n"; // Fehlerhafte Eingabe melden
24 
25         if (min+1 >= max) {                        // Keine Zahl mehr im gültigen Bereich
26             std::cout << "Sie sind ein Lügner!\n"; // Das Programm ist äußert entsetzt
27             break;                                 // Schleife wird abgebrochen
28         }
29     }
30 
31     std::cout << "Die von Ihnen gemerkte Zahl ist " << zahl << "!" << std::endl; // Ausgabe der erratenen Zahl
32 }
Crystal Clear app kscreensaver.svg
Ausgabe:
 1 Wo fängt die Zahlenreihe an?: 0
 2 Wo hört die Zahlenreihe auf?: 100
 3 Denken Sie an 50? <
 4 Denken Sie an 25? >
 5 Denken Sie an 37? <
 6 Denken Sie an 31? >
 7 Denken Sie an 34? <
 8 Denken Sie an 32? >
 9 Denken Sie an 33? =
10 Die von Ihnen gemerkte Zahl ist 33!

Dies ist eine Beispielausgabe, alles nach einem Fragezeichen ist eine Benutzereingabe.

Auswahl [Bearbeiten]

Verzweigungen kennen Sie schon, daher sollte es Ihnen nicht schwer fallen, ein Programm zu schreiben, welches abfragt, welche der verschiedenen, in der Überschrift benannten Leckereien, Sie am liebsten mögen. Das ganze könnte etwa so aussehen:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 int main(){
 6     int auswahl;
 7 
 8     cout << "Wählen Sie Ihre Lieblingsleckerei:\n"
 9             "1 - Käsesahnetorte\n"
10             "2 - Streuselkuchen\n"
11             "3 - Windbeutel\n";
12 
13     cin >> auswahl;
14 
15     if(auswahl==1)
16         cout << "Sie mögen also Käsesahnetorte!\n";
17     else if(auswahl==2)
18         cout << "Streuselkuchen ist ja auch lecker...\n";
19     else if(auswahl==3)
20         cout << "Windbeutel sind so flüchtig wie ihr Name, das können Sie sicher bestätigen?\n";
21     else
22         cout << "Wollen Sie wirklich behaupten, dass Ihnen nichts davon zusagt?\n";
23 
24     return 0;
25 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Wählen Sie Ihre Lieblingsleckerei:
2 1 - Käsesahnetorte
3 2 - Streuselkuchen
4 3 - Windbeutel
5 <Eingabe>2</Eingabe>
6 Streuselkuchen ist ja auch lecker...

Das funktioniert natürlich, aber finden Sie nicht auch, dass der (Schreib-)Aufwand ein wenig zu groß ist? Außerdem ist diese Schreibweise nicht gerade sofort einleuchtend. Für unseren Fall, wäre es schöner, wenn wir die Variable auswahl als zu untersuchendes Objekt festlegen könnten und dann einfach alle Fälle die uns interessieren durchgehen könnten. Praktischerweise bietet C++ ein Schlüsselwort, das genau dies ermöglicht.

switch und break[Bearbeiten]

Eine switch-Anweisung hat die folgende Form:

Crystal Project Tutorials.png
Syntax:
switch(«Ganzzahlige Variable»){
    case «Ganzzahl»: «Anweisungsblock»
    case «Ganzzahl»: «Anweisungsblock»
    «...»
    default: «Anweisungsblock»
}
«Nicht-C++-Code», »optional«

Auf unser Beispiel angewandt, würde das dann so aussehen:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 int main(){
 6     int auswahl;
 7 
 8     cout << "Wählen Sie Ihre Lieblingsleckerei:\n"
 9             "1 - Käsesahnetorte\n"
10             "2 - Streuselkuchen\n"
11             "3 - Windbeutel\n";
12 
13     cin >> auswahl;
14 
15     switch(auswahl){
16         case 1:  cout << "Sie mögen also Käsesahnetorte!";
17         case 2:  cout << "Streuselkuchen ist ja auch lecker...";
18         case 3:  cout << "Windbeutel sind so flüchtig wie ihr Name, das können Sie sicher bestätigen?";
19         default: cout << "Wollen Sie wirklich behaupten, dass Ihnen nichts davon zusagt?";
20     }
21 
22     return 0;
23 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Wählen Sie Ihre Lieblingsleckerei:
2 1 - Käsesahnetorte
3 2 - Streuselkuchen
4 3 - Windbeutel
5 <Eingabe>2</Eingabe>
6 Streuselkuchen ist ja auch lecker...
7 Windbeutel sind so flüchtig wie ihr Name, das können Sie sicher bestätigen?
8 Wollen Sie wirklich behaupten, dass Ihnen nichts davon zusagt?

Nun ja, Sie haben ein neues Schlüsselwort kennen gelernt, setzen es ein und kommen damit auch prompt zum falschen Ergebnis. Sieht so aus, als würde jetzt jeder der Sätze ab dem Ausgewählten ausgegeben. In der Tat handelt switch genau so. Es führt alle Anweisungen, ab dem Punkt aus, an dem das case-Argument mit der übergebenen Variable (in unserem Fall auswahl) übereinstimmt. Um das Ausführen nachfolgender Anweisungen innerhalb von switch zu verhindern, benutzen Sie das Schlüsselwort break. Unser Beispiel sieht dann also folgendermaßen aus:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 int main(){
 6     int auswahl;
 7 
 8     cout << "Wählen Sie Ihre Lieblingsleckerei:\n"
 9             "1 - Käsesahnetorte\n"
10             "2 - Streuselkuchen\n"
11             "3 - Windbeutel\n";
12 
13     cin >> auswahl;
14 
15     switch(auswahl){
16         case 1:
17             cout << "Sie mögen also Käsesahnetorte!";
18             break;
19         case 2:
20             cout << "Streuselkuchen ist ja auch lecker...";
21             break;
22         case 3:
23             cout << "Windbeutel sind so flüchtig wie ihr Name, das können Sie sicher bestätigen?";
24             break;
25         default:
26             cout << "Wollen Sie wirklich behaupten, dass Ihnen nichts davon zusagt?";
27     }
28 
29     return 0;
30 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Wählen Sie Ihre Lieblingsleckerei:
2 1 - Käsesahnetorte
3 2 - Streuselkuchen
4 3 - Windbeutel
5 <Eingabe>2</Eingabe>
6 Streuselkuchen ist ja auch lecker...

Nun haben Sie wieder das ursprüngliche, gewünschte Verhalten. Was Sie noch nicht haben, ist eine Erklärung, warum extra ein break aufgerufen werden muss, um das Ausführen folgender case-Zweige zu unterbinden. Aber das werden Sie gleich erfahren.

Nur Ganzzahlen[Bearbeiten]

Wie bereits aus der oben stehenden Syntaxangabe hervorgeht, kann switch nur mit Ganzzahlen benutzt werden. Dies hängt damit zusammen, dass switch ausschließlich auf Gleichheit mit einem der case-Zweige vergleicht. Bei int-Werten (mit der üblichen Größe von 4 Byte) ist das noch eine „überschaubare“ Menge von maximal 4.294.967.296 () case-Zweigen. Ein float kann die gleiche Menge unterschiedlicher Zahlen darstellen, sofern er ebenfalls 4 Byte groß ist. Aber versuchen Sie mal einen genauen float-Wert aufzuschreiben. Sie arbeiten also immer mit Näherungen, wenn Sie Gleitkommazahlen in Ihrem Code benutzen. Ihr Compiler regelt das für Sie, er weist der Gleitkommazahl den zu Ihrem Wert am nächsten liegenden, darstellbaren Wert zu. Deshalb ist es so gut wie nie sinnvoll (aber natürlich trotzdem möglich), einen Test auf Gleichheit für Gleitkommazahlen durchzuführen. Bei switch wurde das jedoch unterbunden.

Zeichen und mehrere case-Zweige[Bearbeiten]

Eine if-Anweisung trifft Ihre Entscheidung hingegen, anhand der Tatsache ob eine Bedingung erfüllt ist, oder nicht. Für die if-Anweisung gibt es also nur zwei Möglichkeiten. Allerdings gibt es eine ganze Menge von Möglichkeiten, wie der Zustand true, oder false erreicht werden kann. Die Rede ist von Vergleichen und Verknüpfungen ( wie && (= und) oder || (= oder) ) und der Umwandlung von anderen Datentypen nach true, oder false. Für ganzzahlige Datentypen gilt etwa, dass jeder Wert ungleich 0 true ergibt, aber 0 hingegen wird als false ausgewertet. Für eine genaue Beschreibung dessen, was hier noch mal kurz umrissen wurde, sehen Sie sich das Kapitel über Verzweigungen an.

Also gut, switch kann nur auf Gleichheit testen und erlaubt auch keine Verknüpfungen. Oder sagen wir besser: fast keine. Denn genau deshalb gibt es diese scheinbar aufwendige Regelung mit dem break. Das folgende Beispiel demonstriert die Verwendung von Zeichen und die Anwendung von mehreren case-Zweigen, die den gleichen Code ausführen (was einer Verknüpfung mit || zwischen mehreren Vergleichen mittels == gleichkommt):

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 int main(){
 6     char auswahl;
 7 
 8     cout << "Wählen Sie Ihre Lieblingsleckerei:\n"
 9             "K - Käsesahnetorte\n"
10             "S - Streuselkuchen\n"
11             "W - Windbeutel\n";
12 
13     cin >> auswahl;
14 
15     switch(auswahl){
16         case 'k':
17         case 'K':
18             cout << "Sie mögen also Käsesahnetorte!";
19             break;
20         case 's':
21         case 'S':
22             cout << "Streuselkuchen ist ja auch lecker...";
23             break;
24         case 'w':
25         case 'W':
26             cout << "Windbeutel sind so flüchtig wie ihr Name, das können Sie sicher bestätigen?";
27             break;
28         default:
29             cout << "Wollen Sie wirklich behaupten, dass Ihnen nichts davon zusagt?";
30     }
31 
32     return 0;
33 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Wählen Sie Ihre Lieblingsleckerei:
2 K - Käsesahnetorte
3 S - Streuselkuchen
4 W - Windbeutel
5 <Eingabe>s</Eingabe>
6 Streuselkuchen ist ja auch lecker...

Dieses Programm benutzt die Anfangsbuchstaben anstatt der bisherigen Durchnummerierung für die Auswahl. Außerdem ist es möglich sowohl den großen, als auch den kleinen Buchstaben einzugeben. Beides führt den gleichen Code aus.

Missing 'break'[Bearbeiten]

Da switch „von oben nach unten“ abgearbeitet wird, benötigt der letzte Fall kein 'break' - dort endet die Switch-Struktur sowieso. Es ist jedoch erlaubt, den 'default'-Fall auch vor einem oder mehreren 'case'-Fällen aufzuführen - dann sollte er ebenso mit einer 'break'-Anweisung enden, wie jeder andere Fall.

Der letzte Fall darf ebenso mit 'break' enden, wie alle anderen - es schadet nicht ;-)

Ein Taschenrechner wird geboren [Bearbeiten]

In diesem Kapitel wollen wir einen kleinen Taschenrechner für die Kommandozeile schreiben. Dieser wird in späteren Kapiteln noch verbessert, aber fürs Erste lernt er nur die vier Grundrechenarten und kann auch nur mit je 2 Zahlen rechnen.

Die Eingabe[Bearbeiten]

Eine Aufgabe besteht aus zwei Zahlen, die durch ein Rechenzeichen getrennt sind. Für die Zahlen verwenden wir den Typ double. Das Rechenzeichen lesen wir als char ein. Außerdem brauchen wir noch eine Variable, in der wir das Ergebnis speichern. Diese soll ebenfalls vom Typ double sein.

Nuvola-inspired-terminal.svg
1 double zahl1, zahl2, ergebnis;
2 char rechenzeichen;
3 
4 cin >> zahl1 >> rechenzeichen >> zahl2;

Die 4 Grundrechenarten[Bearbeiten]

Wie sicher jeder weiß, sind die 4 Grundrechenarten Addition (+), Subtraktion (-), Multiplikation (*) und Division (/). Da die Variable rechenzeichen vom Typ char und char ein ganzzahliger Typ ist, bietet es sich an, die switch-Anweisung zu verwenden, um die richtige Rechnung zu ermitteln und durchzuführen. Wenn ein ungültiges Rechenzeichen eingegeben wird, geben wir eine Fehlermeldung aus und beenden das Programm.

Nuvola-inspired-terminal.svg
1 switch(rechenzeichen){
2     case '+': ergebnis = zahl1+zahl2; break;
3     case '-': ergebnis = zahl1-zahl2; break;
4     case '*': ergebnis = zahl1*zahl2; break;
5     case '/': ergebnis = zahl1/zahl2; break;
6     default: cout << "unbekanntes Rechenzeichen...\n"; return 1;
7 }

Der Rückgabewert 1 - ausgelöst von return 1; - beendet das Programm, die 1 (und jeder andere Wert ungleich 0 auch) sagt dabei aus, dass im Programm ein Fehler auftrat.

Das ganze Programm[Bearbeiten]

Hier ist noch einmal eine Zusammenfassung unseres Taschenrechners:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 int main(){
 6     double zahl1, zahl2, ergebnis;                // Variablen für Zahlen
 7     char rechenzeichen;                           // Variable fürs Rechenzeichen
 8 
 9     cout << "Geben Sie eine Rechenaufgabe ein: "; // Eingabeaufforderung ausgeben
10     cin >> zahl1 >> rechenzeichen >> zahl2;       // Aufgabe einlesen
11 
12     switch(rechenzeichen){                        // Wert von rechenzeichen ermitteln 
13         case '+': ergebnis = zahl1+zahl2; break;  // entsprechend dem
14         case '-': ergebnis = zahl1-zahl2; break;  // Rechenzeichen
15         case '*': ergebnis = zahl1*zahl2; break;  // das Ergebnis
16         case '/': ergebnis = zahl1/zahl2; break;  // berechnen
17         // Fehlerausgabe und Programm beenden, falls falsches Rechenzeichen eingegeben wurde
18         default: cout << "unbekanntes Rechenzeichen...\n"; return 1;
19     }
20 
21     // Aufgabe noch mal komplett ausgeben
22     cout << zahl1 << ' ' << rechenzeichen << ' ' << zahl2 << " = " << ergebnis << '\n';
23 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Geben Sie eine Rechenaufgabe ein: <Eingabe>99 / 3</Eingabe>
2 99 / 3 = 33

Zusammenfassung [Bearbeiten]

Ein C++-Programm beginnt mit der Hauptfunktion main().

Ein- und Ausgabe[Bearbeiten]

Die Ein- und Ausgabe erfolgt in C++ über Streams, mehr dazu erfahren Sie in einem der folgenden Abschnitte. Um die Ein- und Ausgabe zu nutzen müssen Sie die Headerdatei iostream einbinden. Die Streamobjekte cin und cout liegen im Namensraum std. Auf Elemente innerhalb eines Namensraums wird mit dem Bereichsoperator :: zugegriffen.

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 
3 int main(){
4     std::cout << "Das wird Ausgegeben.\n";
5 
6     int wert;
7     std::cin >> wert;
8     std::cout << "Wert ist: " << wert << std::endl;
9 }

endl fügt einen Zeilenumbruch ein und leert anschließend den Ausgabepuffer.

Mit der using-Direktive können auch alle Elemente eines Namensraums verfügbar gemacht werden.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 int main(){
 6     cout << "Das wird Ausgegeben.\n";
 7 
 8     int wert;
 9     cin >> wert;
10     cout << "Wert ist: " << wert << endl;
11 }

Kommentare[Bearbeiten]

Es gibt in C++ zwei Arten von Kommentaren

Nuvola-inspired-terminal.svg
1 // Kommentare über eine Zeile
2 
3 /* und Kommentare über mehrere 
4 Zeilen*/

Rechnen[Bearbeiten]

C++ beherrscht die 4 Grundrechenarten, die Operatoren lauten +, -, * und /. Es gilt Punkt- vor Strichrechnung und Klammern ändern die Auswertungsreihenfolge. Weiterhin bietet C++ mit dem Zuweisungsoperator kombinierte Rechenoperatoren:

Nuvola-inspired-terminal.svg
1 lvalue += rvalue;
2 lvalue -= rvalue;
3 lvalue *= rvalue;
4 lvalue /= rvalue;

Für Ganzzahlige Datentypen stehen weiterhin der Inkrement- und der Dekrementoperator, jeweils in einer Prä- und einer Postfixvariante zur Verfügung:

Nuvola-inspired-terminal.svg
1 ++lvalue; // Erhöht den Wert und gibt ihn zurück
2 lvalue++; // Erhöht den Wert und gibt den alten Wert zurück
3 --lvalue; // Erniedriegt den Wert und gibt ihn zurück
4 lvalue--; // Erniedriegt den Wert und gibt den alten Wert zurück

Die Rückgabe der Präfixvariante ist ein lvalue, die Postfixvariante gibt ein rvalue zurück.

Variablen[Bearbeiten]

Die Syntax zur Deklaration einer Variable lautet:

Crystal Project Tutorials.png
Syntax:
«Datentyp» «Name»;
«Nicht-C++-Code», »optional«

Datentypen[Bearbeiten]

Die C++-Basisdatentypen sind:

  • Typlos
    • void (wird später erläutert)
  • Logisch
    • bool
  • Zeichen (auch Ganzzahlig)
    • char (signed char und unsigned char)
    • wchar_t
  • Ganzzahlig
    • short (signed short und unsigned short)
    • int (signed int und unsigned int)
    • long (signed long und unsigned long)
  • Gleitkommazahlen
    • float
    • double
    • long double

Die Typmodifizierer signed und unsigned geben an, ob es sich um einen vorzeichenbehafteten oder vorzeichenlosen Typ handelt. Ohne diese Modifizierer wird ein vorzeichenbehafteter Typ angenommen, außer bei char. Hier ist es Implementierungs­abhängig. signed und unsigned können ohne Datentyp verwendet werden, dann wird int als Typ angenommen.

Das Schlüsselwort const zeichnet einen Datentyp als konstant aus. Es gehört immer zu dem, was links davon steht, es sei denn, links steht nichts mehr, dann gehört es zu dem Teil auf der rechten Seite. Es ist somit egal, ob Sie const vor oder hinter einen Basisdatentypen schreiben:

Crystal Project Tutorials.png
Syntax:
const «Datentyp» «Variablenname»;
«Datentyp» const «Variablenname»;
«Nicht-C++-Code», »optional«

C++ macht keine Angaben über die Größen der Datentypen, es ist lediglich folgendes festgelegt:

  • char <= short <= int <= long
  • float <= double <= long double

Initialisierung[Bearbeiten]

In C++ gibt es 2 Möglichkeiten für eine Initialisierung:

Crystal Project Tutorials.png
Syntax:
Datentyp «Variablenname» = «Wert»;
Datentyp «Variablenname»(«Wert»);
«Nicht-C++-Code», »optional«

Die erste Variante ist verbreiteter, aber nur möglich, wenn zur Initialisierung nur 1 Wert benötigt wird. Alle Basisdatentypen erwarten genau einen Wert.

Typaufwertung[Bearbeiten]

Wird ein Operator auf verschiedene Datentypen angewendet, müssen vor der Operation beide in den gleichen Typ konvertiert werden. Der Zieltyp ist üblicherweise der kleinste, der beide Werte darstellen kann. Für genauere Informationen lesen Sie bitte im Kapitel Rechnen mit unterschiedlichen Datentypen.

Kontrollstrukturen[Bearbeiten]

Anweisungsblöcke[Bearbeiten]

Mit einem Anweisungsblock können mehrere Anweisungen zusammengefasst werden. Er kann überall stehen, wo auch eine Anweisung stehen könnte. Die Syntax sieht folgendermaßen aus:

Crystal Project Tutorials.png
Syntax:
{
    «Anweisung»
    «...»
}
«Nicht-C++-Code», »optional«

Verzweigung[Bearbeiten]

Eine Verzweigung hat in C++ folgende Syntax

Crystal Project Tutorials.png
Syntax:
if(«Bedingung»)
    «Anweisung»
else
    «Anweisung»
«Nicht-C++-Code», »optional«

Die Bedingung ist immer ein Logischer Wert. Zahlenwerte werden implizit in logische Werte konvertiert. 0 entspricht dabei immer false, alle anderen Werte werden zu true umgewandelt.

Schleifen[Bearbeiten]

Es gibt 3 Arten von Schleifen. Prinzipiell lässt sich in C++ jede der 3 Arten durch jede der jeweils andere simulieren. Allerdings kann je nach Anwendungsfall, rücksichtlich der Tipparbeit, einer der drei Arten am praktischsten sein.

Crystal Project Tutorials.png
Syntax:
// while-Schleife (Kopfgesteuert)
while(«Bedingung»)
    «Anweisung»

// do-while-Schleife: Alle Anweisungen werden mindestens einmal ausgeführt. (Fußgesteuert)
do
    «Anweisung»
while(«Bedingung»);

// for-Schleife: Ermöglicht die Initialisierung, die Bedingung (Kopfgesteuert) und eine Aktion,
// die nach jedem Schleifendurchlauf stattfindet, im Schleifenkopf zu platzieren
for(«Deklarationen (z.B. Zählvariablen)»; «Bedingung»; «Aktion nach einem Durchlauf (z.B. hochzählen)»)
    «Anweisung»
«Nicht-C++-Code», »optional«

Auswahl[Bearbeiten]

Mit der switch-Anweisung kann eine Variable auf mehrere (konstante) Werte verglichen werden. Jedem dieser Werte können eine oder mehrere Anweisungen folgen, welche im Falle einer Übereinstimmung ausgeführt werden, bis das Ende des switch-Blocks erreicht wird.

Crystal Project Tutorials.png
Syntax:
switch(«Variable»){
    case «Wert»:
        «Anweisung»
        «...»
        »break;«

    «...»

    default: // Wird ausgeführt, falls die Variable keinem der Werte entsprach
        «Anweisung»
        «...»
}
«Nicht-C++-Code», »optional«
Symbol opinion vote.svg
Hinweis

Wird das break; am Ende eines Anweisungsblockes weggelassen, werden auch die darauf folgenden Blöcke ausgeführt, bis ein break; gefunden oder das Ende der switch-Anweisung erreicht ist.