Benutzer:Dirk Huenniger/cpp

Aus Wikibooks
Zur Navigation springen Zur Suche springen
C++ Programmierung


Benjamin Buch
Wikibooks

Inhaltsverzeichnis

Wie lese ich dieses Buch?[Bearbeiten]

Egal, ob Sie schon C++ können, eine andere Programmiersprache beherrschen oder kompletter Programmieranfänger sind. Wenn Sie in C++ programmieren wollen, werden Sie mit diesem Buch etwas anfangen können. Es steht Ihnen frei, das Buch ganz normal von Anfang an zu lesen oder sich die Kapitel herauszupicken, die Sie interessieren. Allerdings sollten Sie beim Herauspicken darauf achten, dass Sie den Stoff der vorherigen Kapitel beherrschen, andernfalls werden Sie wahrscheinlich Schwierigkeiten haben, das Kapitel Ihres Interesses zu verstehen.

Dieses Buch gliedert sich in verschiedene Abschnitte, von denen jeder einen eigenen Schwierigkeitsgrad und entsprechend eine eigene Zielgruppe hat. Die meisten Abschnitte vermitteln Wissen über C++ oder sollen die praktische Anwendung zeigen, um das bisherige Wissen zu festigen. Andere weisen auf Besonderheiten und „Stolpersteine“ hin oder vermitteln Hintergrundwissen.

  • Jeder Abschnitt enthält eine Anzahl von Kapiteln, welche einen komplexeren Zusammenhang erklären. Die Abschnitte sind in sich abgeschlossen, setzen aber voraus, dass Sie den Stoff der vorherigen Abschnitte verstanden haben.
  • Am Ende jedes Kapitels stehen meistens ein paar Fragen und/oder Aufgaben, die Ihnen helfen sollen zu überprüfen, ob Sie verstanden haben, was im entsprechenden Kapitel stand. Die Antworten auf die Fragen lassen sich einfach ausklappen, für die Aufgaben gibt es je einen Verweis auf eine Seite mit einer Musterlösung. Diese Musterlösung ist natürlich nicht die einzige Variante, um die Aufgabe korrekt zu erfüllen, sie dient lediglich als Beispiel, wie Sie es machen könnten. Zu beachten ist allerdings, dass das im Kapitel erworbene Wissen genutzt werden sollte, um die Aufgabe zu erfüllen.
  • Jeder Abschnitt schließt mit einer Zusammenfassung ab, die das vermittelte Wissen kurz und bündig auf den Punkt bringt. Wer schnell etwas nachschlagen will, kann sich in der Regel an die Zusammenfassungen halten. Auf Abweichungen von dieser Regel wird explizit hingewiesen.

„Für Programmieranfänger“ ist der nächste Abschnitt. Wenn Sie schon in einer anderen Programmiersprache Programme geschrieben haben, können Sie diesen Abschnitt getrost überspringen. Es geht nicht speziell um C++, sondern eher darum, zu begreifen, was überhaupt eine Programmiersprache ist und wie man dem Rechner sagen kann, was er zu tun hat.

Wenn Sie eine andere Programmiersprache schon sehr sicher beherrschen, reicht es wahrscheinlich, wenn Sie von den nächsten Abschnitten nur die Zusammenfassungen lesen, aber es kann Ihnen in keinem Fall schaden, auch die kompletten Abschnitte zu lesen. Die Zusammenfassungen sollen Ihnen zwar einen groben Überblick geben, was in diesem Abschnitt vermittelt wurde, aber es ist nun einmal nicht möglich, zur gleichen Zeit kurz und vollständig zu sein.

Sofern Sie C++ schon sicher beherrschen, können Sie sich einfach ein Kapitel aussuchen, es lesen und wenn nötig, in einem früheren Kapitel nachschlagen. Umsteigern ist dieses Verfahren hingegen nicht zu empfehlen, weil C++ eben doch etwas anderes ist als die meisten anderen Programmiersprachen.

In jedem Fall hoffen wir, dass dieses Buch Ihnen hilft, Programmieren zu lernen und Ihre Fähigkeiten zu verbessern, aber vergessen Sie niemals, dass ein Buch nur eine Stütze sein kann. Programmieren lernt man durchs Programmieren!


Es war einmal…[Bearbeiten]

C++ wurde von Bjarne Stroustrup ab 1979 in den AT&T Bell Laboratories entwickelt. Ausgangspunkt waren Untersuchungen des UNIX-Betriebssystemkerns in Bezug auf verteiltes Rechnen.

Auf die Idee für eine neue Programmiersprache war Stroustrup schon durch Erfahrungen mit der Programmiersprache Simula im Rahmen seiner Doktorarbeit an der Cambridge University gekommen. Simula erschien zwar geeignet für den Einsatz in großen Software-Projekten, die Struktur der Sprache erschwerte aber die für viele praktische Anwendungen erforderliche Erzeugung hocheffizienter Programme. Demgegenüber ließen sich effiziente Programme zwar mit der Sprache BCPL schreiben, für große Projekte war BCPL aber wiederum ungeeignet.

Mit den Erfahrungen aus seiner Doktorarbeit erweiterte Stroustrup nun die Programmiersprache C um ein Klassenkonzept, für das die Sprache Simula-67 das primäre Vorbild war. Die Wahl fiel auf die Programmiersprache C, eine Mehrzwecksprache, die schnellen Code produzierte und einfach auf andere Plattformen zu portieren war. Als dem Betriebssystem UNIX beiliegende Sprache hatte C außerdem eine nicht unerhebliche Verbreitung. Zunächst fügte er der Sprache Klassen (mit Datenkapselung) hinzu, dann abgeleitete Klassen, ein strengeres Typsystem, Inline-Funktionen und Standard-Argumente.

Während Stroustrup „C with Classes“ („C mit Klassen“) entwickelte (woraus später C++ wurde), schrieb er auch cfront, einen Compiler, der aus C with Classes zunächst C-Code als Zwischenresultat erzeugte. Die erste kommerzielle Version von cfront erschien im Oktober 1985.

1983 wurde C with Classes in C++ umbenannt. Erweiterungen darin waren: virtuelle Funktionen, Überladen von Funktionsnamen und Operatoren, Referenzen, Konstanten, änderbare Freispeicherverwaltung und eine verbesserte Typüberprüfung. Die Möglichkeit von Kommentaren, die an das Zeilenende gebunden sind, wurde wieder aus BCPL übernommen (//).

1985 erschien die erste Version von C++, die eine wichtige Referenzversion darstellte, da die Sprache damals noch nicht standardisiert war. 1989 erschien die Version 2.0 von C++. Neu darin waren Mehrfachvererbung, abstrakte Klassen, statische Elementfunktionen, konstante Elementfunktionen und die Erweiterung des Schutzmodells um protected. 1990 erschien das Buch „The Annotated C++ Reference Manual“, das als Grundlage für den darauffolgenden Standardisierungsprozess diente.

Relativ spät wurden der Sprache Templates, Ausnahmen, Namensräume, neuartige Typumwandlungen und boolesche Typen hinzugefügt.

Im Zuge der Weiterentwicklung der Sprache C++ entstand auch eine gegenüber C erweiterte Standardbibliothek. Erste Ergänzung war die Stream-I/O-Bibliothek, die Ersatz für traditionelle C-Funktionen wie zum Beispiel printf() und scanf() bietet. Eine der wesentlichen Erweiterungen der Standardbibliothek kam später durch die Integration großer Teile der bei Hewlett-Packard entwickelten Standard Template Library (STL) hinzu.

Nach jahrelanger Arbeit wurde schließlich 1998 die endgültige Fassung der Sprache C++ (ISO/IEC 14882:1998) genormt. 2003 wurde ISO/IEC 14882:2003 verabschiedet, eine Nachbesserung der Norm von 1998.

Die vorhandenen Performance-Probleme der Sprache C++, die Rechenzeit und Speicherplatz betreffen, wurden auf hohem Niveau zusammen mit Lösungen im Technical Report ISO/IEC TR 18015:2006 diskutiert. Das Dokument ist zum Download von ISO freigegeben. (http://www.open-std.org/jtc1/sc22/wg21/docs/TR18015.pdf)

Die aktuelle Version wurde am 11. Oktober 2011 als ISO/IEC 14882:2011 von der ISO veröffentlicht. Inoffiziell wird der Name C++11 verwendet, der Entwurf lief lange Zeit unter der inoffiziellen Bezeichnung C++0x. Die Entwürfe des C++-Standards können unter http://www.open-std.org/JTC1/SC22/WG21/ heruntergeladen werden. Das Dokument http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf stimmt mit C++11 bis auf minimale Änderungen überein.

Der offizielle Standard muss käuflich erworben werden, bei der ISO ist er für 238 Schweizer Franken zu haben, beim DIN zahlt man 659,60 €, beim ANSI steht der Preis bei 285 US-Dollar, bzw. 761 US-Dollar wenn man die britische Ausgabe kauft. Das INCITS verkauft ihn unter der Beizeichnung INCITS/ISO/IEC 14882-2012 für 30 US-Dollar. Es lohnt sich also die Preise der unterschiedlichen Herausgeber bzw. Anbieter zu vergleichen.

Der Name „C++“[Bearbeiten]

Der Name ist eine Wortschöpfung von Rick Mascitti und wurde zum ersten Mal im Dezember 1983 benutzt. Der Name kommt von der Verbindung der Vorgängersprache C und dem Inkrement-Operator „++“, der den Wert einer Variable um eins erhöht.

Weiterentwicklung der Programmiersprache C++[Bearbeiten]

Um mit den aktuellen Entwicklungen der sich schnell verändernden Computer-Technik Schritt zu halten, aber auch zur Ausbesserung bekannter Schwächen, erarbeitet das C++-Standardisierungskomitee derzeit die nächste größere Revision von C++, die inoffiziell mit C++16 abgekürzt wird, worin die Ziffernfolge eine grobe Einschätzung des möglichen Erscheinungstermins andeuten soll. Derzeit ist 2016 als Termin im Gespräch, doch ist eine Verschiebung um wenige Jahre durchaus nicht unwahrscheinlich.

Erweiterung der Programmbibliothek[Bearbeiten]

Im April 2006 gab das C++-Standardisierungskomitee den so genannten ersten technischen Report (TR1) heraus, eine nichtnormative Ergänzung zur damals gültigen, 1998 definierten Bibliothek, mit der Erweiterungsvorschläge vor einer möglichen Übernahme in die C++-Standardbibliothek auf ihre Praxistauglichkeit hin untersucht werden sollen.

Enthalten sind im TR1 u.a. reguläre Ausdrücke, verschiedene intelligente Zeiger, ungeordnete assoziative Container, eine Zufallszahlenbibliothek, Hilfsmittel für die C++-Metaprogrammierung, Tupel sowie numerische und mathematische Bibliotheken. Die meisten dieser Erweiterungen stammen aus der Boost-Bibliothek, woraus sie mit minimalen Änderungen übernommen wurden. Außerdem sind viele Bibliothekserweiterungen der 1999 überarbeiteten Programmiersprache C (C99) in einer an C++ angepassten Form enthalten.

Mit Ausnahme der numerischen und mathematischen Bibliotheken wurde die Übernahme aller TR1-Erweiterungen in die aktuelle Sprachnorm C++11 vom C++-Standardisierungskomitee beschlossen.

In Vorbereitung auf den nächsten Standard wird die Erweiterung im Bereich der Netzwerke, des Dateisystems und der Verwendung von XML und möglicherweise auch HTML diskutiert.


Compiler[Bearbeiten]

Was passiert beim Übersetzen[Bearbeiten]

Übersetzungsvorgang

Als Übersetzen oder compilieren bezeichnet man den Vorgang, den als Text geschriebenen Quellcode (engl. source code) in eine Sprache zu überführen, die der Computer versteht. Also in Einsen und Nullen. Dies passiert bei C++ in Drei Schritten. Um diese zu verstehen, ist zunächst ein Verständnis für die Dateistruktur von C++-Quellcode erforderlich.

Grob gesagt gibt es zwei Kategorien von Quellcode-Dateien in C++: Quelldateien und Headerdateien. Quelldateien sollten den Code enthalten, der die eigentlichen Anweisungen enthält und somit das Verhalten des Programms beschreibt. Headerdateien sollten Daten enthalten, welche die Struktur des Programms beschreiben. Um zu definieren, wie das Verhalten mit der Struktur verknüpft ist, bindet typischerweise jede Quelldatei mehrere Headerdateien ein.

Dies ist wie gesagt eine sehr grobe Beschreibung des Aufbaus, die jedoch beim Grundverständnis helfen kann. Damit können wir nun zum Übersetzungsprozess kommen.

Als erstes ist der Präprozessor (engl. Preprocessor) dran, dessen Hauptaufgabe es ist, alle benötigten Headerdateien in die Quellcodedateien zu kopieren. Auf diesen vom Präprozessor zusammengefügten Quelldateien arbeitet nun der Compiler. Er erzeugt aus jeder dieser Dateien eine sogenannte Objektdatei (engl. object file), die nicht mehr C++, sondern Maschinensprache enthält. Um aus diesen Objektdateien ein ausführbares Programm zu machen, müssen die Objektdateien schließlich vom Linker gebunden werden. (denglisch linken, engl. linking)

Das Ganze noch mal in Stichpunkten:

  1. Präprozessor: in jede Quelle alle nötigen Headern einfügen
  2. Compiler: jede vom Präprozessor erstellte C++-Quelle in Maschinensprache übersetzten
  3. Linker: in Maschinensprache übersetzte Dateien zu einem einzigen Programm zusammensetzen

Werkzeuge[Bearbeiten]

Wie es immer mit Software ist, stellt sich am Anfang die Frage, auf welcher Plattform bzw. welchem Betriebssystem man arbeitet. Ich (Prog) verwende seit vielen Jahren Linux und bin gerade beim Thema Softwareentwicklung sehr zufrieden damit. Auch Mac OS X soll sich sehr gut zum Programmieren eignen, wobei ich hier nur Erfahrungsberichte kenne. Microsoft Windows hingegen macht mir das Leben jedes Mal zur Hölle, wenn ich gezwungen bin dies zu verwenden. Immerhin ist die Situation letzten Jahren etwas besser geworden, da Microsoft sich beispielsweise um Tools zur automatisierten Einrichtung von Drittbibliotheken bemüht und generische Werkzeuge wie Git und die dazugehörigen Plattformen wie github.com oder [gitlab.com unter allen Betriebssystemen funktionieren.

Es gibt natürlich eine ganze Reihe von C++-Compilern, und wenn ich im Folgenden von Compilern spreche, meine ich auch Präprozessor und Linker, da diese drei Komponenten üblicherweise in einem Programm zusammengefasst sind. Die drei verbreitetsten Compiler sind GCC (OpenSource), clang (OpenSource) und Visual C++ (proprietär). Visual C++ darf in der kostenfreien Variante von Visual Studio nur für private Zwecke verwendet werden. GCC und clang dürfen auch kommerziell eingesetzt werden.

  1. clang (hohe Standardkonformität, gute Fehlermeldungen)
    Betriebssysteme: Linux, Mac OS X, Windows
  2. GCC (hohe Standardkonformität)
    Betriebssysteme: Linux, Mac OS X, Windows
  3. Visual C++ (schlechtere Standardkonformität und wesentlich langsamer als clang und GCC, holt aber langsam auf)
    Betriebssysteme: Windows

Ich entwickle gern »direkt von der Kommandozeile« aus, wobei ich für größere Projekte Boost.Build einsetze. Auf diese Weise hat man eine hohe Flexibilität und maximale Kontrolle über alle Vorgänge. Meine Entwicklungsumgebung besteht also im Wesentlichen aus einem Texteditor (ich verwende unter Linux Kate, den Standardeditor des KDE-Desktops, unter Windows Notepad++) und eine Kommandozeile, um den Compiler aufzurufen.

Die meisten Entwickler bevorzugen eine Integrierte Entwicklungsumgebung (kurz IDE) die ihnen den direkten Kontakt mit dem Compiler abnimmt. Speziell wenn Sie unter Windows arbeiten, ist eine IDE dringend zu empfehlen, weil die Kommandozeile von Windows eine absolute Katastrophe ist.

Im Folgenden eine kurze List der aus meiner Sicht wichtigsten IDEs:

  1. Visual Studio Code (nicht verwechseln mit Visual Studio!)
    Betriebssysteme: Linux, Mac OS X, Windows
    Compiler: GCC, clang, Visual C++
  2. QtCreator
    Betriebssysteme: Linux, Mac OS X, Windows
    Compiler: GCC, clang, Visual C++
  3. XCode (von Apple)
    Betriebssysteme: Mac OS X
    Compiler: clang
  4. Visual Studio (von Microsoft)
    Betriebssysteme: Windows
    Compiler: Visual C++, (clang – experimentell)

Ich empfehle sehr den QtCreator als IDE, da er Betriebssystem- und Compiler-Übergreifend eingesetzt werden kann und obendrein vergleichsweise einfach in der Bedienung ist. Windows-Nutzer können eine Version herunterladen, in die der GCC für Windows bereits integriert ist. Alternativ kann auch erst Visual Studio installiert werden und anschließend der QtCreator, der dann den Microsoft Compiler verwendet.

Wenn Sie QtCreator einsetzten und als Compiler GCC (Voreinstellung) oder clang verwenden, dann müssen Sie eventuell explizit den C++-Standard (C++11, C++14, C++17 …) angeben. Da sich das vorgehen hierzu ändert, verwenden Sie bitte eine Suchmaschine um herauszufinden, wie dies geht.

Unter Mac OS X verwenden die meisten Entwickler wohl XCode. Ich kenne dazu wieder nur Erfahrungsberichte, die sind allerdings in der Regel positiv.

Visual Studio Code verwende ich erst seit kurzem und bislang nicht für C++. Das Programm ist recht gut, eine Empfehlung kann ich aufgrund mangelnder eigener Erfahrung zur Zeit noch nicht aussprechen.

Visual Studio ist als IDE ganz gut, auch wenn es einige Macken hat, die sich auch gerne mal von PC zu PC unterscheiden können. Es ist sehr Umfangreich, was allerdings auch zu einer recht komplexen Bedienung führt. Gerade für Anfänger kann es daher schwierig zu bedienen sein. Der größte Nachteil von Visual Studio ist allerdings die Festlegung auf Visual C++ als Compiler. Fakt ist, dass Visual Studio in der Industrie weit verbreitet ist.

Symbol oppose vote oversat.svg
Nicht Thema dieses Buches…

Falls Sie Windows verwenden und bislang keine Erfahrung mit Programmierung haben, kann ich empfehlen, VirtualBox zu installieren und darin dann ein Linux (z. B. Kubuntu Long Term Support) laufen zu lassen. Das erlaubt es clang oder GCC ohne die massiven Schwierigkeiten zu verwenden, die man unter Windows mit diesen Compiler und auch in einigen Aspekten der eigentlichen Entwicklung hat.

Was genau VirtualBox ist und wie es funktioniert finden Sie mit einem (Video)-Tutorial Ihrer Wahl sicher schnell heraus. Die Felsen die Windows einem in den Weg legt, kompensieren nach meiner Erfahrung recht schnell den Aufwand, ein paar Sachen rund um die Nutzung von Linux lernen zu müssen. Allein die Kommandozeile von Linux ist im Vergleich zur "CMD" diesen Aufwand wert.

GCC & clang[Bearbeiten]

GCC steht für Gnu Compiler Collection und ist eine Sammlung von freien Compilern, darunter auch den C++-Compiler g++. Der C++-Compiler clang++ gehört hingegen zum LLVM-Projekt. Achten Sie bei clang auf das ++, da clang ohne ++ (ein C-Compiler) zwar ebenfalls C++ übersetzen kann, wenn man den C++-Standard angibt, aber dann meist beim Linken Probleme macht.

Sowohl GCC als auch LLVM stellen auch Compiler für viele andere Sprachen bereit. Beide sind weit verbreitet. GCC ist deutlich älter, während sich LLVM in den letzten Jahren immer weiter steigender Beliebtheit erfreut und die Compiler der GCC inzwischen in einigen Punkten überholt hat. Beide sind für viele Betriebssysteme und Prozessorarchitekturen verfügbar, wobei GCC hier noch leicht die Nase vorn hat. Die wichtigsten Commandozeilen-Parameter sind bei beiden identisch, so dass es egal ist, welchen Sie primär verwenden. Sie können jederzeit mal eben auch mit dem jeweils anderen übersetzten, um »eine zweite Meinung« zu ihrem Code zu bekommen, falls Probleme auftreten.

Der größte Unterschied zwischen den beiden, ist ein Politischer. Die GCC steht unter der GNU General Public License (GNU GPL), LLVM-Projekte stehen unter BSD- und MIT-ähnlichen Lizenzen. Das heißt, beide sind Freie Software und jeder ist berechtigt, den Quellcode einzusehen, zu verändern und natürlich auch beliebigen Quellcode mit den Compilern zu übersetzten. Sie dürfen also sowohl private Projekte, als auch kommerzielle Projekte ohne Einschränkung mit diesen Compilern übersetzen. Bei Visual Studio benötigen Sie hingegen eine gekaufte Lizenz, wenn Sie kommerzielle Produkte damit übersetzen wollen.

Allerdings müssen Änderungen am Quellcode von GCC wiederum unter die GNU GPL gestellt werden. Änderungen an LLVM-Projekten dürfen unter eine beliebige Lizenz gestellt werden. Für Sie als Entwickler, der die Compiler nur verwendet, und keine Änderungen daran vornimmt, spielt das keine Rolle, aber für Firmen, die den Compiler in Ihre Produkte integrieren wollen. Sie sind im Falle von GCC gezwungen, mit der Community zusammenzuarbeiten, und können Ihre eigenen Änderungen an GCC nicht vor der Welt verstecken, sondern müssen Sie wieder freigeben.

Auf fast allen GNU/Linux ist GCC üblicherweise der Standardcompiler. Unter Mac OS X und FreeBSD (ein weiteres freies Unixoides Betriebssystem) ist clang inzwischen der Standardcompiler. Unter Windows gibt es in dem Sinne keinen Compiler, weil es unter Windows nie üblich war, dass Benutzer selbst Programme übersetzten. Dies liegt vor allem daran, dass Windows, verglichen mit dem Stammbaum der Unixoiden Systeme (BSD, Mac OS X, Linux & viele weitere) ein sehr junges Betriebssystem ist und zum Zeitpunkt der Einführung Software schon nicht mehr im Quellcode ausgeliefert wurde.

Aber jetzt ist Schluss mit der Theorie. Schauen wir uns erst einmal an, wie g++ benutzt wird. Im folgenden wird angenommen, dass eine Datei mit dem Namen prog.cpp vorhanden ist. In dieser Datei könnte zum Beispiel folgendes stehen:

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 
3 int main(){
4     std::cout << "Hallo Welt" << std::endl;
5 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Hallo Welt

Dieses Programm müssen Sie noch nicht verstehen, im Kapitel Hallo, du schöne Welt! wird es erklärt. Nun geben Sie auf der Kommandozeile (GNU/Linux: Shell, Windows: Eingabeaufforderung) folgendes ein:

g++ prog.cpp

g++ ist der Name des Programms, welches aufgerufen wird, also der Compiler g++. prog.cpp ist der Name der Datei, die kompiliert werden soll. Wenn Sie diesen Befehl ausführen, sehen Sie entweder Fehlermeldungen auf dem Bildschirm, oder aber Sie bekommen eine Datei mit dem Namen a.out. Manchmal bekommen Sie auch sogenannte „warnings“, also Warnungen. Bei diesen Warnungen wird der Code zwar kompiliert, aber Sie sollten versuchen, warnungsfreie Programme zu schreiben. Ein Beispiel für eine Warnung könnte z.B. sein:

g++ prog.cpp
prog.cpp: In function `int main()':
prog.cpp:17: warning: comparison between signed and unsigned integer expressions

In diesem Beispiel würde die Warnung bedeuten, dass wir eine Zahl ohne Vorzeichen (unsigned) und eine mit Vorzeichen (signed) vergleichen, und zwar innerhalb der Funktion `int main()', genauer gesagt in Zeile 17. Was unsigned und signed ist, erfahren Sie im Kapitel Variablen, Konstanten und ihre Datentypen.

Es gibt auch einige, zum Teil hilfreiche Warnungen, die nicht angezeigt werden. Um diese zu sehen, müssen Sie die Option -Wall hinzufügen.

g++ -Wall prog.cpp

Um sich noch mehr Warnungen anzeigen zu lassen (-Wall zeigt auch nicht alle), können Sie auch noch -Wextra benutzen:

g++ -Wall -Wextra prog.cpp

Es wird empfohlen, diese Möglichkeit zu nutzen, vor allem wenn Sie auf der Suche nach Fehlern in Ihrem Programm sind.

Möchten Sie, dass das fertige Programm einen anderen Namen als a.out hat, so können Sie es natürlich jedesmal umbenennen. Dies ist aber umständlich und somit nicht zu empfehlen. Ein viel eleganterer Weg ist das Benutzen der Option -o.

g++ -o tollername prog.cpp

Der Dateiname nach der Option -o gibt an, in welche Datei das kompilierte Programm gespeichert werden soll. So erhalten Sie in diesem Beispiel die ausführbare Datei tollername.

Sollten Sie sich einmal nicht mehr erinnern, was eine bestimmte Funktion bewirkte oder wie sie hieß, so können Sie g++ einfach nur mit der Option --help aufrufen.

g++ --help

g++ gibt dann eine kurze Auflistung der Optionen aus. Wer gerne eine detailliertere Version hätte, kann unter GNU/Linux auch das Manualprogramm „man“ benutzen:

man g++

Ausführlichere und übersichtlichere Dokumentation, die nicht nur die Kommandozeilenoptionen vorstellt, sind im Dokumentationssystem info zu finden, das auf vielen GNU/Linux- und BSD-Systemen installiert ist:

info g++

Für Fortgeschrittenere[Bearbeiten]

Jetzt sollten Sie erst einmal den Rest des Kapitels überspringen und mit einigen der folgenden Buchkapitel weitermachen, denn für den Rest ist ein wenig Vorwissen sehr hilfreich. Sobald Sie mit den ersten paar Kapiteln fertig sind, können Sie hierher zurückkehren und den Rest lesen.

Was passiert überhaupt, wenn Sie g++ aufrufen? Nun, als erstes wird der Code vom Präprozessor durchgeschaut und bearbeitet. (Natürlich bleibt Ihre Quelldatei, wie sie ist.) Dabei werden beispielsweise Makros ersetzt und Kommentare gelöscht. Dieser bearbeitete Code wird dann vom Compiler in die Assemblersprache übersetzt. Die Assemblersprache ist auch eine Programmiersprache, welche aber nur die Maschinensprache so darstellt, dass ein Mensch sie (leichter) lesen kann. Schließlich wird diese Assemblersprache von einem Assembler in Maschinencode umgewandelt. Zum Schluss wird noch der Linker aufgerufen, der die einzelnen Programmdateien und die benutzten Bibliotheken "verbindet".

Darum, dass dies alles in korrekter Reihenfolge richtig ausgeführt wird, brauchen Sie sich nicht zu kümmern; g++ erledigt das alles für Sie. Allerdings kann es manchmal nützlich sein, dass das Programm noch nicht gelinkt wird, etwa wenn Sie mehrere Quelldateien haben. Dann kann man einfach dem g++ die Option -c mitgeben.

g++ -c -o prog.o prog.cpp

Durch diesen Aufruf erhalten wir eine Datei prog.o, die zwar kompiliert und assembliert, aber noch nicht gelinkt ist. Deswegen wurde die Datei auch prog.o genannt, da ein kompiliertes und assembliertes, aber nicht gelinktes Programm als Objektdatei vorliegt. Objektdateien bekommen üblicherweise die Endung *.o. Ohne die -o Option hätten Sie möglicherweise eine Datei gleichen Namens erhalten, aber das ist nicht absolut sicher. Es ist besser den Namen der Ausgabedatei immer mit anzugeben; so können Sie sicher sein, dass die ausgegeben Dateien auch wirklich den von Ihnen erwarteten Namen haben.

Bei g++ gibt es Unmengen von Optionen, mit denen Sie fast alles kontrollieren können. So gibt es natürlich auch eine Option, durch die kompiliert, aber nicht assembliert wird. Diese Option heißt -S.

g++ -S prog.cpp

Diese Option wird allerdings fast nie benötigt, es sei denn Sie interessieren sich dafür, wie Ihr Compiler Ihren Code in Assembler umsetzt. Die Option -E ist schon nützlicher. Mit ihr wird nur der Präprozessor ausgeführt:

g++ -E prog.cpp

So können Sie z. B. sehen, ob mit den Makros alles ordnungsgemäß geklappt hat oder die Headerdateien eventuell in einer von Ihnen unerwarteten Reihenfolge inkludiert wurden. Eine Warnung sollen Sie hier aber mit auf den Weg bekommen. Wenn der Präprozessor durchgelaufen ist, stehen auch alle mittels #include eingebundenen Headerdateien der Standardbibliothek mit im Quelltext, die Ausgabe kann also ziemlich lang werden. Allein das Einbinden von iostream produziert bei g++ 4.6.3 knapp 19 000 Zeilen Code. Welche Zeit es in Anspruch nimmt, den Quellcode nach dem Übersetzen in Assembler (Option -S) zu lesen, dürfte damit geklärt sein.

Sie sollten auch die Option -ansi kennen. Da g++ einige C++ Erweiterungen beinhaltet, die nicht im C++-Standard definiert sind oder sogar mit ihm im Konflikt stehen, ist es nützlich, diese Option zu verwenden, wenn Sie ausschließlich mit Standard-C++ arbeiten wollen. In der Regel ist das zu empfehlen, da sich solcher Code viel leichter auf andere Compiler portieren lässt. Im Idealfall müssten Sie gar keine Änderungen mehr vornehmen. Da aber weder g++ noch irgendein anderer Compiler absolut standardkonform sind, ist das selten der Fall. Ein Negativbeispiel für standardkonforme Compiler kommt immer mal wieder aus Redmond. Die dort ansässige Firma produziert in der Regel Produkte, die zu ihren selbstdefinierten Standards in einer bestimmten Version (also nicht mal untereinander) kompatibel sind. Beschweren Sie sich bitte nicht, wenn einige Programmbeispiele mit deren Compiler nicht kompiliert werden. Der Fairness halber soll trotzdem angemerkt werden, dass langsam aber doch sicher Besserung in Sicht ist.

g++ -ansi -o prog prog.cpp

Dies bewirkt, dass diese nicht standardkonformen Erweiterungen des g++-Compilers abgeschaltet werden. Solcher Code ist in der Regel die bessere Wahl, da er auch in Zukunft, wenn es neue Compiler oder Compiler-Versionen geben wird, noch mit ihnen übersetzt werden kann.

Möchten Sie eine Warnung erhalten, wenn nicht standardkonforme Erweiterungen von g++ verwendet werden, dann nutzen Sie die Option -pedantic:

g++ -pedantic -o prog prog.cpp

Um die Optimierung zuzuschalten, nutzen Sie die Option -Ox, wobei das x für eine Zahl von 1 bis 3 steht. 3 bedeutet stärkste Optimierung.

g++ -O3 -o prog prog.cpp

Programme, die mit Optimierung übersetzt wurden, sind kleiner und laufen schneller. Der Nachteil besteht in der höheren Zeit, welche für die Übersetzung an sich benötigt wird. Daher sollten Sie die Optimierung nur zuschalten, wenn Sie eine Programmversion erstellen, die Sie auch benutzen möchten. Beim Austesten während der Entwicklung ist es besser, ohne Optimierung zu arbeiten, da häufig kompiliert wird. Eine lange Wartezeit, nur um dann einen Programmdurchlauf zu machen, ist schlicht nervtötend.

Externe Bibliotheken benutzen[Bearbeiten]

Die C++-Standardbibliothek ist zwar eine wohl durchdachte und vielfach bewährte Bibliothek für Ihre Programme; allerdings ist sie kein Wundermittel für alle Probleme. Um auch andere Bibliotheken mit einem Programm nutzen zu können, bietet der Compiler spezielle Optionen an.

Headerdateien finden[Bearbeiten]

Damit die Quelldateien, die die externe Bibliothek benutzen, übersetzt werden können, muss der Präprozessor die Headerdateien finden. Mit dem Befehl cpp -v werden die Standardverzeichnisse ausgegeben, in denen nach Headerdateien gesucht wird. Befinden sich die Dateien der Bibliothek in einem anderen Verzeichnis, muss dieses mit der Option -I angegeben werden. Die imaginäre Bibliothek libfoo bietet z.B. eine Headerdatei foo.h im Verzeichnis /usr/include/libfoo an. Folgender Befehl wäre damit nötig:

g++ -I/usr/include/libfoo -o prog prog.cpp

Die Quelldatei kann die Headerdatei nun wie jede andere Datei der Standardbibliothek einbinden:

Nuvola-inspired-terminal.svg
1 #include <foo.h>

Mit Bibliothek linken[Bearbeiten]

Es reicht aber noch nicht aus, dass die Headerdateien eingebunden werden können. Der Linker muss den compilierten Code der Quelldateien zusammen mit der Bibliothek linken. Dafür bietet der Compiler die Option -l an, die den Namen der Bibliothek benötigt. Die Zeichenkette lib kann weggelassen werden, aus libfoo wird also einfach nur foo:

 g++ -I/usr/include/libfoo -lfoo -o prog prog.cpp

Makefiles[Bearbeiten]

Was ist make?[Bearbeiten]

Bei make handelt es sich um ein Werkzeug, mit dem man die Abhängigkeiten eines Build Prozesses auflösen kann. Dieses Stück Software ist schon sehr alt und in unterschiedlichsten Implementierungen verfügbar, die verbreitesten sind wohl GNU make und BSD make. Leider sind die verschiedenen Varianten untereinander nicht ganz kompatibel.

Makefiles per Hand erstellen[Bearbeiten]

make kann sehr viel mehr, als hier beschrieben werden könnte, es folgt daher lediglich eine kurze Erläuterung, um was es eigentlich geht. In einem Makefile lassen sich Regeln beschreiben, wie bestimmte "Targets" (Ziele) erstellt werden können. Diese können von anderen Zielen oder Dateien abhängen.

Beispielsweise erstellt man eine Objektdatei aus einer Sourcedatei, indem man sie kompiliert. Dazu muss aber natürlich die Sourcedatei vorhanden sein. Eine solche Regel könnte zum Beispiel so aussehen:

hello.o: hello.c
    $(CC) -c $(CFLAGS) hello.c

Die erste Zeile besagt, dass zum Erstellen von hello.o die Datei hello.c benötigt wird. Die Zweite sagt aus, wie das Erstellen von hello.o zu bewerkstelligen ist. Variablen werden mit $ eingeleitet. So beinhaltet zum Beispiel $(CC) in der Regel den Namen des C Compilers.

Derartige Regeln kann man auch mit Wildcards versehen, so kann man eine Regel erstellen, mit der man ausdrücken kann, wie generell aus einer *.c eine *.o Datei zu erstellen ist:

%.o: %.c
    $(CC) -c $(CFLAGS) $< 

Dabei steht die spezielle Variable $< für den Namen der tatsächlichen Source Datei, wie zum Beispiel hello.c.


Beispiel:

CC = gcc
OBJECTS = cbg.o
LIBS = -lcurl
CFLAGS = -Wall -O2
BINDIR = $(DESTDIR)/usr/bin
NAME = cbg
cbg: $(OBJECTS)
   $(CC) -o $(NAME) $(OBJECTS) $(LIBS)
%.o: %.c
   $(CC) -c $(CFLAGS) $<
install:
   install --mode=755 $(NAME) $(BINDIR)/
clean:
   rm *.o $(NAME)
uninstall:
   rm $(BINDIR)/$(NAME) 

Damit ist es nun möglich, die einzelnen Ziele zu erstellen:

make install
make clean
make uninstall 

Wird kein Ziel angegeben, so wird das erste Ziel erstellt, in obigen Beispiel also cbg.

Automake[Bearbeiten]

Boost Build[Bearbeiten]

Eine sehr gute alternative zu Makefiles. http://www.boost.org/doc/tools/build/index.html


GUIs und C++[Bearbeiten]

Was ist ein GUI?[Bearbeiten]

GUI kommt vom englischen „Graphical User Interface“, was soviel heißt wie „Graphische Benutzerschnittstelle“. Grob gesagt ist es das, was der Benutzer von den meisten Programmen zu sehen bekommt. Also: Die Menüleiste, Textfelder, Buttons u.s.w.

Weiterhin gibt es natürlich noch das „Command Line Interface“ (kurz CLI, zu Deutsch "Kommandozeilenschnittstelle"), das vielen als Fenster mit schwarzem Hintergrund und mit weißer Schrift bekannt ist.

C++ und GUIs[Bearbeiten]

C++ bringt von Haus aus kein GUI mit, da es als hardwarenahe plattformunabhängige Sprache erstellt wurde und GUIs stark vom verwendeten Betriebssystem abhängen. Dieser „Mangel“ könnte einige Neueinsteiger vielleicht auf den ersten Blick abschrecken, da sie sich einen Einstieg in C++ oder gar in die gesamte Programmierung mit vielen Buttons, Textfeldern, Statusanzeigen und Menüeintragen erhofft haben.

Wer jedoch einmal damit angefangen hat, kleinere Programme zu schreiben, wird schnell merken, dass der Reiz hier nicht von bunten Farben und blinkenden Symbolen ausgeht. Ganz im Gegenteil. Gerade für den Anfänger ist es am besten, wenn die eigentliche Funktion nicht durch Tonnen von "Design-Code" überdeckt und unleserlich gemacht wird. Hat man erst einmal die Grundlagen erlernt, so ist es nicht schwer auch ansprechende Oberflächen zu erstellen.

Es gibt eine ganze Reihe von Bibliotheken, die eine weitgehend plattformübergreifende Programmierung mit C++ als Sprache ermöglichen. Aber auch die Programmierung über die API (für engl. „application programming interface“, deutsch: „Schnittstelle zur Anwendungsprogrammierung“) des spezifischen Betriebssystems ist natürlich möglich.

Einsatz von GUI[Bearbeiten]

Sobald man mit C++ dann doch ein GUI programmieren will, sollte auf externe Bibliotheken zurückgegriffen werden. Alle GUIs erfordern ein Verständnis der C++ Grundlagen. Nachfolgend sind einige Bibliotheken zur GUI-Programmierung aufgelistet. Viele der Bibliotheken lassen sich auch mit anderen Programmiersprachen einsetzen.

Qt[Bearbeiten]

Qt ist eine leistungsstarke plattformübergreifende Klassenbibliothek mit Meta-Object Compiler (gennant: moc), die von der norwegischen Firma Trolltech entwickelt wurde. Trolltech wurde 2008 von Nokia übernommen, welches jedoch wirtschaftliche Schwierigkeiten hatte und in der Folge Qt 2011 an das finnische Softwareunternehmen Digia verkaufte.

Die Entwicklung wird inzwischen vom Qt Project vorangetrieben, so dass jeder sich daran beteiligen kann. Die Klassenbibliothek ist unter der GNU General Public License (GPL) und der GNU Lesser General Public License (LGPL) lizenziert. Es gibt außerdem eine proprietäre Lizenz von Digia, die allerdings lediglich zusätzlichen technischen Support beinhaltet.

Speziell aufgrund der Veränderungen, die mit Qt 5 und C++11 Einzug in das Framework halten, ist Qt eine der mächtigsten Bibliotheken für C++. Ein weiterer Vorteil von Qt ist die vollständig freie Entwicklungsumgebung Qt Creator, die insbesondere Anfängern das Programmieren leichter macht.

Symbol redirect vote.svg
Buchempfehlung

Das Buch „Qt für C++-Anfänger“ gibt einen Einstieg in die Programmierung mit Qt. Es behandelt nicht viele Themen und ist somit wirklich nur zum Kennenlernen des Frameworks geeignet. Dafür sind die vorhandenen Seiten aber auch gut gefüllt.

GTK+[Bearbeiten]

Das GIMP-Toolkit (abgekürzt: GTK+) ist eine freie Komponentenbibliothek, die in C geschrieben ist und unter der GNU Lesser General Public License (LGPL) steht. Um dieses Framework in C++ zu nutzen gibt es ein Framework namens Gtkmm. Wie Qt ist es für viele Plattformen verfügbar.

wxWidgets[Bearbeiten]

wxWidgets ist ein auf C++ basierendes Open-Source-Framework zur plattformunabhängigen Entwicklung von Anwendungen mit grafischer Benutzeroberfläche (GUI). Die wxWidgets-Lizenz ist eine leicht modifizierte LGPL und erlaubt daher ebenfalls die freie Verwendung in proprietärer und freier Software und den weiteren Vertrieb unter einer selbst gewählten Lizenz.

MFC[Bearbeiten]

Die Microsoft Foundation Classes (MFC) sind ein C++ Framework, vor allem zur GUI-Programmierung unter Microsoft Windows. Es verwendet Entwurfsmuster, insbesondere Document-View (Model-View-Controller), Singleton, Bridge und Observer, um Funktionalität der Windows-API zu kapseln. Außerdem gibt es eine enorme Anzahl an Hilfsmakros zur Unterstützung bei RTTI („Runtime Type Information“), Nachrichtenbehandlung, dynamischer Instanziierung etc.. Da sie seit 1992 in jeder -nicht Express- Version von Microsoft Visual C++ enthalten sind ist ihre Verbreitung auf der Windows-Plattform sehr hoch. Die Verwendung ist an eine kommerzielle Lizenz gebunden, den Besitz einer kostenpflichtigen Version von Visual C++, die MFC-Laufzeitumgebung ist kostenlos. Für die GUI-Entwicklung mit C++ -nicht C++/CLI- auf Windows sind die MFC das am weitesten verbreitete Framework das direkt auf der Windows-API aufsetzt.


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 kept vote.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 kept vote.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 kept vote.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 kept vote.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 kept vote.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.


Prozeduren und Funktionen[Bearbeiten]

Unter einer Funktion (function, in anderen Programmiersprachen auch Prozedur oder Subroutine genannt) versteht man ein Unterprogramm, das eine bestimmte Aufgabe erfüllt. Funktionen sind unter anderem sinnvoll, um sich wiederholende Aufgaben zu kapseln, so dass die Befehle nicht jedesmal neu geschrieben werden müssen. Zudem verbessert es die Übersichtlichkeit der Quellcode-Struktur erheblich, wenn der Programmtext logisch in Abschnitte unterteilt wird.

Parameter und Rückgabewert[Bearbeiten]

Die spezielle Funktion main() ist uns schon mehrfach begegnet. In C++ lassen sich Funktionen nach folgenden Kriterien unterscheiden:

  • Eine Funktion kann Parameter besitzen, oder nicht.
  • Eine Funktion kann einen Wert zurückgeben, oder nicht.

Dem Funktionsbegriff der Mathematik entsprechen diejenigen C++-Funktionen, die sowohl Parameter haben als auch einen Wert zurückgeben. Dieser Wert kann im Programm weiter genutzt werden, um ihn z.B. einer Variablen zuzuweisen.

Nuvola-inspired-terminal.svg
1 int a = f(5); // Aufruf einer Funktion

Damit diese Anweisung fehlerfrei kompiliert wird, muss vorher die Funktion f() deklariert worden sein. Bei einer Funktion bedeutet Deklaration die Angabe des Funktionsprototyps. Das heißt, der Typ von Parametern und Rückgabewert muss angegeben werden. Das folgende Beispiel deklariert bspw. eine Funktion, die einen Parameter vom Typ char besitzt und einen int-Wert zurückgibt.

Nuvola-inspired-terminal.svg
1 int f (char x); // Funktionsprototyp == Deklaration

Soll eine Funktion keinen Wert zurückliefern, lautet der Rückgabetyp formal void.

Nach dem Compilieren ist das Linken der entstandenen Objektdateien zu einem ausführbaren Programm nötig. Der Linker benötigt die Definition der aufzurufenden Funktion. Eine Funktionsdefinition umfasst auch die Implementation der Funktion, d.h. den Code, der beim Aufruf der Funktion ausgeführt werden soll. In unserem Fall wäre das:

Nuvola-inspired-terminal.svg
 1 int f(int x);     // Funktionsdeklaration
 2 
 3 int main(){
 4     int a = f(3); // Funktionsaufruf
 5     // a hat jetzt den Wert 9
 6 }
 7 
 8 int f(int x){    // Funktionsdefinition
 9     return x * x;
10 }
Symbol opinion vote.svg
Hinweis

Innerhalb eines Programms dürfen Sie eine Funktion beliebig oft (übereinstimmend!) deklarieren, aber nur einmal definieren.

Der Compiler muss die Deklaration kennen, um eventuelle Typ-Unverträglichkeiten abzufangen. Würden Sie die obige Funktion z.B. als int a = f(2.5); aufrufen, käme die Warnung, dass f() ein ganzzahliges Argument erwartet und keine Fließkommazahl. Eine Definition ist für den Compiler auch immer eine Deklaration, das heißt Sie müssen nicht explizit eine Deklaration einfügen, um eine Funktion aufzurufen, die zuvor definiert wurde.

Die Trennung von Deklaration und Definition kann zu übersichtlicher Code-Strukturierung bei größeren Projekten genutzt werden. Insbesondere ist es sinnvoll, Deklarationen und Definitionen in verschiedene Dateien zu schreiben. Oft will man, wenn man fremden oder alten Code benutzt, nicht die Details der Implementierung einer Funktion sehen, sondern nur das Format der Parameter o.ä. und kann so in der Deklarationsdatei (header file, üblicherweise mit der Endung .hpp, z.T. auch .h oder .hh) nachsehen, ohne durch die Funktionsrümpfe abgelenkt zu werden. (Bei proprietärem Fremdcode bekommt man die Implementation in der Regel gar nicht zu Gesicht!)

Bei einer Deklaration ist es nicht nötig, die Parameternamen mit anzugeben, denn diese sind für den Aufruf der Funktion nicht relevant. Es ist allerdings üblich, die Namen dennoch mit anzugeben, um zu verdeutlichen was der Parameter darstellt. Der Compiler ignoriert die Namen in diesem Fall einfach, weshalb es auch möglich ist den Parametern in der Deklaration und der Definition unterschiedliche Namen zu geben. Allerdings wird davon aus Gründen der Übersichtlichkeit abgeraten.

Mit der Anweisung return gibt die Funktion einen Wert zurück, in unserem Beispiel x * x, wobei die Variable x als Parameter bezeichnet wird. Als Argument bezeichnet man eine Variable oder einen Wert, mit denen eine Funktion aufgerufen wird. Bei Funktionen mit dem Rückgabetyp void schreiben Sie einfach return; oder lassen die return-Anweisung ganz weg. Nach einem return wird die Funktion sofort verlassen, d.h. alle nachfolgenden Anweisungen des Funktionsrumpfs werden ignoriert.

Erwartet eine Funktion mehrere Argumente, so werden die Parameter durch Kommas getrennt. Eine mit

Nuvola-inspired-terminal.svg
1 int g(int x, double y);

deklarierte Funktion könnte z.B. so aufgerufen werden:

Nuvola-inspired-terminal.svg
1 int a = g(123, -4.44);

Für eine leere Parameterliste schreiben Sie hinter den Funktionsnamen einfach ().

Nuvola-inspired-terminal.svg
1 int h(){     // Deklaration von h()
2   // Quellcode ...
3 }
4 
5 int a = h(); // Aufruf von h()
Symbol opinion vote.svg
Hinweis

Vergessen Sie beim Aufruf einer Funktion ohne Parameter nicht die leeren Klammern. Andernfalls erhalten Sie nicht den von der Funktion zurückgelieferten Wert, sondern die Adresse der Funktion. Dies ist ein „beliebter“ Anfängerfehler, daher sollten Sie im Falle eines Fehlers erst einmal überprüfen, ob Sie nicht vielleicht irgendwo eine Funktion ohne Parameter falsch aufgerufen haben.

Übergabe der Argumente[Bearbeiten]

C++ kennt zwei Varianten, wie einer Funktion die Argumente übergeben werden können: call-by-value und call-by-reference.

call-by-value[Bearbeiten]

Bei call-by-value (Wertübergabe) wird der Wert des Arguments in einen Speicherbereich kopiert, auf den die Funktion mittels Parametername zugreifen kann. Ein Werteparameter verhält sich wie eine lokale Variable, die „automatisch“ mit dem richtigen Wert initialisiert wird. Der Kopiervorgang kann bei Klassen (Thema eines späteren Kapitels) einen erheblichen Zeit- und Speicheraufwand bedeuten!

Crystal Clear action button cancel.svg
 1 #include <iostream>
 2 
 3 void f1(int const x) {
 4     x = 3 * x;       // ungültig, weil Konstanten nicht überschrieben werden dürfen
 5     std::cout << x << std::endl;
 6 }
 7 
 8 void f2(int x) {
 9     x = 3 * x;
10     std::cout << x << std::endl;
11 }
12 
13 int main() {
14    int a = 7;
15    f1(a);          // Ausgabe: 21
16    f2(5);          // Ausgabe: 15
17    std::cout << x; // Fehler! x ist hier nicht definiert
18    std::cout << a; // a hat immer noch den Wert 7
19 
20    return 0;
21 }

Wird der Parameter als const deklariert, so darf ihn die Funktion nicht verändern (siehe erstes Beispiel). Im zweiten Beispiel kann die Variable x verändert werden. Die Änderungen betreffen aber nur die lokale Kopie und sind für die aufrufende Funktion nicht sichtbar.

call-by-reference[Bearbeiten]

Sollen die von einer Funktion vorgenommen Änderungen auch für das Hauptprogramm sichtbar sein, müssen in C sogenannte Zeiger verwendet werden. C++ stellt ebenfalls Zeiger zur Verfügung. C++ gibt Ihnen aber auch die Möglichkeit, diese Zeiger mittels Referenzen zu umgehen, was im alten C nicht möglich war. Beide sind jedoch noch Thema eines späteren Kapitels.

Im Gegensatz zu call-by-value wird bei call-by-reference die Speicheradresse des Arguments übergeben, also der Wert nicht kopiert. Änderungen der (Referenz-)Variable betreffen zwangsläufig auch die übergebene Variable selbst und bleiben nach dem Funktionsaufruf erhalten. Um call-by-reference anzuzeigen, wird der Operator & verwendet, wie Sie gleich im Beispiel sehen werden. Wird keine Änderung des Inhalts gewünscht, sollten Sie den Referenzparameter als const deklarieren, um so den Speicherbereich vor Änderungen zu schützen. Fehler, die sich aus der ungewollten Änderung des Inhaltes einer übergebenen Referenz ergeben, sind in der Regel schwer zu finden.

Die im folgenden Beispiel definierte Funktion swap() vertauscht ihre beiden Argumente. Weil diese als Referenzen übergeben werden, überträgt sich das auf die Variablen, mit denen die Funktion aufgerufen wurde:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 void swap(int &a, int &b) {
 4     int tmp = a; // "temporärer" Variable den Wert von Variable a zuweisen
 5     a = b;       // a mit dem Wert von Variable b überschreiben
 6     b = tmp;     // b den Wert der "temporären" Variable zuweisen (Anfangswert von Variable a) 
 7 }
 8 
 9 int main() {
10     int x = 5, y = 10;
11 
12     swap(x, y);
13 
14     std::cout << "x=" << x << " y=" << y << std::endl;
15 
16     return 0;
17 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 x=10 y=5
Symbol kept vote.svg
Tipp

Ob das kaufmännische Und (&) genau nach int (int& a, ...), oder genau vor der Variablen a (int &a, ...), oder dazwischen (int & a, ...) steht, ist für den Compiler nicht von Bedeutung. Auch möglich wäre (int&a, ...).

Nicht-konstante Referenzen können natürlich nur dann übergeben werden, wenn das Argument tatsächlich eine Speicheradresse hat, sprich eine Variable bezeichnet. Ein Literal z.B. 123 oder gar ein Ausdruck 1 + 2 wäre hier nicht erlaubt. Bei const-Referenzen wäre das möglich, der Compiler würde dann eine temporäre Variable anlegen.

Array[Bearbeiten]

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

Wir werden die oben angesprochenen Zeiger in einem späteren Kapitel ausführlich kennen lernen. Sie ermöglichen z.B. das Arbeiten mit Arrays. Soll eine Funktion mit einem Array umgehen, werden ihr die Startadresse des Arrays (ein Zeiger) und seine Größe als Parameter übergeben. Wenn das Array nur gelesen werden soll, deklariert man die Werte, auf die der Zeiger zeigt, als const. Das Zeichen * signalisiert, dass es sich um einen Zeiger handelt.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 void print(int const* array, int const arrayGroesse) {
 4     std::cout << "Array:" << std::endl;
 5     for (int i = 0; i < arrayGroesse; ++i) {
 6         std::cout << array[i] << std::endl;
 7     }
 8 }
 9 
10 int main() {
11     int array[] = { 3, 13, 113 };
12     int n = sizeof(array) / sizeof(array[0]);
13 
14     print(array, n);
15 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Array:
2 3
3 13
4 113

Default-Parameter[Bearbeiten]

Default-Parameter dienen dazu, beim Aufruf einer Funktion nicht alle Parameter explizit angeben zu müssen. Die nicht angegebenen Parameter werden mit einer Voreinstellung (default) belegt. Parameter, die bei einem Aufruf einer Funktion nicht angegeben werden müssen, werden auch als „fakultative Parameter“ bezeichnet.

Nuvola-inspired-terminal.svg
1 int summe(int a, int b, int c = 0, int d = 0) {
2     return a + b + c + d;
3 }
4  
5 int main() {
6     int x = summe(2, 3, 4, 5); //x == 14
7     x = summe(2, 3, 4);        //x == 9, es wird d=0 gesetzt
8     x = summe(2, 3);           //x == 5, es wird c=0, d=0 gesetzt   
9 }

Standardargumente werden in der Deklaration einer Funktion angegeben, da der Compiler sie beim Aufruf der Funktion kennen muss. Im obigen Beispiel wurde die Deklaration durch die Definition gemacht, daher sind die Parameter hier in der Definition angegeben. Bei einer getrennten Schreibung von Deklaration und Definition könnte das Beispiel so aussehen:

Nuvola-inspired-terminal.svg
 1 int summe(int a, int b, int c = 0, int d = 0); // Deklaration
 2 
 3 int main() {
 4     int x = summe(2, 3, 4, 5); //x == 14
 5     x = summe(2, 3, 4);        //x == 9, es wird d=0 gesetzt
 6     x = summe(2, 3);           //x == 5, es wird c=0, d=0 gesetzt   
 7 }
 8 
 9 int summe(int a, int b, int c, int d) {        // Definition
10     return a + b + c + d;
11 }

Funktionen überladen[Bearbeiten]

Überladen (overloading) von Funktionen bedeutet, dass verschiedene Funktionen unter dem gleichen Namen angesprochen werden können. Damit der Compiler die Funktionen richtig zuordnen kann, müssen die Funktionen sich in ihrer Funktionssignatur unterscheiden. In C++ besteht die Signatur aus dem Funktionsnamen und ihren Parametern, der Typ des Rückgabewerts gehört nicht dazu. So ist es nicht zulässig, eine Funktion zu überladen, die den gleichen Namen und die gleiche Parameterliste wie eine bereits existierende Funktion besitzt und sich nur im Typ des Rückgabewerts unterscheidet. Das obige Beispiel lässt sich ohne Default-Parameter so formulieren:

Nuvola-inspired-terminal.svg
 1 int summe(int a, int b, int c, int d) {
 2     return a + b + c + d;
 3 }
 4 
 5 int summe(int a, int b, int c) {
 6     return a + b + c;
 7 }
 8 
 9 int summe(int a, int b) {
10     return a + b;
11 }
12 
13 int main() {
14     // ...
15 }

Funktionen mit beliebig vielen Argumenten[Bearbeiten]

Wenn die Zahl der Argumente nicht von vornherein begrenzt ist, wird als Parameterliste die sog. Ellipse ... angegeben. Der Funktion werden die Argumente dann in Form einer Liste übergeben, auf die mit Hilfe der (in der Headerdatei cstdarg definierten) va-Makros zugegriffen werden kann.

Nuvola-inspired-terminal.svg
 1 #include <cstdarg>
 2 #include <iostream>
 3 
 4 int summe(int a, ...) {
 5     int summe = 0;
 6     int i = a;
 7 
 8     va_list Parameter;              // Zeiger auf Argumentliste
 9     va_start(Parameter, a);         // gehe zur ersten Position der Liste
10 
11     while (i != 0){                 // Schleife, solange Zahl nicht 0 (0 ist Abbruchbedingung)
12         summe += i;                 // Zahl zur Summe addieren
13         i = va_arg(Parameter, int); // nächstes Argument an i zuweisen, Typ int
14     }
15 
16     va_end(Parameter);              // Liste löschen
17 
18     return summe;
19 }
20 
21 int main() {
22     std::cout << summe(2, 3, 4, 0) << std::endl; // 9
23     std::cout << summe(2, 3, 0) << std::endl;    // 5
24 
25     std::cout << summe(1,1,0,1,0) << std::endl;  // 2 (da die erste 0 in der while-Schleife für Abbruch sorgt)
26 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 9
2 5
3 2

Obwohl unspezifizierte Argumente manchmal verlockend aussehen, sollten Sie sie nach Möglichkeit vermeiden. Das hat zwei Gründe:

  • Die va-Befehle können nicht erkennen, wann die Argumentliste zu Ende ist. Es muss immer mit einer expliziten Abbruchbedingung gearbeitet werden. In unserem Beispiel muss als letztes Argument eine 0 stehen, ansonsten gibt es, je nach Compiler unterschiedliche, „interessante“ Ergebnisse.
  • Die va-Befehle sind Makros, d.h. eine strenge Typüberprüfung findet nicht statt. Fehler werden - wenn überhaupt - erst zur Laufzeit bemerkt.
Symbol kept vote.svg
Tipp

Mit dem kommenden C++ Standard C++11 wird mit den „variadic templates“ eine Technik eingeführt, welche diese Art von variabler Parameterliste überflüssig macht. Über Templates wie Sie im aktuellen Standard stehen, werden Sie später mehr erfahren. Sobald der neue Standard endgültig verabschiedet ist, wird es auch zu den „variadic templates“ ein Kapitel geben. Die meisten Compiler beherrschen diese Technik bereits in weiten Teilen, sofern man den neuen Standard explizit aktiviert:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 template < typename First >
 4 First summe(First first){
 5 	return first;
 6 }
 7 
 8 template < typename First, typename ... Liste >
 9 First summe(First first, Liste ... rest){
10 	return first + summe(rest ...);
11 }
12 
13 int main() {
14     std::cout << summe(2, 3, 4) << std::endl;
15     std::cout << summe(2, 3) << std::endl;
16     std::cout << summe(1, 1, 0, 1) << std::endl;
17 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 9
2 5
3 3

Diese Implementierung ist typsicher und benötigt keine Tricks um den letzten Parameter zu kennzeichnen. Hierbei entspricht der Rückgabetyp immer dem Typ des ersten Parameters, was nicht sonderlich sinnvoll ist, aber eine Implementierung, die sich auch bezüglich des Rückgabetyps sinnvoll verhält, würde an dieser Stelle endgültig zu weit führen. „Variadic templates“ sind eine extrem nützliche Technik für Fortgeschrittene. Für Sie genügt es zum gegenwärtigen Zeitpunkt zu wissen, dass sie existieren und dass man derartige Funktionen wie jede andere Funktion aufrufen kann.

Inline-Funktionen[Bearbeiten]

Um den Aufruf einer Funktion zu beschleunigen, kann in die Funktionsdeklaration das Schlüsselwort inline eingefügt werden. Dies ist eine Empfehlung (keine Anweisung) an den Compiler, beim Aufruf dieser Funktion keine neue Schicht auf dem Stack anzulegen, sondern den Code direkt auszuführen - den Aufruf sozusagen durch den Funktionsrumpf zu ersetzen.

Da dies – wie eben schon erwähnt – nur eine Empfehlung an den Compiler ist, wird der Compiler eine Funktion nur dann tatsächlich inline einbauen, wenn es sich um eine kurze Funktion handelt. Ein typisches Beispiel:

Nuvola-inspired-terminal.svg
1 inline int max(int a, int b) {
2     return a > b ? a : b;
3 }
Symbol move vote.svg
Thema wird später näher erläutert…

Das Schlüsselwort inline wird bei der Deklaration angegeben. Allerdings muss der Compiler beim Aufruf den Funktionsrumpf kennen, wenn er den Code direkt einfügen soll. Für den Aufruf einer inline-Funktion genügt also wie immer die Deklaration, um dem Compiler jedoch tatsächlich das ersetzen des Funktionsaufrufs zu ermöglichen, muss auch die Definition bekannt sein. Über diese Eigenheit von inline-Funktionen erfahren Sie im Kapitel „Headerdateien“ mehr. Auch die Bedeutung von Deklaration und Definition wird Ihnen nach diesem Kapitel klarer sein.


Lebensdauer und Sichtbarkeit von Objekten[Bearbeiten]

Die Lebensdauer einer Variable beschreibt die Zeit, in der die Variable im Speicher existiert. Die Sichtbarkeit einer Variable ist von ihrer Lebensdauer zu unterscheiden. Sie beschreibt, wie der Name schon vermuten lässt, wann man auf eine Variable über ihren Namen zugreifen kann, beziehungsweise wann dies nicht möglich ist. Wir werden in diesem Kapitel Variablen nach ihrer Lebensdauer sortiert betrachten und dabei auch immer auf ihren Sichtbarkeitsbereich eingehen.

Statische Variablen[Bearbeiten]

Als statische Variablen werden alle Variablen bezeichnet, deren Lebensdauer mit der Laufzeit des Programms übereinstimmt. Sie belegen somit während der gesamten Ausführungszeit Speicherplatz, können andererseits aber auch während der gesamten Laufzeit zugegriffen werden.

Lokale statische Variablen[Bearbeiten]

Variablen, die innerhalb einer Funktion als static deklariert wurden, werden als lokale statische Variablen bezeichnet, da sie bezüglich der Funktion lokal sind. Solche Variablen sind nur innerhalb der jeweiligen Funktion sichtbar. Da sie jedoch permanent existieren, können Sie über eine entsprechende Referenz oder einen Zeiger auch außerhalb der Funktion auf sie zugreifen. Die Initialisierung solcher Variablen erfolgt beim ersten Aufruf der Funktion.

Nicht-lokale statische Variablen[Bearbeiten]

Alle statischen Variablen, die nicht in die Kategorie „lokal“ fallen, werden entsprechend als „nicht-lokal“ bezeichnet. Alle Variablen dieser Art sind überall sichtbar, mit Ausnahme von Variablen, die in anonymen Namensräumen deklariert wurden. Diese sind nur innerhalb der aktuellen Übersetzungseinheit sichtbar. Auch diese können natürlich dennoch mittels einer entsprechenden Referenz oder eines Zeigers auch aus anderen Übersetzungseinheiten zugegriffen werden. Als Übersetzungseinheit bezeichnet man das Kompilat einer cpp-Datei, welches der Compiler erstellt, bevor es vom Linker zum endgültigen Programm gebunden wird. Aus Quelltextsicht entspricht sie somit einer cpp-Datei inklusive aller mit #include eingebundenen Header. Um eine Variable in einer anderen Übersetzungseinheit sichtbar zu machen, muss sie dort deklariert werden. Beachten Sie, dass die Variable dort nicht ein zweites Mal definiert werden darf.

Globale Variablen[Bearbeiten]

Variablen, die direkt im globalen Namensraum deklariert wurden, heißen globale Variablen. Im globalen Namensraum heißt, außerhalb von jeder Funktion, Klasse und jedem Namensraum. Ein geeignetes Indiz zum Überprüfen, ob eine Variable global deklariert ist, ist den Zugriffsoperator (::) ohne Namensraum zu benutzen. Folgendes Beispiel zeigt diesen einfachen Test.

Crystal Clear action button cancel.svg
1 extern int globale; // explizite Deklaration
2 int global;         // Definition
3 
4 int main(){
5     int lokal;
6 
7     ::global; // geht -> globale Variable
8     ::lokal;  // Fehler -> nicht globale Variable
9 }

Zum erfolgreichen Kompilieren muss die Fehlerzeile auskommentiert werden

Auch hierbei gibt es natürlich wieder eine Ausnahme, denn auch Variablen aus einem anonymen Namensraum lassen sich auf diese Weise zugreifen. Da sich die Nicht-lokalen, statischen Variablen aus interner Sicht jedoch ohnehin alle sehr ähnlich verhalten, spielt ihre Unterscheidung in der Praxis ohnehin eine untergeordnete Rolle. Allgemein sollten Sie globale Variablen komplett vermeiden, da sie in größeren Projekten mit mehreren Programmierern sehr schnell zu Namenskonflikten führen.

Während sich eine globale Variable jedoch über eine explizite Deklaration aus einer anderen Übersetzungseinheit heraus sichtbar machen lässt, ist dies für eine Variable in einem anonymen Namensraum nicht möglich.

Globaler Namensraum[Bearbeiten]

Variablen, die innerhalb eines Namensraumes deklariert werden, vermeiden Namenskonflikte und die Zuordnung zu einzelnen Programmteilen ist schneller ersichtlich. Wenn Sie eine globale Variable benötigen, dann verpacken Sie diese in einen geeigneten Namensraum. Auch hier ist natürlich eine explizite Deklaration in einer anderen Übersetzungseinheit möglich, wobei die Deklaration natürlich auch dort im selben Namensraum erfolgen muss.

Anonymer Namensraum[Bearbeiten]

Der anonyme Namensraum wurde nun schon einige Male angesprochen. Variablen, die in diesem Namensraum definiert wurden, können in der aktuellen Übersetzungseinheit wie globale Variablen behandelt werden. Da ein anonymer Namensraum nur in der aktuellen Übersetzungseinheit sichtbar ist, gibt es keine Möglichkeit, seinen Inhalt aus einer anderen Übersetzungseinheit aus sichtbar zu machen. Der anonyme Namensraum einer anderen Übersetzungseinheit ist entsprechend wieder ein anderer als der in der aktuellen Datei.

Statische Klassenvariablen[Bearbeiten]

Statische Klassenvariablen verhalten sich im wesentlichen wie Variablen innerhalb eines benannten Namensraumes. Um sie in einer anderen Übersetzungseinheit zu sehen, ist eine Definition der Klasse nötig, in der sie deklariert ist. Dies erfolgt üblicherweise durch Einbinden der entsprechenden Headerdatei der Klasse.

Probleme mit der Initialisierung[Bearbeiten]

Das große Problem, das sich in Zusammenhang mit statischen, nicht-lokalen Variablen ergibt, ist ihre Initialisierungsreihenfolge bezüglich unterschiedlicher Übersetzungseinheiten. Diese ist nicht definiert, da es für den Compiler beziehungsweise Linker im allgemeinen unmöglich ist, herauszufinden, welche Reihenfolge die richtige ist. Betrachten Sie zur Veranschaulichung das folgende Beispiel mit zwei Übersetzungseinheiten.

Crystal Clear action button cancel.svg
 1 //*******************************************************//
 2 //******************** Datei "B.hpp" ********************//
 3 // Definition von B
 4 struct B{
 5     B(int value):value_(value){}
 6     int value_;
 7 };
 8 
 9 //*******************************************************//
10 //****************** Datei "file1.cpp" ******************//
11 #include "B.hpp"
12 
13 B b(5); // Definition und Initialisierung der globalen Variable b
14 
15 //*******************************************************//
16 //****************** Datei "file2.cpp" ******************//
17 #include <iostream>
18 #include "B.hpp"
19 
20 extern B b; // Deklaration der Variable b
21 
22 struct A{ // Definition von A
23     A(B const& value):b_(value){}
24     B b_;
25 };
26 
27 A a(b); // Globale Variable a, die mit b initialisiert wird
28 
29 int main(){
30     std::cout << a.b_.value_ << std::endl;
31 }

Ausgabe ist vom Compiler abhängig

Falls die Variable B zuerst initialisiert wird, liefert das Programm wie gewünscht die Ausgabe 5. Sie können ja mal versuchen Ihrem Compiler die beiden cpp-Dateien auf der Kommandozeile in unterschiedlicher Reihenfolge zu übergeben. Wahrscheinlich wird das Programm je nachdem welche Datei zuerst gebunden wird, ein anderes Ergebnis liefern. Sie können sich jedoch keinesfalls darauf verlassen, dass Sie Ihre Wunschinitialisierungsreihenfolge immer mit dieser Try-and-Error-Methode herstellen können. Es ist nicht immer möglich, weshalb es vom C++-Standard auch nicht definiert wurde.

Glücklicherweise gibt es einen einfachen Ausweg aus diesem Dilemma. Eine kleine Designänderung wird Ihr Problem sofort beheben. Wie Ihnen inzwischen bekannt ist, werden lokale, statische Variablen erst beim ersten Funktionsaufruf initialisiert. Wenn Sie also derartige Initialisierungsprobleme befürchten müssen, dann können Sie statt einer nicht-lokalen, statischen Variable eine Funktion verwenden, die eine Referenz auf eine lokale statische Variable zurückgibt. Die Initialisierungsreihenfolge ergibt sich dann automatisch und ohne Zutun von Compiler und Linker zur Laufzeit des Programms.

Nuvola-inspired-terminal.svg
 1 //*******************************************************//
 2 //******************** Datei "B.hpp" ********************//
 3 // Definition von B
 4 struct B{
 5     B(int value):value_(value){}
 6     int value_;
 7 };
 8 
 9 //*******************************************************//
10 //****************** Datei "file1.cpp" ******************//
11 #include "B.hpp"
12 
13 // Definition und Initialisierung einer statischen
14 // lokalen Variable die durch einen Funktionsaufruf
15 // zugegriffen werden kann
16 B& b(){
17     static B _b(5); // Initialisierung beim ersten Aufruf
18     return _b;
19 }
20 
21 //*******************************************************//
22 //****************** Datei "file2.cpp" ******************//
23 #include <iostream>
24 #include "B.hpp"
25 
26 B& b(); // Deklaration der Funktion b
27 
28 struct A{ // Definition von A
29     A(B const& value):b_(value){}
30     B b_;
31 };
32 
33 // Kapselungsfunktion
34 A& a(){
35     static A _a(b()); // Initialisierung beim ersten Aufruf
36     return _a;
37 }
38 
39 int main(){
40     std::cout << a().b_.value_ << std::endl;
41 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 5

Diese Variante erfordert zwar einen minimal höheren Schreibaufwand, im Gegenzug erhalten Sie aber ein klar definiertes und sinnvolles Verhalten und als kleinen Bonus bekommen Sie noch einen möglicherweise hilfreichen Effekt dazu. Da die Initialisierung der Variablen nun erst dann stattfindet, wenn Sie diese tatsächlich verwenden, startet ihr Programm etwas schneller und Variablen, die während der Laufzeit nicht genutzt werden, verschwenden keine Zeit mehr mit einer unnötigen Initialisierung. Natürlich belegen sie trotzdem immer noch Speicherplatz, also gehen Sie trotz der gewonnen Laufzeitvorteile mit bedacht vor, wenn Sie statische Variablen verwenden.

Alter Text[Bearbeiten]

Der Rest des Kapitels muss noch einmal überarbeitet werden, die aktuelle Version bietet jedoch schon einen grundlegenden Überblick. Ich möchte die Überarbeitung selbst vornehmen, da ich eine etwas andere Struktur vorgesehen habe. Der aktuelle Text wird natürlich in meine Version mit einfließen. ;) --Prog 16:19, 6. Dez. 2010 (CET)

Lokale Variablen[Bearbeiten]

Im Gegensatz zu globalen, werden lokale Variablen in einem bestimmten Anweisungsblock (z.B. Schleifen, if-Abfragen oder Funktionen) deklariert. Ihre Existenz endet, wenn dieser Block wieder verlassen wird.

Nuvola-inspired-terminal.svg
1 void foo(int a) {
2     int lok1 = 0; // lok1 ist eine Variable im Anweisungsblock von void foo(int a)
3 
4     if (a < 0) {
5         int lok2 = 1; // lok2 ist eine Variable im if-Block
6     } // hier wird lok2 aus dem Speicher gelöscht...
7 } // ...und hier lok1
Symbol opinion vote.svg
Hinweis

Bei Schleifen ist zu beachten, dass Variablen, deren Deklaration im Schleifenrumpf steht, bei jedem Durchlauf neu initialisiert werden.

Nuvola-inspired-terminal.svg
1 while (1) {
2     int var = 0;
3     std::cout << var << std::endl; // die Ausgabe ist hier immer 0
4     ++var;
5 }

Statische Variablen[Bearbeiten]

Statische Variablen (auch statische Klassenmember) werden wie globale zu Beginn des Programms im Speicher angelegt und bei seinem Ende wieder daraus entfernt. Der Unterschied zu einer globalen Variable wird weiter unten auf dieser Seite im Teil über Sichtbarkeit geklärt.

Dynamisch erzeugte Variablen[Bearbeiten]

Eine Variable, die mittels dem new Operator angefordert wird, ist dynamisch. Sie existiert so lange, bis sie durch einen Aufruf von delete wieder gelöscht wird.

Symbol opinion vote.svg
Hinweis

Der Aufruf von delete ist die einzige Möglichkeit, den von einer dynamisch erzeugten Variable belegten Speicher wieder frei zu geben. Geschieht dies nicht, so kann es leicht zu einem Speicherleck kommen.

Lesen Sie bitte auch das Kapitel über den new und delete um Informationen über deren Verwendung zu erhalten.

Objekte und Membervariablen[Bearbeiten]

Objekte werden wie normale Variablen gehandhabt, d. h. sie können global, lokal, statisch oder dynamisch erzeugt sein. Ihre Member haben die gleiche Lebensdauer wie sie selbst. Eine Ausnahme bilden statische Klassenvariablen, die von Anfang bis Ende des Programmablaufes im Speicher vorhanden sind.

Sichtbarkeit[Bearbeiten]

Allgemein[Bearbeiten]

Um überhaupt die Chance zu haben mit einer Variablen zu arbeiten, muss diese im Quelltext bereits deklariert worden sein. Folgendes Codestück ist also falsch und führt zu einem Fehler.

Crystal Clear action button cancel.svg
1 // ...
2 var = 34; // Fehler z.B. "symbol var not found"
3 int var;
4 // ...
Symbol move vote.svg
Thema wird später näher erläutert…

Das Prinzip der Datenkapselung in der objektorientierten Programmierung finden Sie im Abschnitt über Klassen.

Gültigkeitsbereiche und deren Schachtelung[Bearbeiten]

Jede Variable gehört zu einem bestimmten Gültigkeitsbereich (engl. scope). Dieser legt fest, wann eine Variable von uns „gesehen“ und damit benutzt werden kann. Vereinfacht gesagt bildet jedes Paar aus geschweiften Klammern ({}) einen eigenen Definitionsbereich. Dazu gehören beispielsweise if, else, Schleifen und Funktionen. Diese unterschiedlichen Bereiche sind nun ineinander geschachtelt ähnlich wie die berühmten Matrjoschka-Puppen mit dem Unterschied, dass die Definitionsbereiche nicht „kleiner“ werden und dass es mehrere „nebeneinander“ geben kann.

Nuvola-inspired-terminal.svg
 1 // das hier gehört zum globalen Bereich
 2 
 3 int func() { // hier beginnt der Bereich der Funktion func...
 4     return 0;
 5     // ... und ist hier auch schon wieder beendet
 6 }
 7 
 8 int bar(int val) {  // val gehört zum Definitionsbereich "bar"
 9     if (val == 7) { // diese if-Anweisung hat auch ihren eigenen Gültigkeitsbereich...
10        int ich_gehoer_zum_if;
11     } // ... der hier zu Ende ist
12 } // bar ende

Welche Variablen sind sichtbar?[Bearbeiten]

Jetzt ist es leicht zu bestimmen mit welchen Variablen wir an einer bestimmten Stelle im Programmcode arbeiten können: Es sind diejenigen, die entweder dem derzeitigen oder einem Gültigkeitsbereich auf einer höheren Ebene angehören. Wenn wir uns erneut das Beispiel der Puppen vor Augen halten, so wird klar was hiermit gemeint ist.

Beispiel:

Nuvola-inspired-terminal.svg
1 int out;
2 {
3     int inner_1;
4 }
5 
6 {   
7     int inner_2;
8     // an dieser Stelle könnten wir sowohl auf out als auch auf inner_2 zugreifen, nicht jedoch auf inner_1;
9 }

Zusätzlich gilt noch, dass von zwei Variablen gleichen Namens nur auf die weiter innen liegende zugegriffen werden kann. Außerdem wird die gleichnamige innere Variable im selben Speicherbereich agieren.

Nuvola-inspired-terminal.svg
1 int var=9;
2 
3 {   
4     int var=3;
5     std::cout << var << std::endl; // die Ausgabe ist 3
6 }


Rekursion[Bearbeiten]

Jede Funktion kann sowohl andere Funktionen als auch sich selbst aufrufen. Ein solcher Selbstaufruf wird auch rekursiver Aufruf genannt. Das dahinter stehende Konzept bezeichnet man entsprechend als Rekursion.

Eine Ausnahme von dieser Regel bildet wiedereinmal die Funktion main(). Sie darf ausschließlich vom Betriebssystem aufgerufen werden, also weder von einer anderen Funktion, noch aus sich selbst heraus.

Eine rekursive Problemlösung ist etwas langsamer und speicheraufwendiger als eine iterative Variante (also mit Schleifen). Dafür ist der Code allerdings auch kompakter und ein „intelligenter“ Compiler ist meist in der Lage, eine Rekursion in eine Iteration umzuwandeln um somit die Nachteile aufzuheben. Sie sollten also keine Scheu haben ein Problem mit Rekursion zu lösen, insbesondere wenn die Lösung leichter zu verstehen ist als eine iterative Variante. Sollten dadurch im Laufe der Entwicklung eines Programms Geschwindigkeits- oder Speichernachteile auftreten, so können Sie die Funktion immer noch durch eine iterativ arbeitende ersetzen.

Beispiele[Bearbeiten]

Fakultät[Bearbeiten]

Als erstes einfaches Beispiel einer rekursiven Problemlösung nehmen wir die Berechnung der Fakultät. Da die Fakultät für negative und nicht ganze Zahlen nicht definiert ist, benutzen wir als Datentyp unsigned int:

Nuvola-inspired-terminal.svg
 1 #include <iostream>       // Für std::cin und std::cout
 2 
 3 unsigned int fakultaet(unsigned int zahl) {
 4     if (zahl <= 1) {
 5         return 1; // Die Fakultät von 0 und 1 ist als 1 definiert.
 6     } else {
 7         return zahl * fakultaet(zahl - 1);
 8     }
 9 }
10 
11 int main() {
12     unsigned int zahl;
13 
14     std::cout << "Bitte Zahl eingeben: ";
15     std::cin >> zahl;                           // Zahl einlesen
16     std::cout << "Die Fakultät von " << zahl << // Antwort ausgeben
17         " ist " << fakultaet(zahl) << "." << std::endl;
18 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Bitte Zahl eingeben: <eingabe>4</eingabe>
2 Die Fakultät von 4 ist 24.

Genau wie bei einer Schleife, ist auch bei einer Rekursion eine Abbruchbedingung definiert (also erforderlich) und genau wie bei einer Schleife würde ohne Abbruchbedingung eine Endlosrekursion auftreten, analog zur Endlosschleife. So eine Endlosschleife bezeichnet man auch als infiniten Regress. Wenn der Wert der Variablen zahl kleiner oder gleich eins ist, so wird eins zurückgegeben, andernfalls wird weiter rekursiv aufgerufen. Eine iterative Variante für das gleiche Problem könnte folgendermaßen aussehen:

Nuvola-inspired-terminal.svg
1 unsigned int fakultaet(unsigned int zahl) {
2     unsigned int wert = 1;
3 
4     for (unsigned int i = 2; i <= zahl; ++i) {
5         wert *= i;
6     }
7 
8     return wert;
9 }

Fibonacci-Zahlen[Bearbeiten]

Als zweites Beispiel wollen wir Fibonacci-Zahlen ausrechnen.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 unsigned int fibonacci(unsigned int zahl) {
 4     if (zahl == 0) { // Die Fibonacci-Zahl von null ist null
 5         return 0;
 6     } // else
 7     if (zahl == 1) { // Die Fibonacci-Zahl von eins ist eins
 8         return 1;
 9     } // else
10 
11     // Ansonsten wird die Summe der zwei vorherigen Fibonacci-Zahlen zurückgegeben.
12     return fibonacci(zahl - 1) + fibonacci(zahl - 2);
13 }
14 
15 int main() {
16     unsigned int zahl;
17 
18     std::cout << "Bitte Zahl eingeben: ";
19     std::cin >> zahl;                                 // Zahl einlesen
20     std::cout << "Die Fibonacci-Zahl von " << zahl << // Antwort ausgeben
21         " ist " << fibonacci(zahl) << "." << std::endl;
22 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Bitte Zahl eingeben: <eingabe>12</eingabe>
2 Die Fibonacci-Zahl von 12 ist 144.

Die iterative Entsprechung sieht folgendermaßen aus:

Nuvola-inspired-terminal.svg
 1 unsigned int fibonacci(unsigned int zahl) {
 2     if (zahl == 0) { // Die Fibonacci-Zahl von null ist null
 3         return 0;
 4     } // else
 5     if (zahl == 1) { // Die Fibonacci-Zahl von eins ist eins
 6         return 1;
 7     } // else
 8 
 9     unsigned int ret;
10     unsigned int h1 = 0;
11     unsigned int h2 = 1;
12 
13     for (unsigned int i = 1; i < zahl; ++i) {
14         // (Zwischen-)Ergebnis ist die Summe der zwei vorhergehenden Fibonacci-Zahlen.
15         ret = h1 + h2; 
16         // "vorherige zwei F.-Zahlen" um 1 "Stelle" der Reihe "weiter ruecken":
17         h1 = h2;
18         h2 = ret;
19     }
20 
21     return ret;
22 }

Bei vielen komplexen Problemen eignet sich Rekursion oft besser zur Beschreibung, als eine iterative Entsprechung. Aus diesem Grund trifft man das Konzept der Rekursion in der Programmierung recht häufig an. Bei der Fibonacci-Funktion ist allerdings die iterative Lösung wesentlich effizienter, da ansonsten bei jedem Aufruf dieselbe Methode wieder zweimal neu aufgerufen wird. So ergeben sich bei fibonacci(40) schon 240-1 Aufrufe.

Merge sort[Bearbeiten]

Merge sort ist ein Beispiel für eine Funktion, bei der Rekursion sinnvoll eingesetzt wird. Die Idee ist: Um ein Array zu sortieren, sortiere erst die erste Hälfte, dann die zweite Hälfte, und dann füge die beiden Teile zusammen (merge). Der folgende Code implementiert Merge sort für int-Arrays. Sie erwartet ein Array, den ersten Index des zu sortierenden Bereichs, und den Index auf das erste Element nach dem zu sortierenden Bereich. Da die genaue Implementierung des Merge-Schritts hier nicht von Interesse ist, wird einfach angenommen, dass dafür bereits eine Funktion merge existiert.

Nuvola-inspired-terminal.svg
1 void mergesort(int array[], int begin, int end)
2 {
3   int mid = begin + (end-begin)/2;    // Mitte des Feldes bestimmen
4 
5   mergesort(array, begin, mid);       // Linke  Hälfte
6   mergesort(array, mid, end);         // Rechte Hälfte
7 
8   merge(array, begin, mid, end);
9 }
Symbol neutral vote.svg Aufgabe 1: Welches wichtige Element einer Rekursion fehlt im Mergesort-Beispiel? Wie würden Sie es ergänzen?

Lösung: Es fehlt eine Abbruchbedingung. Eine mögliche Abbruchbedingung wäre: Weil eine Liste mit nur einem oder gar keinem Element darin nicht sortiert werden braucht, kann die Funktion 'nichts tun', wenn der Unterschied von begin und end kleinergleich 1 ist.

Symbol kept vote.svg
Tipp

Bei komplexeren Problemen, die rekursiv gelöst werden sollen, ist es wichtig darauf zu achten, dass das „jeweils zu lösende Problem“ bei jedem tieferen Rekursionsschritt kleiner wird, einfacher wird, näher an die Abbruchbedingung herankommt. Damit ist recht gut sichergestellt, dass die Rekursion nicht (in ungünstigen Fällen) „unendlich tief“ verzweigt.

Jeder (rekursive) Aufruf der Funktion sollte das ihr übergebene (Teil-)Problem zumindest ein wenig vereinfachen, aufteilen oder anderweitig an eine Lösung heranbringen, bevor sich die Funktion für (Unter-Teil-)Probleme rekursiv erneut aufruft - und das Vereinfachen sollte in jedem möglichen Fall (if-Zweig) geschehen.


Zeiger[Bearbeiten]

Grundlagen zu Zeigern[Bearbeiten]

Zeiger (engl. pointers) sind Variablen, die als Wert die Speicheradresse einer anderen Variable (oder eines anderen Speicherobjekts) enthalten.

Jede Variable wird in C++ an einer bestimmten Position im Hauptspeicher abgelegt. Diese Position nennt man Speicheradresse (engl. memory address). C++ bietet die Möglichkeit, die Adresse jeder Variable zu ermitteln. Solange eine Variable gültig ist, bleibt sie an ein und derselben Stelle im Speicher.

Am einfachsten vergegenwärtigt man sich dieses Konzept anhand der globalen Variablen. Diese werden außerhalb aller Funktionen und Klassen deklariert und sind überall gültig. Auf sie kann man von jeder Klasse und jeder Funktion aus zugreifen. Über globale Variablen ist bereits zur Kompilierzeit bekannt, wo sie sich innerhalb des Speichers befinden (also kennt das Programm ihre Adresse).

Eine Adresse ist nichts anderes als eine Ganzzahl, die den Ort, die Nummer des ersten Bytes eines Objekts, angibt. Um eine solche Adressen-Ganzzahl zu speichern, ist ein Zeiger im Wesentlichen eine normale (Ganzzahl-)Variable. Zeiger(variablen) werden deklariert (und definiert), besitzen einen Gültigkeitsbereich, selbst wiederum eine Adresse und einen Wert. Dieser Wert, der Inhalt der Zeigervariable, ist zwar zunächst einmal eine Zahl, aber auch die Adresse einer anderen Variable oder eines Speicherbereichs. Bei der Deklaration einer Zeigervariable wird auch der Typ der Variable angegeben, auf die der Zeiger verweisen soll - also der Typ, den das Objekt besitzt, auf das der Zeiger zeigt.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main() {
 4     int   Wert;      // eine int-Variable
 5     int *pWert;      // eine Zeigervariable, zeigt auf einen int
 6     int *pZahl;      // ein weiterer "Zeiger auf int"
 7 
 8     Wert = 10;       // Zuweisung eines Wertes an eine int-Variable
 9 
10     pWert = &Wert;   // Adressoperator '&' liefert die Adresse einer Variable
11     pZahl = pWert;   // pZahl und pWert zeigen jetzt auf dieselbe Variable

Der Adressoperator & kann auf jede Variable angewandt werden und liefert deren Adresse, die man einer (dem Variablentyp entsprechenden) Zeigervariablen zuweisen kann. Wie im Beispiel gezeigt, können Zeiger gleichen Typs einander zugewiesen werden. Zeiger verschiedenen Typs bedürfen einer Typumwandlung. Die Zeigervariablen pWert und pZahl sind an verschiedenen Stellen im Speicher abgelegt, nur die Inhalte sind gleich.

Wollen Sie auf den Wert zugreifen, der sich hinter der im Zeiger gespeicherten Adresse verbirgt, so verwenden Sie den Dereferenzierungsoperator *.

Nuvola-inspired-terminal.svg


1 {
2     *pWert += 5;
3     *pZahl += 8;
4 
5     std::cout << "Wert = " << Wert << std::endl;
6 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Wert = 23

Man nennt das den Zeiger dereferenzieren. Im Beispiel erhalten Sie die Ausgabe Wert = 23, denn pWert und pZahl verweisen ja beide auf die Variable Wert.

Um es noch einmal hervorzuheben: Zeiger auf Integer (int) sind selbst keine Integer. Den Versuch, einer Zeigervariablen eine Zahl zuzuweisen, beantwortet der Compiler mit einer Fehlermeldung oder mindestens einer Warnung. Hier gibt es nur eine Ausnahme: die Zahl 0 darf jedem beliebigen Zeiger zugewiesen werden. Ein solcher Nullzeiger zeigt nirgendwohin. Der Versuch, ihn zu dereferenzieren, führt zu einem Laufzeitfehler.

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

Der Sinn von Zeigern erschließt sich vor allem Anfängern nicht unmittelbar. Das ändert sich allerdings schnell, sobald der dynamische Speicher besprochen wird.

Zeiger und const[Bearbeiten]

Das Schlüsselwort const kann auf zweierlei Arten in Verbindung mit Zeigern genutzt werden:

  • Um den Wert, auf den der Zeiger zeigt, konstant zu machen,
  • Um den Zeiger selbst konstant zu machen.

Im ersteren Fall kann der Zeiger im Laufe seines Lebens auf verschiedene Objekte zeigen, diese Werte können dann allerdings (über diesen Zeiger) nicht geändert werden. Im zweiten Fall kann der Zeiger nicht auf eine andere Adresse "umgebogen" werden. Der Wert an jener Stelle kann allerdings verändert werden. Natürlich sind auch beide Varianten in Kombination möglich.

Crystal Clear action button cancel.svg
 1 int               Wert1;           // eine int-Variable
 2 int               Wert2;           // noch eine int-Variable
 3 int const *       p1Wert = &Wert1; // Zeiger auf konstanten int
 4 int * const       p2Wert = &Wert1; // konstanter Zeiger auf int
 5 int const * const p3Wert = &Wert1; // konstanter Zeiger auf konstanten int
 6 
 7 p1Wert  = &Wert2; // geht
 8 *p1Wert = Wert2;  // geht nicht, int konstant
 9 
10 p2Wert  = &Wert2; // geht nicht, Zeiger konstant
11 *p2Wert = Wert2;  // geht
12 
13 p3Wert  = &Wert2; // geht nicht, Zeiger konstant
14 *p3Wert = Wert2;  // geht nicht, int konstant

Wie Sie sich sicher noch erinnern, gehört const immer zu dem was links von ihm steht. Es sei denn links steht nichts mehr, dann gehört es zu dem was rechts davon steht.

Zeiger und Funktionen[Bearbeiten]

Wenn Sie einen Zeiger als Parameter an eine Funktion übergeben, können Sie den Wert an der übergebenen Adresse ändern. Eine Funktion, welche die Werte zweier Variablen vertauscht, könnte folgendermaßen implementiert werden:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 void swap(int *wert1, int *wert2) {
 4     int tmp;
 5     tmp    = *wert1;
 6     *wert1 = *wert2;
 7     *wert2 = tmp;
 8 }
 9 
10 int main() {
11     int a = 7, b = 9;
12 
13     std::cout << "a: " << a << ", b: " << b << std::endl;
14     swap(&a, &b);
15     std::cout << "a: " << a << ", b: " << b << std::endl;
16 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 a: 7, b: 9
2 a: 9, b: 7

Diese Funktion hat natürlich einige Schwachstellen. Beispielsweise stürzt sie ab, wenn ihr ein Nullzeiger übergeben wird. Aber sie zeigt, dass es mit Zeigern möglich ist, den Wert einer Variable außerhalb der Funktion zu verändern. In Kürze werden Sie sehen, dass sich dieses Beispiel besser mit Referenzen lösen lässt.

Funktionen, die einen Zeiger auf einen konstanten Datentyp erwarten, können auch mit einem Zeiger auf einen nicht-konstanten Datentyp aufgerufen werden. Das folgende Minimalbeispiel soll dies zeigen:

Nuvola-inspired-terminal.svg
1 // Funktion, die einen Zeiger auf einen konstanten int erwartet
2 void function(int const* parameter){}
3 
4 int main() {
5     int* zeiger;      // Zeiger auf nicht-konstanten int
6     function(zeiger); // Funktioniert
7 }

Probleme mit Zeigern auf Zeiger auf konstante Daten[Bearbeiten]

Ein Problem, über das die meisten Programmierer irgendwann stolpern, ist die Übergabe eines Zeigers auf einen Zeiger auf nicht-konstante Daten an eine Funktion, die einen Zeiger auf einen Zeiger auf konstante Daten erwartet. Da sich das const hier nicht direkt auf die Daten des Zeigers bezieht, sondern erst auf die Daten des Zeigers, auf den der Zeiger zeigt, erlaubt der Compiler die Übergabe nicht. Die Lösung des Problems ist relativ einfach: teilen Sie dem Compiler mittels const_cast explizit mit, dass Sie die Umwandlung vornehmen möchten.

Crystal Clear action button cancel.svg
 1 // Funktion, die einen Zeiger auf einen Zeiger einen konstanten int erwartet
 2 void function(int const** parameter){}
 3 
 4 int main() {
 5     int** zeiger;     // Zeiger auf Zeiger auf nicht-konstanten int
 6     function(zeiger); // Fehler: Typen sind inkompatibel
 7 
 8     // Lösung: explizites hinzucasten der Konstantheit
 9     function(const_cast< int const** >(zeiger));
10 }

Wenn Sie das Beispiel ausprobieren möchten, kommentieren Sie die fehlerhafte Zeile aus

In den meisten Fällen werden Sie einen Parametertyp haben, der etwa die Form Typ const*const* hat und Daten übergeben will, deren Typ Typ** lautet. Die Umwandlung der Konstantheit der Daten unmittelbar auf die der Zeiger zeigt, dass der Compiler dies automatisch vornehmen kann. Alle anderen Umwandlungen müssen Sie explizit mittels const_cast erledigen. Es ist somit egal, ob Sie const_cast< int const*const* > oder nur const_cast< int const** > für die explizite Umwandlung angeben.

Zeigerarithmetik[Bearbeiten]

Zeiger sind keine Zahlen. Deshalb sind einige arithmetischen Operationen auf Zeiger nicht anwendbar, und für die übrigen gelten andere Rechenregeln als in der Zahlenarithmetik. C++ kennt die Größe des Speicherbereichs, auf den ein Zeiger verweist. Inkrementieren (oder Dekrementieren) verändert die referenzierte Adresse unter Berücksichtigung dieser Speichergröße. Das folgende Beispiel soll den Unterschied zwischen Zahlen- und Zeigerarithmetik verdeutlichen:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main() {
 4     std::cout << "Zahlenarithmetik" << std::endl;
 5 
 6     int a = 1;   // a wird 1
 7     std::cout << "a: " << a << std::endl;
 8 
 9     a++;         // a wird 2
10     std::cout << "a: " << a << std::endl;
11 
12     std::cout << "Zeigerarithmetik" << std::endl;
13 
14     int *p = &a; // Adresse von a an p zuweisen
15 
16     std::cout << "p verweist auf: " << p << std::endl;
17     std::cout << " Größe von int: " << sizeof(int) << std::endl;
18 
19     p++;
20     std::cout << "p verweist auf: " << p << std::endl;
21 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Zahlenarithmetik
2 a: 1
3 a: 2
4 Zeigerarithmetik
5 p verweist auf: 0x7fff3aa60090
6  Größe von int: 4
7 p verweist auf: 0x7fff3aa60094

Die Ausgabe sieht bei Ihnen vermutlich etwas anders aus.

Wie Sie sehen, erhöht sich der Wert des Zeigers nicht um eins, sondern um vier, was genau der Größe des Typs entspricht, auf den er zeigt: int. Auf einer Platform, auf der int eine andere Größe hat, würde natürlich entsprechend dieser Größe gezählt werden. Im nächsten Beispiel sehen Sie, wie ein Zeiger auf eine weitere Zeigervariable verweist, welche ihrerseits auf einen int-Wert zeigt.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main() {
 4     int   a  = 1;
 5     int  *p  = &a; // Adresse von a an p zuweisen
 6     int **pp = &p; // Adresse von p an pp zuweisen
 7     std::cout << "pp verweist auf: " << pp << std::endl;
 8     std::cout << " Größe von int*: " << sizeof(int*) << std::endl;
 9     ++pp;
10     std::cout << "pp verweist auf: " << pp << std::endl;
11 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 pp verweist auf: 0x7fff940cb6f0
2  Größe von int*: 8
3 pp verweist auf: 0x7fff940cb6f8

Die Ausgabe sieht bei Ihnen vermutlich etwas anders aus.

Wie Sie sehen hat ein Zeiger auf int im Beispiel eine Größe von 8 Byte. Die Größe von Datentypen ist allerdings architektur-, compiler- und systembedingt. pp ist vom Typ „Zeiger auf Zeiger auf int“, was sich dann in C++ als int** schreibt. Um also auf die Variable "hinter" diesen beiden Zeigern zuzugreifen, muss man **pp schreiben.

Es spielt keine Rolle, ob man in Deklarationen int* p; oder int *p; schreibt. Einige Programmierer schreiben den Stern direkt hinter den Datentyp (int* p), andere schreiben ihn direkt vor Variablennamen (int *p), und wieder andere lassen zu beidem ein Leerzeichen (int * p). In diesem Buch wird die Konvention verfolgt, den Stern direkt vor Variablennamen zu schreiben, wenn einer vorhanden ist (int *p), andernfalls wird er direkt nach dem Datentyp geschrieben (int*).

Negativbeispiele[Bearbeiten]

Zur Verdeutlichung zwei Beispiele, die nicht funktionieren, weil sie vom Compiler nicht akzeptiert werden:

Crystal Clear action button cancel.svg
1 int *pWert;
2 int Wert;
3 pWert = Wert;     // dem Zeiger kann kein int zugewiesen werden
4 Wert  = pWert;    // umgekehrt natürlich auch nicht

Zeigervariablen erlauben als Wert nur Adressen auf Variablen. Daher kann einer Zeigervariable wie in diesem Beispiel kein Integer-Wert zugewiesen werden.

Im Folgenden wollen wir den Wert, auf den pWert zeigt, inkrementieren. Einige der Beispiele bearbeiten die Adresse, die pWert enthält. Erst das letzte Beispiel verändert tatsächlich den Wert, auf den pWert zeigt. Beachten Sie, dass jede Codezeile ein Einzelbeispiel ist.

Nuvola-inspired-terminal.svg
 1 int Wert = 0;
 2 int *pWert = &Wert; // pWert zeigt auf Wert
 3 
 4 pWert += 5;         // ohne Dereferenzierung (*pWert) verändert man die Adresse, auf die  
 5                     // der Zeiger verweist, und nicht deren Inhalt
 6 std::cout << pWert; // es wird nicht die Zahl ausgegeben, auf die pWert 
 7                     // zeigt, sondern deren (veränderte) Adresse
 8 std::cout << "Wert enthält: " << pWert;  // gleiche Ausgabe
 9 
10 pWert++;            // Diese Operation verändert wiederum die Adresse, da nicht dereferenziert wird.
11 *pWert++;           // Auf diese Idee kommt man als Nächstes. Doch auch das hat nicht den
12                     // gewünschten Effekt. Da der (Post-)Inkrement-Operator vor dem Dereferenzierungs-
13                     // operator ausgewertet wird, verändert sich wieder die Adresse.
14 (*pWert)++;         // Da der Ausdruck in der Klammer zuerst ausgewertet wird, erreichen wir
15                     // diesmal den gewünschten Effekt: Eine Änderung des Wertes.

void-Zeiger (anonyme Zeiger)[Bearbeiten]

Eine besondere Rolle spielen die „Zeiger auf void“, die so genannten generischen Zeiger. Einer Zeigervariable vom Typ void* kann jeder beliebige Zeiger zugewiesen werden. void-Zeiger werden in der Sprache C beispielsweise bei der dynamischen Speicherverwaltung verwendet. In C++ kommt man weitgehend ohne sie aus. Vermeiden Sie Zeiger auf void, wenn Sie eine andere Möglichkeit haben. Ein Objekt kann nicht vom Typ void sein. Entsprechend ist es auch nicht möglich, einen void-Zeiger zu dereferenzieren. Das folgende kleine Codebeispiel ist praxisfern. Aber wie schon erwähnt gibt es in C++ nur noch sehr selten eine Notwendigkeit für void-Zeiger, und keine dieser seltenen Situationen könnte an dieser Stelle im Buch bereits erklärt werden. Die meisten C++-Programmierer werden in Ihrem gesamten Leben nicht in die Verlegenheit kommen, einen void-Zeiger wirklich verwenden zu müssen.

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 
3 int main() {
4     int  value   = 1;
5     int* pointer = &value; // zeigt auf value
6 
7     void* void_pointer;
8     void_pointer = pointer; // void_pointer zeigt wie pointer auf value

Sie können jetzt nicht ohne Weiteres auf *void_pointer zugreifen, um an den Wert von value zu kommen. Da es sich um einen Zeiger vom Typ void handelt, muss man diesen erst umwandeln (engl. to cast). In diesem Fall nach int*.

Nuvola-inspired-terminal.svg


1 std::cout << *reinterpret_cast< int* >(void_pointer) << std::endl;
2 }

Der Ablauf dieser letzten Zeile noch einmal im Detail:

  1. Zeiger void_pointer ist vom Typ void* und zeigt auf value
  2. reinterpret_cast< int* >, Zeiger ist vom Typ int*
  3. Zeiger dereferenzieren (*), um Wert (vom Typ int) zu erhalten
  4. Wert ausgeben

Funktionszeiger[Bearbeiten]

Zeiger können nicht nur auf Variablen, sondern auch auf Funktionen verweisen. Die Deklaration eines solchen Funktionszeigers sieht im ersten Augenblick etwas schwierig aus, aber sie ist dennoch leicht zu merken. Sie schreiben einfach den Prototypen der Funktion, auf die ihr Zeiger verweisen soll und geben statt des Funktionsnamens den Variablennamen an. Selbigen stellen Sie einen Stern voran, um klar zu machen, dass es sich um einen Zeiger handelt, und um dem Compiler zu vermitteln, dass der Stern nicht zum Rückgabetyp gehört, fassen Sie ihn und den Variablennamen in Klammern ein. Das folgende kleine Beispiel zeigt die Verwendung:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int multiplication(int a, int b){
 4     return a*b;
 5 }
 6 
 7 int division(int a, int b){
 8     return a/b;
 9 }
10 
11 int main(){
12     int (*rechenoperation)(int, int) = 0; // Anlegen eines Funktionszeigers, Initialisierung mit 0
13 
14     rechenoperation = &multiplication;
15     std::cout << (*rechenoperation)(40, 8) << std::endl;
16     rechenoperation = &division;
17     std::cout << (*rechenoperation)(40, 8) << std::endl;
18 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 320
2 5

Man liest: rechenoperation ist ein Zeiger auf eine Funktion, die zwei ints übernimmt und einen int zurückgibt. Im Kapitel über Felder wird eine allgemein gültige Regel für das Lesen komplexer Datentypen vorgestellt. Wie Sie sehen wird der Zeigervariable nacheinander die Adresse zweier Funktionen zugewiesen, die dem Typ der Zeigervariable entsprechen. Eine für den Zeiger gültige Funktion muss also zwei ints übernehmen und einen int zurückgeben.

Um die Adresse der Funktion zu erhalten, müssen Sie den Adressoperator auf den Funktionsnamen anwenden. Beachten Sie, dass die Klammern, die Sie zum Aufruf einer Funktion immer setzen müssen, hier keinesfalls gesetzt werden dürfen. &multiplication() würde Ihnen die Adresse des von multiplication() zurückgelieferten Objekts beschaffen. Es sei auch darauf hingewiesen, dass der Adressoperator nicht zwingend zum Ermitteln der Funktionsadresse notwendig ist. Sie sollten Ihn aus Gründen der Übersicht allerdings immer mitschreiben.

Gleiches gilt bei der Dereferenzierung: ein expliziter Stern vor dem Funktionszeiger macht deutlich, dass es sich um eine Zeigervariable handelt. Während der Fehlersuche kann dies beim Lesen des Codes erheblich helfen. Die Klammern sind, wie schon bei der Deklaration, nötig, um dem Compiler mitzuteilen, dass sich der Stern nicht auf den Rückgabewert, sondern auf die Funktion bezieht.

Nuvola-inspired-terminal.svg
1 int x;
2 x = (*rechenoperation)(40, 8); // ruft multiplication()  bzw. division() auf und weist x den Rückgabewert zu
3 x = rechenoperation(40, 8);    // alternative (nicht empfohlene) Syntax

In C werden Funktionszeiger oft für generische Funktionen verwendet, wofür es in C++ mit den Templates (auf deutsch etwa „Vorlagen“) eine bessere Lösung gibt. Insbesondere werden in C++ statt Funktionszeigern auch oft Funktoren verwendet, welche aber erst später vorgestellt werden. Vorweggenommen sei an dieser Stelle bereits, dass ein Funktor etwas mehr Schreibaufwand benötigt als ein Funktionszeiger, dafür aber auch einiges kann, was mit einfachen Funktionszeigern nicht möglich ist.

Symbol kept vote.svg
Tipp

Verwenden Sie typedef um komplizierte Typen zu vereinfachen. Für unseren Zeigertyp könnte man etwa auch schreiben:

Nuvola-inspired-terminal.svg
1 typedef int (*Zeigertyp)(int, int);    // Zeigertyp als Alias für den Funktionszeigertyp
2 Zeigertyp rechenoperation = 0; // Anlegen eines Funktionszeigers, Initialisierung mit 0
Symbol move vote.svg
Thema wird später näher erläutert…

Im Zusammenhang mit Klassen werden uns weitere Arten von Zeigern begegnen:

  • Zeiger auf statische Datenelemente
  • Zeiger auf Elementfunktionen.

Beide werden Sie zu einem späteren Zeitpunkt noch kennen lernen. Auch im Abschnitt „Speicherverwaltung“ werden Ihnen Zeiger noch einmal begegnen.


Referenzen[Bearbeiten]

Grundlagen zu Referenzen[Bearbeiten]

Referenzen sind interne Zeiger auf Variablen. Sie werden also genau so verwendet wie gewöhnliche Variablen, verweisen jedoch auf das Objekt, mit dem sie initialisiert wurden. Die Zeigerverwendung wird vor dem Programmierer verborgen.

Nuvola-inspired-terminal.svg
1 int  a = 1;  // eine Variable
2 int &r = a;  // Referenz auf die Variable a
3 
4 std::cout << "a: " << a << " r: " << r << std::endl;
5 ++a;
6 std::cout << "a: " << a << " r: " << r << std::endl;
7 ++r;
8 std::cout << "a: " << a << " r: " << r << std::endl;
Crystal Clear app kscreensaver.svg
Ausgabe:
1 a: 1 r: 1
2 a: 2 r: 2
3 a: 3 r: 3

Wie Sie im Beispiel sehen, sind a und r identisch. Gleiches können Sie natürlich auch mit einem Zeiger erreichen, auch wenn bei einem Zeiger die Syntax etwas anders ist als bei einer Referenz.

Im Beispiel wurde die Referenz auf int r, mit dem int a initialisiert. Beachten Sie, dass die Initialisierung einer Referenzvariablen nur beim Anlegen erfolgen kann, danach kann ihr Wert nur noch durch eine Zuweisung geändert werden. Daraus folgt, dass eine Referenz immer initialisiert werden muss und es nicht möglich ist, eine Referenzvariable auf ein neues Objekt verweisen zu lassen:

Nuvola-inspired-terminal.svg
1 int  a = 10; // eine Variable
2 int  b = 20; // noch eine Variable
3 int &r = a;  // Referenz auf die Variable a
4 
5 std::cout << "a: " << a << " b: " << b << " r: " << r << std::endl;
6 ++a;
7 std::cout << "a: " << a << " b: " << b << " r: " << r << std::endl;
8 r = b;       // r zeigt weiterhin auf a, r (und somit a) wird 20 zugewiesen 
9 std::cout << "a: " << a << " b: " << b << " r: " << r << std::endl;
Crystal Clear app kscreensaver.svg
Ausgabe:
1 a: 10 b: 20 r: 10
2 a: 11 b: 20 r: 11
3 a: 20 b: 20 r: 20

Wie Sie sehen, ist es nicht möglich, r als Alias für b zu definieren, nachdem es einmal mit a initialisiert wurde. Die Zuweisung bewirkt genau das, was auch eine Zuweisung von b an a bewirkt hätte. Dass eine Referenz wirklich nichts weiter ist als ein Aliasname wird umso deutlicher, wenn man sich die Adressen der Variablen aus dem ersten Beispiel ansieht:

Nuvola-inspired-terminal.svg
1 int  a = 1;  // eine Variable
2 int &r = a;  // Referenz auf die Variable a
3 
4 std::cout << "a: " << &a << " r: " << &r << std::endl;
Crystal Clear app kscreensaver.svg
Ausgabe:
1 a: 0x7fffbf623c54 r: 0x7fffbf623c54

Die Ausgabe sieht bei Ihnen vermutlich etwas anders aus.

Wie Sie sehen, sind die Adressen identisch.

Anwendung von Referenzen[Bearbeiten]

Vielleicht haben Sie sich bereits gefragt, wofür Referenzen nun eigentlich gut sind, schließlich könnte man ja auch einfach die Originalvariable benutzen.

Selbstdefinierte Referenzen[Bearbeiten]

Referenzen bieten in einigen Anwendungsfällen eine Beschleunigung und bessere Lesbarkeit der Quelltexte. Sie müssen initialisiert werden.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main(){
 4     unsigned int const x = 2, y = 3, z = 4;
 5     unsigned int zahlen_array[x][y][z] = {
 6         { { 0,  1,  2,  3}, { 4,  5,  6,  7}, { 8,  9, 10, 11} },
 7         { {12, 13, 14, 15}, {16, 17, 18, 19}, {20, 21, 22, 23} }
 8     };
 9     for(unsigned int a = 0; a < x; ++a){
10         for(unsigned int b = 0; b < y; ++b){
11             for(unsigned int c = 0; c < z; ++c){
12                 // ref wird als Referenz auf zahlen_array[a][b][c] initialisiert
13                 unsigned int& ref = zahlen_array[a][b][c];
14                 // entspricht 'zahlen_array[a][b][c] *= 2;'
15                  ref *= 2;
16                 // entspricht 'zahlen_array[a][b][c] += a * b * c;'
17                  ref += a * b * c;
18                 // entspricht 'std::cout << zahlen_array[a][b][c] << std::endl;'
19                 std::cout << ref << ", ";
20             }
21             std::cout << std::endl;
22         }
23         std::cout << std::endl;
24     }
25 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 0, 2, 4, 6,
2 8, 10, 12, 14,
3 16, 18, 20, 22,
4 
5 24, 26, 28, 30, 
6 32, 35, 38, 41, 
7 40, 44, 48, 52,

Bei mehrfacher Verwendung, kann eine Referenz Ihnen viel Tipparbeit ersparen und vor allem erhöht sie die Übersichtlichkeit des Quellcodes. Außerdem kann diese Vorgehensweise die Performance verbessern, da der Zugriff auf Daten in Klassen oder Feldern durch eine Referenzdefinition vereinfacht wird. Bei obigem Beispiel wird zur Laufzeit, im Arbeitsspeicher, bei jeder Verwendung von zahlen_array[a][b][c] zuerst der Speicherort der einzelnen Zahl berechnet, dabei müssen die Inhalts-, Feldgrößen und Offsets innerhalb des Felds berücksichtigt werden. An anderen Stellen mag dies alles mit STL-Containerklassen und verschachtelten Methoden- und Operatoraufrufen erfolgen.

Dies alles können Sie dem Prozessor nicht ersparen. Sie können aber dafür sorgen, dass es, pro Schritt, nur einmal vorkommt. Die Verwendung einer Referenz ergibt daher Sinn, sobald Sie zahlen_array[a][b][c] mehr als einmal verwenden. Eine Referenz ist intern meist mit einem Zeiger implementiert. Es sei allerdings darauf hingewiesen, dass der Compiler in vielen Fällen diese Optimierung auch selbst vornehmen kann, daher ist ein Performancegewinn nicht zwingend vorhanden.

Call-By-Reference[Bearbeiten]

Möglicherweise erinnern Sie sich aber auch noch, dass im Kapitel „Prozeduren und Funktionen“ die Wertübergabe als Referenz (call-by-reference) vorgestellt wurde. Darauf wird nun genauer eingegangen.

Referenzen bieten genau wie Zeiger die Möglichkeit, den Wert einer Variable außerhalb der Funktion zu ändern. Im Folgenden sehen Sie die im Kapitel über Zeiger vorgestellte Funktion swap() mit Referenzen:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 void swap(int &wert1, int &wert2) {
 4     int tmp;
 5     tmp   = wert1;
 6     wert1 = wert2;
 7     wert2 = tmp;
 8 }
 9 
10 int main() {
11     int a = 7, b = 9;
12 
13     std::cout << "a: " << a << ", b: " << b << "\n";
14 
15     swap(a, b);
16 
17     std::cout << "a: " << a << ", b: " << b << "\n";
18     return (0);
19 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 a: 7, b: 9
2 a: 9, b: 7

Diese Funktion bietet gegenüber der Zeigervariante zwei Vorteile. Die Syntax ist einfacher und es ist nicht möglich, so etwas wie einen Nullzeiger zu übergeben. Um diese Funktion zum Absturz zu bewegen, ist schon einige Mühe nötig.

const-Referenzen[Bearbeiten]

Referenzen auf konstante Variablen spielen in C++ eine besondere Rolle. Eine Funktion, die eine Variable übernimmt, kann genauso gut auch eine Referenz auf eine konstante Variable übernehmen. Folgendes Beispiel soll dies demonstrieren:

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

Die beiden Ausgabefunktionen sind an sich identisch, lediglich die Art der Parameterübergabe unterscheidet sich. ausgabe1() übernimmt einen int, ausgabe2() eine Referenz auf einen konstanten int. Beide Funktionen lassen sich auch vollkommen identisch aufrufen. Würde ausgabe2() eine Referenz auf einen nicht-konstanten int übernehmen, wäre ein Aufruf mit einer Konstanten, wie dem int-Literal 5 nicht möglich.

In Verbindung mit Klassenobjekten ist die Übergabe als Referenz auf ein konstantes Objekt sehr viel schneller, dazu erfahren Sie aber zu gegebener Zeit mehr. Für die Ihnen bereits bekannten Basisdatentypen ist tatsächlich die Übergabe als Wert effizienter.

Referenzen als Rückgabetyp[Bearbeiten]

Referenzen haben als Rückgabewert die gleichen Vorteile wie bei der Wertübergabe. Allerdings sind sie in diesem Zusammenhang wesentlich gefährlicher. Es kann schnell passieren, dass Sie versehentlich eine Referenz auf eine lokale Variable zurückgeben. Diese Variable ist außerhalb der Funktion allerdings nicht mehr gültig, daher ist das Resultat, wenn Sie außerhalb der Funktion darauf zugreifen, undefiniert. Aus diesem Grund sollten Sie Referenzen als Rückgabewert nur verwenden wenn Sie wirklich wissen, was Sie tun.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 // gibt die Referenz des Parameters x zurück
 4 int &zahl(int &x) {
 5     return x;
 6 }
 7 
 8 int main() {
 9     int y = 3;
10     zahl(y) = 5;
11     std::cout << "wert: " << y; 
12     return y;
13 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 wert: 5


Felder[Bearbeiten]

In C++ lassen sich mehrere Variablen desselben Typs zu einem Array (im Deutschen bisweilen auch Datenfeld oder Vektor genannt, selten auch Matrix, Tabelle, Liste) zusammenfassen. Auf die Elemente des Arrays wird über einen Index zugegriffen. Bei der Definition sind der Typ der Elemente und die Größe des Arrays (=Anzahl der Elemente) anzugeben. Folgende Möglichkeiten stehen zum Anlegen eines Array zur Verfügung:

Nuvola-inspired-terminal.svg
1 // Array mit 10 Elementen vom Typ 'int'; Array-Name ist 'feld'.
2 int feld[10];                                      // Anlegen ohne Initialisierung
3 int feld[]   = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };  // Mit Initialisierung (automatisch 10 Elemente)
4 int feld[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };  // 10 Elemente, mit Initialisierung

Soll das Array initialisiert werden, verwenden Sie eine Aufzählung in geschweiften Klammern, wobei der Compiler die Größe des Arrays selbst ermitteln kann. Es wird empfohlen, diese automatische Größenerkennung nicht zu nutzen. Wenn die Größenangabe explizit gemacht wurde, gibt der Compiler einen Fehler aus, falls die Anzahl der Intitiallisierungselemente nicht mit der Größenangabe übereinstimmt.

Wie bereits erwähnt, kann auf die einzelnen Elemente eines Arrays mit dem Indexoperator [] zugegriffen werden. Beim Zugriff auf Arrayelemente beginnt die Zählung bei 0. Das heißt, ein Array mit 10 Elementen enthält die Elemente 0 bis 9. Ein Arrayindex ist immer ganzzahlig.

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 
3 int main() {
4     int feld[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; // 10 Elemente, mit Initalisierung
5 
6     for(int i = 0; i < 10; ++i) {
7         std::cout << feld[i] << " ";   // Elemente 0 bis 9 ausgeben
8     }
9 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 1 2 3 4 5 6 7 8 9 10

Mit Arrayelementen können alle Operationen wie gewohnt ausgeführt werden.

Nuvola-inspired-terminal.svg
 1 feld[4] = 88;
 2 feld[3] = 2;
 3 feld[2] = feld[3] - 5 * feld[7 + feld[3]];
 4 
 5 if(feld[0] < 1){
 6     ++feld[9];
 7 }
 8 
 9 for(int n = 0; n < 10; ++n){
10     std::cout << feld[n] << std::endl;
11 }


Symbol opinion vote.svg
Hinweis

Beachten Sie, dass der Compiler keine Indexprüfung durchführt. Wenn Sie ein nicht vorhandenes Element, z.B. feld[297] im Programm verwenden, kann Ihr Programm bei einigen Durchläufen unerwartet abstürzen. Zugriffe über Arraygrenzen erzeugen undefiniertes Verhalten. In modernen Desktop-Betriebssystemen kann das Betriebssystem einige dieser Bereichsüberschreitungen abfangen und das Programm abbrechen („segmentation fault“). Manchmal überschreibt man auch einfach nur den eigenen Speicherbereich in anderen Variablen, was zu schwer zu findenden Bugs führt.

Zeiger und Arrays[Bearbeiten]

Der Name eines Arrays wird vom Compiler (ähnlich wie bei Funktionen) als Adresse des Arrays interpretiert. In Folge dessen haben Sie neben der Möglichkeit über den Indexoperator auch die Möglichkeit, mittels Zeigerarithmetik auf die einzelnen Arrayelemente zuzugreifen.

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 
3 int main() {
4     int feld[10] = {1,2,3,4,5,6,7,8,9,10};
5 
6     std::cout << feld[3]   << "\n"; // Indexoperator
7     std::cout << *(feld + 3) << "\n"; // Zeigerarithmetik
8 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 4
2 4

Im Normalfall werden Sie mit der ersten Syntax arbeiten, es ist jedoch nützlich zu wissen, wie Sie ein Array mittels Zeigern manipulieren können. Es ist übrigens nicht möglich, die Adresse von feld zu ändern. feld verhält sich also in vielerlei Hinsicht wie ein konstanter Zeiger auf das erste Element des Arrays. Einen deutlichen Unterschied werden Sie allerdings bemerken, wenn Sie den Operator sizeof() auf die Arrayvariable anwenden. Als Rückgabe bekommen Sie die Größe des gesamten Arrays. Teilen Sie diesen Wert durch die Größe eines beliebigen Arrayelements, erhalten Sie die Anzahl der Elemente im Array.

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 
3 int main() {
4     int feld[10];
5 
6     std::cout << "   Array Größe: " << sizeof(feld)                   << "\n";
7     std::cout << " Element Größe: " << sizeof(feld[0])                << "\n";
8     std::cout << "Element Anzahl: " << sizeof(feld) / sizeof(feld[0]) << "\n";
9 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Array Größe: 40
2  Element Größe: 4
3 Element Anzahl: 10

Mehrere Dimensionen[Bearbeiten]

Auch mehrdimensionale Arrays sind möglich. Hierfür werden einfach Größenangaben für die benötigte Anzahl von Dimensionen gemacht. Das folgende Beispiel legt ein zweidimensionales Array der Größe 4 × 8 an, das 32 Elemente enthält. Theoretisch ist die Anzahl der Dimensionen unbegrenzt.

Nuvola-inspired-terminal.svg
1 int feld[4][8];    // Ohne Initialisierung
2 
3 int feld[4][8] = { // Mit Initialisierung
4     {  1,  2,  3,  4,  5,  6,  7,  8 },
5     {  9, 10, 11, 12, 13, 14, 15, 16 },
6     { 17, 18, 19, 20, 21, 22, 23, 24 },
7     { 25, 26, 27, 28, 29, 30, 31, 32 }
8 };

Wie Sie sehen, können auch mehrdimensionale Arrays initialisiert werden. Die äußeren geschweiften Klammern beschreiben die erste Dimension mit 4 Elementen. Die inneren geschweiften Klammern beschreiben dementsprechend die zweite Dimension mit 8 Elementen. Beachten Sie, dass die inneren geschweiften Klammern lediglich der Übersicht dienen, sie sind nicht zwingend erforderlich. Dementsprechend ist es für mehrdimensionale Arrays bei der Initialisierung nötig, die Größe aller Dimensionen anzugeben.

Genaugenommen wird eigentlich ein (1-dimensionales) Array von (1-dimensionalen) Arrays erzeugt. In unserem Beispiel ist feld ein Array mit 4 Elementen vom Typ „Array mit 8 Elementen vom Typ int“. Dementsprechend sieht auch der Aufruf mittels Zeigerarithmetik auf einzelne Elemente aus.

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 
3 int main(){
4     // Anlegen des Arrays mit Initialisierung von eben
5 
6     std::cout << feld[2][5]         << "\n"; // Indexoperator
7     std::cout << *(*(feld + 2) + 5) << "\n"; // Zeigerarithmetik
8 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 22
2 22

Es sind ebenso viele Dereferenzierungen wie Dimensionen nötig. Um sich vor Augen zu führen, wie die Zeigerarithmetik für diese mehrdimensionalen Arrays funktioniert, ist es nützlich, sich einfach die Adressen bei Berechnungen anzusehen:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main(){
 4     int feld[4][8];
 5 
 6 
 7     std::cout << "Größen\n";
 8     std::cout << "int[4][8]: " << sizeof(feld)     << "\n";
 9     std::cout << "   int[8]: " << sizeof(*feld)    << "\n";
10     std::cout << "      int: " << sizeof(**feld)   << "\n";
11 
12     std::cout << "Adressen\n";
13     std::cout << "       feld: " << feld        << "\n";
14     std::cout << "   feld + 1: " << feld + 1    << "\n";
15     std::cout << "(*feld) + 1: " << (*feld) + 1 << "\n";
16 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Größen
2 int[4][8]: 128
3    int[8]: 32
4       int: 4
5 Adressen
6        feld: 0x7fff2be5d400
7    feld + 1: 0x7fff2be5d420
8 (*feld) + 1: 0x7fff2be5d404

Wie Sie sehen, erhöht feld + 1 die Adresse um den Wert 32 (Hexadezimal 20), was sizeof(int[8]) entspricht. Also der Größe aller verbleibenden Dimensionen. Die erste Dereferenzierung liefert wiederum eine Adresse zurück. Wird diese um 1 erhöht, so steigt der Wert lediglich um 4 (sizeof(int)).

Symbol opinion vote.svg
Hinweis

Beachten Sie, dass auch für mehrdimensionale Arrays keine Indexprüfung erfolgt. Greifen Sie nicht auf ein Element zu, dessen Grenzen außerhalb des Arrays liegen. Beim Array int[12][7][9] können Sie auf die Elemente [0..11][0..6][0..8] zugreifen. Die Zählung beginnt also auch hier immer bei 0 und endet dementsprechend 1 unterhalb der Dimensionsgröße.

Arrays und Funktionen[Bearbeiten]

Arrays und Funktionen arbeiten in C++ nicht besonders gut zusammen. Sie können keine Arrays als Parameter übergeben und auch keine zurückgeben lassen. Da ein Array allerdings eine Adresse hat (und der Arrayname diese zurückliefert), kann man einfach einen Zeiger übergeben. C++ bietet (ob nun zum besseren oder schlechteren) eine alternative Syntax für Zeiger bei Funktionsparametern an.

Nuvola-inspired-terminal.svg
1 void funktion(int *parameter);
2 void funktion(int parameter[]);
3 void funktion(int parameter[5]);
4 void funktion(int parameter[76]);

Jeder dieser Prototypen ist gleichwertig. Die Größenangaben beim dritten und vierten Beispiel werden vom Compiler ignoriert. Innerhalb der Funktion können Sie wie gewohnt mit dem Indexoperator auf die Elemente zugreifen. Beachten Sie, dass Sie die Arraygröße innerhalb der Funktion nicht mit sizeof(arrayname) feststellen können. Bei diesem Versuch würden Sie stattdessen die Größe eines Zeigers auf ein Array-Element erhalten.

Aufgrund dieses Verhaltens könnte man die Schreibweise des ersten Prototypen auswählen. Andere Programmierer argumentieren, dass bei der zweiten Schreibweise deutlich wird, dass der Parameter ein Array repräsentiert. Eine Größenangabe bei Arrayparametern ist manchmal anzutreffen, wenn die Funktion nur Arrays dieser Größe bearbeiten kann. Um es noch einmal zu betonen: Diese Größenangaben sind nur ein Hinweis für den Programmierer; der Compiler wird ohne Fehler und Warnung Ihr Array als einfachen Zeiger übernehmen. Eine eventuelle Angabe der Elementanzahl beim Funktionsparameter wird vom Compiler komplett ignoriert.

Bei mehrdimensionalen Arrays sehen die Regeln ein wenig anders aus, da diese Arrays vom Typ Array sind. Wie Sie wissen, ist es zulässig, Zeiger als Parameter zu übergeben. Entsprechend ist natürlich auch ein Zeiger auf ein Array zulässig. Die folgenden Prototypen zeigen, wie die Syntax bei mehrdimensionalen Arrays aussieht.

Nuvola-inspired-terminal.svg
1 void funktion(int (*parameter)[8]);
2 void funktion(int parameter[][8]);
3 void funktion(int parameter[4][8]);

Alle diese Prototypen haben einen Parameter vom Typ „Zeiger auf Array mit acht Elementen vom Typ int“. Ab der zweiten Dimension geben Sie also tatsächlich Arrays an, somit müssen Sie natürlich auch die Anzahl der Elemente zwingend angeben. Daher können Sie sizeof() in der Funktion verwenden, um die Größe zu ermitteln. Dies ist allerdings nicht notwendig, da Sie bereits im Vorfeld wissen, wie groß der Array ist und vom welchem Typ er ist. Die Größe berechnet sich wie folgt:

sizeof(Typ)*Anzahl der Elemente. In unserem Beispiel entspricht dies 4*8 = 32. Auf ein zweidimensionales Array können Sie innerhalb der Funktion mit dem normalen Indexoperator zugreifen.

Beachten Sie, dass beim ersten Prototypen die Klammern zwingend notwendig sind, andernfalls hätten die eckigen Klammern auf der rechten Seite des Parameternamen Vorrang. Somit würde der Compiler dies wie oben gezeigt als einen Zeiger behandeln, natürlich unabhängig von der Anzahl der angegebenen Elemente. Ohne diese Klammern würden Sie also einen Zeiger auf einen Zeiger auf int deklarieren.

Symbol kept vote.svg
Tipp

Seit C++11 gibt es den Header <array> in welchem eine gleichnamige Datenstruktur definiert ist. Man könnte in diesem Zusammenhang vielleicht von C++-Arrays sprechen. Sie werden verwendet wie gewöhnliche C-Arrays, haben aber eine andere Deklaration. Ein Array mit 8 Elemente vom Typ int wird wie folgt definiert:

Nuvola-inspired-terminal.svg
1 #include <array>
2 // ...
3 std::array< int, 8 > variablenname;

Für mehrdimensionale Arrays kann man statt int als Datentyp wieder ein Array angeben. Die Deklaration ist also etwas aufwendiger als bei C-Arrays, dafür kann ein solches C++-Array aber ganz normal an Funktionen übergeben werden.

Nuvola-inspired-terminal.svg
1 void funktion(std::array< int, 8 > parameter);
2 void funktion(std::array< int, 8 > const& parameter);
3 void funktion(std::array< std::array< int, 8 >, 4 > const& parameter);

Im ersten Fall wird eine Kopie übergeben, im zweiten eine Referenz auf eine konstantes Array. In beiden Fällen können nur C++-Arrays mit genau 8 Elementen übergeben werden. Die dritte Zeile zeigt die Übergabe eines zweidimensionalen Arrays, auch hier müssen die beiden Dimensionen (4 und 8) natürlich exakt übereinstimmen.

Ein weiterer Vorteil ist, dass C++-Array-Objekte eine Funktion names size() haben, welche die Anzahl der Elemente zurückgibt.

Lesen komplexer Datentypen[Bearbeiten]

Sie kennen nun Zeiger, Referenzen und Arrays, sowie natürlich die grundlegenden Datentypen. Es kann Ihnen passieren, dass Sie auf Datentypen treffen, die all das in Kombination nutzen. Im Folgenden werden Sie lernen, solche komplexen Datentypen zu lesen und zu verstehen, wie man Sie schreibt.

Symbol kept vote.svg
Tipp

Als einfache Regel zum Lesen von solchen komplexeren Datentypen können Sie sich merken:

  • Es wird ausgehend vom Namen gelesen.
  • Steht etwas rechts vom Namen, wird es ausgewertet.
  • Steht rechts nichts mehr, wird der Teil auf der linken Seite ausgewertet.
  • Mit Klammern kann die Reihenfolge geändert werden.

Die folgenden Beispiele werden zeigen, dass diese Regeln immer gelten:

Nuvola-inspired-terminal.svg
 1 int i;            // i ist ein int
 2 int *j;           // j ist ein Zeiger auf int
 3 int k[6];         // k ist ein Array von sechs Elementen des Typs int
 4 int *l[6];        // l ist ein Array von sechs Elementen des Typs Zeiger auf int
 5 int (*m)[6];      // m ist ein Zeiger auf ein Array von sechs Elementen des Typs int
 6 int *(*&n)[6];    // n ist eine Referenz auf einen Zeiger auf ein Array von
 7                   // sechs Elementen des Typs Zeiger auf int
 8 int *(*o[6])[5];  // o ist ein Array von sechs Elementen des Typs Zeiger auf ein
 9                   // Array von fünf Elementen des Typs Zeiger auf int
10 int **(*p[6])[5]; // p ist Array von sechs Elementen des Typs Zeiger auf ein Array
11                   // von fünf Elementen des Typs Zeiger auf Zeiger auf int

Nehmen Sie sich die Zeit, die Beispiele nachzuvollziehen. Wenn Sie keine Probleme damit haben, sehen Sie sich das nächste sehr komplexe Beispiel an. Es soll die allgemeine Gültigkeit dieser Regel noch einmal demonstrieren:

Nuvola-inspired-terminal.svg
1 int (*(*(**pFunc[5])(int*, double&))[6])();

pFunc ist ein Array mit fünf Elementen, das Zeiger auf Zeiger auf Funktionen enthält, die einen Zeiger auf int und eine Referenz auf double übernehmen und einen Zeiger auf Arrays mit sechs Elementen vom Typ Zeiger auf Funktionen, ohne Parameter, mit einem int als Rückgabewert zurückgeben. Einem solchen Monstrum werden Sie beim Programmieren wahrscheinlich selten bis nie begegnen, aber falls doch, können Sie es mit den obengenannten Regeln entschlüsseln. Wenn Sie nicht in der Lage sind, dem Beispiel noch zu folgen, brauchen Sie sich keine Gedanken zu machen: Nur wenige Menschen sind in der Lage, sich ein solches Konstrukt überhaupt noch vorzustellen. Wenn Sie es nachvollziehen können, kommen Sie sehr wahrscheinlich mit jeder Datentypdeklaration klar!

Symbol opinion vote.svg
Hinweis

Wenn Sie in Ihren Programmen solche Strukturen deklarieren/anlegen, denken Sie daran, dass ein kurzes Kommentar es jedermann viel einfacher macht, die Struktur zu verstehen!


Zeichenketten[Bearbeiten]

Einleitung[Bearbeiten]

In C gibt es keinen eingebauten Datentyp für Zeichenketten, lediglich einen für einzelne Zeichen. Da es in C noch keine Klassen gab, bediente man sich dort der einfachsten Möglichkeit, aus Zeichen Zeichenketten zu bilden: Man legte einfach einen Array von Zeichen an. C++ bietet eine komfortablere Lösung an: Die C++-Standardbibliothek enthält eine Klasse namens string. Um diese Klasse nutzen zu können, müssen Sie die gleichnamige Headerdatei string einbinden.

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 #include <string>
3 
4 int main() {
5     std::string zeichenkette;
6     zeichenkette = "Hallo Welt!";
7     std::cout << zeichenkette << std::endl;
8 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Hallo Welt!

Wir werden uns in diesem Kapitel mit der C++-Klasse string auseinandersetzen. Am Ende des Kapitels beleuchten wir den Umgang mit C-Strings (also char-Arrays) etwas genauer. Natürlich liegt auch string, wie alle Teile der Standardbibliothek, im Namensraum std.

Wie entsteht ein string-Objekt?[Bearbeiten]

Zunächst sind einige Worte zur Notation von Zeichenketten in doppelten Anführungszeichen nötig. Wie Ihnen bereits bekannt ist, werden einzelne Zeichen in einfachen Anführungszeichen geschrieben. Dieser Zeichenliteral ist dann vom Typ char. Die doppelten Anführungszeichen erzeugen hingegen eine Instanz eines char-Arrays. "Hallo Welt!" ist zum Beispiel vom Typ char[12].

Es handelt sich also um eine Kurzschreibweise, zum Erstellen von char-Arrays, damit Sie nicht {'H', 'a', 'l', 'l', 'o', ' ', 'W', 'e', 'l', 't', '!', '\0'} schreiben müssen, um eine einfache Zeichenkette zu erstellen. Was ist das '\0' und warum ist das Array 12 chars lang, obwohl es nur 11 Zeichen enthält? Wie bereits erwähnt, ist ein C-String ein Array von Zeichen. Da ein solcher C-String natürlich im Programmablauf Zeichenketten unterschiedlicher Längen enthalten konnte, beendete man die Zeichenkette durch ein Endzeichen: '\0' (Zahlenwert 0). Somit musste ein Array von Zeichen in C immer ein Zeichen länger sein, als die längste Zeichenkette, die im Programmverlauf darin gespeichert wurde.

Diese Kurzschreibweise kann aber noch mehr, als man auf den ersten Blick vermuten würde. Die eben genannte lange Notation zur Initialisierung eines Arrays funktioniert im Quelltext nur, wenn der Compiler auch weiß, von welchem Datentyp die Elemente des Arrays sein sollen. Da Zeichenliterale jedoch implizit in größere integrale Typen umgewandelt werden können, kann er den Datentyp nicht vom Typ der Elemente, die für die Initialisierung genutzt wurden ableiten:

Crystal Clear action button cancel.svg
 1 #include <string>
 2 
 3 int main() {
 4     // char-Array mit 12 Elementen
 5     char a[] = {'H', 'a', 'l', 'l', 'o', ' ', 'W', 'e', 'l', 't', '!', '\0'};
 6 
 7     // int-Array mit 12 Elementen
 8     int  b[] = {'H', 'a', 'l', 'l', 'o', ' ', 'W', 'e', 'l', 't', '!', '\0'};
 9 
10     // char-Array mit 12 Elementen
11     std::string z = {'H', 'a', 'l', 'l', 'o', ' ', 'W', 'e', 'l', 't', '!', '\0'};
12 }

Bei der Notation mit Anführungszeichen ist dagegen immer bekannt, dass es sich um ein char-Array handelt. Entsprechend ist die Initialisierung eines int-Arrays damit nicht möglich. Folgendes dagegen schon:

CrystalClearActionApply.svg
1 #include <string>
2 
3 int main() {
4     // char-Array mit 12 Elementen
5     char a[] = "Hallo Welt!";
6 
7     // char-Array mit 12 Elementen
8     std::string z = "Hallo Welt!";
9 }

Bei der Erzeugung eines string-Objekts wird eine Funktion aufgerufen, die sich Konstruktor nennt. Was genau ein Konstruktor ist, erfahren Sie im Kapitel über Klassen. In unserem Fall wird also der Konstruktor für das string-Objekt z aufgerufen. Als Parameter erhält er das char-Array "Hallo Welt!". Wie Ihnen bereits bekannt ist, können an Funktionen keine Arrays übergeben werden. Stattdessen wird natürlich ein Zeiger vom Arrayelementtyp (also char) übergeben. Dabei geht aber die Information verloren, wie viele Elemente dieses Array enthält und an dieser Stelle kommt das '\0'-Zeichen (Nullzeichen) ins Spiel. Anhand dieses Zeichens kann auch innerhalb des Konstruktors erkannt werden, wie lang die übergebene Zeichenkette ist.

Damit wissen Sie nun, wie aus dem einfachen char-Array das fertige string-Objekt wird. Jetzt ist es an der Zeit zu erfahren, was Sie mit diesem Objekt alles machen können

string und andere Datentypen[Bearbeiten]

Wie Sie bereits im Beispiel von eben gesehen haben, lässt sich die string-Klasse problemlos mit anderen Datentypen und Klassen kombinieren. Im ersten Beispiel dieses Kapitels wurde zunächst eine Zuweisung eines char-Arrays vorgenommen. Anschließend wurde das string-Objekt über cout ausgegeben. Auch die Eingabe einer Zeichenkette über cin ist mit einem string-Objekt problemlos möglich:

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 #include <string>
3 
4 int main() {
5     std::string zeichenkette;
6 
7     std::cin >> zeichenkette;
8     std::cout << zeichenkette;
9 }

Diese Art der Eingabe erlaubt es lediglich, bis zum nächsten Whitespace einzulesen. Es kommt jedoch häufig vor, dass man eine Zeichenkette bis zum Zeilenende oder einem bestimmten Endzeichen einlesen möchte. In diesem Fall ist die Funktion getline hilfreich. Sie erwartet als ersten Parameter einen Eingabestream und als zweiten ein string-Objekt.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 #include <string>
 3 
 4 int main() {
 5     std::string zeichenkette;
 6 
 7     // Liest bis zum Zeilenende
 8     std::getline(std::cin, zeichenkette);
 9     std::cout << zeichenkette;
10 }

Als optionalen dritten Parameter kann man das Zeichen angeben, bis zu dem man einlesen möchte. Im Fall von eben wurde als der Default-Parameter '\n' (Newline-Zeichen) benutzt. Im folgenden Beispiel wird stattdessen bis zum ersten kleinen y eingelesen.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 #include <string>
 3 
 4 int main() {
 5     std::string zeichenkette;
 6 
 7     // Liest bis zum nächsten y
 8     std::getline(std::cin, zeichenkette, 'y');
 9     std::cout << zeichenkette;
10 }

Zuweisen und Verketten[Bearbeiten]

Genau wie die Basisdatentypen, lassen sich auch strings einander zuweisen. Für die Verkettung von strings wird der +-Operator benutzt und das Anhängen einer Zeichenkette ist mit += möglich.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 #include <string>
 3 
 4 int main() {
 5     std::string string1, string2, string3;
 6 
 7     string1 = "ich bin ";
 8     string2 = "klug";
 9     string3 = string1 + string2;
10     std::cout << string3 << std::endl;
11 
12     string3 += " - " + string1 + "schön";
13     std::cout << string3 << std::endl;
14 
15     std::cout << string1 + "schön und" + string2 << std::endl;
16 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 ich bin klug
2 ich bin klug - ich bin schön
3 ich bin schön und klug

Spielen Sie einfach ein wenig mit den Operatoren, um den Umgang mit ihnen zu lernen.

Nützliche Methoden[Bearbeiten]

Die string-Klasse stellt einige nützliche Methoden bereit. Etwa um den String mit etwas zu füllen, ihn zu leeren oder über verschiedene Eigenschaften Auskunft zu bekommen. Eine Methode wird mit folgender Syntax aufgerufen:

Crystal Project Tutorials.png
Syntax:
«stringname».«methodenname»(«parameter...»);
«Nicht-C++-Code», »optional«

Die Methoden size() und length() erwarten keine Parameter und geben beide die aktuelle Länge der gespeicherten Zeichenkette zurück. Diese Doppelung in der Funktionalität existiert, da string in Analogie zu den anderen Containerklassen der C++-Standardbibliothek size() anbieten muss, der Name length() für die Bestimmung der Länge eines Strings aber natürlicher und auch allgemein üblich ist. empty() gibt true zurück falls der String leer ist, andernfalls false.

Mit clear() lässt sich der String leeren. Die resize()-Methode erwartet ein oder zwei Parameter. Der erste ist die neue Größe des Strings, der zweite das Zeichen, mit dem der String aufgefüllt wird, falls die angegebene Länge größer ist, als die aktuelle. Wird der zweite Parameter nicht angegeben, wird der String mit '\0' (Nullzeichen) aufgefüllt. In der Regel werden Sie dieses Verhalten nicht wollen, geben Sie also ein Füllzeichen an, falls Sie sich nicht sicher sind, was Sie tun. Ist die angegebene Länge geringer, als die des aktuellen Strings, wird am Ende abgeschnitten.

Um den Inhalt zweier Strings auszutauschen existiert die swap()-Methode. Sie erwartet als Parameter den String mit dem ihr Inhalt getauscht werden soll. Dies ist effizienter, als das Vertauschen über eine dritte, temporäre string-Variable.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 #include <string>
 3 
 4 int main() {
 5     std::string zeichenkette1 = "Ich bin ganz lang!";
 6     std::string zeichenkette2 = "Ich kurz!";
 7 
 8     std::cout << zeichenkette1 << std::endl;
 9     std::cout << zeichenkette2 << std::endl;
10 
11     zeichenkette1.swap(zeichenkette2);
12 
13     std::cout << zeichenkette1 << std::endl;
14     std::cout << zeichenkette2 << std::endl;
15 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Ich bin ganz lang!
2 Ich kurz!
3 Ich kurz!
4 Ich bin ganz lang!

Zeichenzugriff[Bearbeiten]

Genau wie bei einem Array können Sie den []-Operator (Zugriffsoperator) verwenden, um auf einzelne Zeichen im String zuzugreifen. Allerdings wird, ebenfalls genau wie beim Array, nicht überprüft, ob der angegebene Wert noch innerhalb der enthaltenen Zeichenkette liegt.

Alternativ existiert die Methode at(), die den Index als Parameter erwartet und eine Grenzprüfung ausführt. Im Fehlerfall löst sie eine out_of_range-Exception aus. Da Sie den Umgang mit Exceptions wahrscheinlich noch nicht beherrschen, sollten Sie diese Methode vorerst nicht einsetzen und stattdessen genau darauf achten, dass Sie nicht versehentlich über die Stringlänge hinaus zugreifen.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 #include <string>
 3 
 4 int main() {
 5     std::string zeichenkette = "Ich bin ganz lang!";
 6 
 7     std::cout << zeichenkette[4] << std::endl;
 8     std::cout << zeichenkette.at(4) << std::endl;
 9 
10     std::cout << zeichenkette[20] << std::endl;    // Ausgabe von Datenmüll
11     std::cout << zeichenkette.at(20) << std::endl; // Laufzeitfehler
12 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 b
2 b
3 
4 terminate called after throwing an instance of 'std::out_of_range'
5   what():  basic_string::at
6 Abgebrochen

Die Fehlerausgabe kann bei Ihrem Compiler anders aussehen.

Symbol opinion vote.svg
Hinweis

Beachten Sie beim Zugriff, dass das erste Zeichen den Index 0 hat. Das letzte Zeichen hat demzufolge den Index zeichenkette.length() - 1.

Manipulation[Bearbeiten]

Suchen[Bearbeiten]

Die Methode find() sucht das erste Vorkommen eines Strings und gibt die Startposition (Index) zurück. Der zweite Parameter gibt an, ab welcher Position des Strings gesucht werden soll.

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 #include <string>
3 
4 int main() {
5     std::string str = "Zeichenkette";
6     std::string find = "k";
7     std::cout << str.find(find, 0);
8 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 7

Wird ein Substring nicht gefunden, gibt find() den Wert std::string::npos zurück.

Das Gegenstück zu find() ist rfind(). Es ermittelt das letzte Vorkommen eines Strings. Die Parameter sind die gleichen wie bei find().

Löschen[Bearbeiten]

Mit der Methode erase() können Zeichen im String gelöscht werden. Der erste Parameter gibt den Startwert an. Zusätzlich kann man mit dem zweiten Parameter die Anzahl der Zeichen festlegen. Wird die Methode nur mit dem Startwert aufgerufen, löscht sie alle Zeichen ab dieser Position.

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 #include <string>
3 
4 int main() {
5     std::string str = "Hallo Welt.";
6     str.erase(5, 1);
7     std::cout << str << std::endl;
8 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 HalloWelt.

Ersetzen[Bearbeiten]

Sie können replace() verwenden, um Strings zu ersetzen. Dafür benötigen Sie die Anfangsposition und die Anzahl der Zeichen, die anschließend ersetzt werden sollen.

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 #include <string>
3 
4 int main() {
5     std::string str = "Zeichenkette";
6     str.replace(str.find("k"), std::string("kette").length(), "test");
7     std::cout << str << std::endl;
8 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Zeichentest

Wie Sie sehen, verwenden wir find(), um die Startposition zu ermitteln. Der zweite Parameter gibt die Länge an. Hier soll die alternative Schreibweise verdeutlicht werden; Sie müssen nicht eine zusätzliche Variable deklarieren, sondern können die std::string-Klasse wie eine Funktion verwenden und über Rückgabewert auf die Methode length() zugreifen. Im dritten Parameter spezifizieren Sie den String, welcher den ursprünglichen String zwischen der angegebenen Startposition und Startposition + Laenge ersetzt.

Einfügen[Bearbeiten]

Die Methode insert() erlaubt es Ihnen, einen String an einer bestimmten Stelle einzufügen.

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 #include <string>
3 
4 int main() {
5     std::string str = "Hallo Welt.";
6     str.insert(5, " schöne");
7     std::cout << str << std::endl;
8 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Hallo schöne Welt

Kopieren[Bearbeiten]

Mit der Methode substr() kann man sich einen Zeichenketten-Teil zurückgeben lassen. Der erste Parameter gibt den Startwert an. Zusätzlich kann man mit dem zweiten Parameter noch die Anzahl der Zeichen festlegen. Wird die Methode nur mit dem Startwert aufgerufen, gibt sie alle Zeichen ab dieser Position zurück.

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 #include <string>
3 
4 int main() {
5     std::string str = "Hallo Welt.";
6     std::cout << str.substr(0, str.find(' ') - 0) << std::endl;
7 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Hallo

Das -0 soll verdeutlichen, dass der Startwert abgezogen werden muss, an dieser Stelle ist es natürlich überflüssig.

Vergleiche[Bearbeiten]

C++-Strings können Sie, genau wie Zahlen, miteinander vergleichen. Was Gleichheit und Ungleichheit bei einem String bedeutet, wird Ihnen sofort klar sein. Sind alle Zeichen zweier Strings identisch, so sind beide gleich, andernfalls nicht. Die Operatoren <, >, <= und >= geben da schon einige Rätsel mehr auf.

Im Grunde kennen Sie die Antwort bereits. Zeichen sind in C++ eigentlich Zahlen. Sie werden zu Zeichen, indem den Zahlen entsprechende Symbole zugeordnet werden. Der Vergleich erfolgt also einfach mit den Zahlen, welche die Zeichen kodieren. Das erste Zeichen der Strings, das sich unterscheidet, entscheidet darüber, welcher der Strings größer bzw. kleiner ist.

Die meisten Zeichenkodierungen beinhalten in den ersten 7 Bit den ASCII-Code, welchen die nachfolgende Tabelle zeigt.

ASCII-Codetabelle, Nummerierung im Hexadezimalsystem (Teil 1)
Code …0 …1 …2 …3 …4 …5 …6 …7
0… NUL SOH STX ETX EOT ENQ ACK BEL
1… DLE DC1 DC2 DC3 DC4 NAK SYN ETB
2… SP ! " # $ % & '
3… 0 1 2 3 4 5 6 7
4… @ A B C D E F G
5… P Q R S T U V W
6… ` a b c d e f g
7… p q r s t u v w
ASCII-Codetabelle, Nummerierung im Hexadezimalsystem (Teil 2)
Code …8 …9 …A …B …C …D …E …F
0… BS HT LF VT FF CR SO SI
1… CAN EM SUB ESC FS GS RS US
2… ( ) * + , - . /
3… 8 9 : ; < = > ?
4… H I J K L M N O
5… X Y Z [ \ ] ^ _
6… h i j k l m n o
7… x y z { | } ~ DEL
Nuvola-inspired-terminal.svg
 1 #include <string>
 2 
 3 int main(){
 4     std::string gross = "Ich bin ganz groß!";
 5     std::string klein = "Ich bin ganz klein!";
 6 
 7     gross == klein; // ergibt false ('g' != 'k')
 8     gross != klein; // ergibt true  ('g' != 'k')
 9     gross <  klein; // ergibt true  ('g' <  'k')
10     gross >  klein; // ergibt false ('g' <  'k')
11     gross <= klein; // ergibt true  ('g' <  'k')
12     gross >= klein; // ergibt false ('g' <  'k')
13 }

Zahl zu string und umgekehrt[Bearbeiten]

In C++ gibt es, im Gegensatz zu vielen anderen Programmiersprachen, keine Funktion, um direkt Zahlen in Strings oder umgekehrt umzuwandeln. Es ist allerdings nicht besonders schwierig, eine solche Funktion zu schreiben. Wir haben für die Umwandlung zwei Möglichkeiten:

  • Die C-Funktionen atof(), atoi(), atol() und sprintf()
  • C++-String-Streams

Die C-Variante wird in Kürze im Zusammenhang mit C-Strings besprochen. Für den Moment wollen wir uns der C++-Variante widmen. Stringstreams funktionieren im Grunde genau wie die Ihnen bereits bekannten Ein-/Ausgabestreams cin und cout mit dem Unterschied, dass sie ein string-Objekt als Ziel benutzen.

Nuvola-inspired-terminal.svg
 1 #include <iostream> // Standard-Ein-/Ausgabe
 2 #include <sstream>  // String-Ein-/Ausgabe
 3 
 4 int main() {
 5     std::ostringstream strout; // Unser Ausgabe-Stream
 6     std::string str;           // Ein String-Objekt
 7     int var = 10;              // Eine ganzzahlige Variable
 8 
 9     strout << var;             // ganzzahlige Variable auf Ausgabe-Stream ausgeben
10     str = strout.str();        // Streaminhalt an String-Variable zuweisen
11 
12     std::cout << str << std::endl; // String ausgeben
13 }

Der vorliegende Code wandelt eine Ganzzahl in einen String um, indem die Ganzzahl auf dem Ausgabe-Stringstream ausgegeben und dann der Inhalt des Streams an den String zugewiesen wird. Die umgekehrte Umwandlung funktioniert ähnlich. Natürlich verwenden wir hierfür einen Eingabe-Stringstream (istringstream statt ostringstream) und übergeben den Inhalt des Strings an den Stream, bevor wir ihn von diesem auslesen.

Nuvola-inspired-terminal.svg
 1 #include <iostream> // Standard-Ein-/Ausgabe
 2 #include <sstream>  // String-Ein-/Ausgabe
 3 
 4 int main() {
 5     std::istringstream strin; // Unser Eingabe-Stream
 6     std::string str = "17";   // Ein String-Objekt
 7     int var;                  // Eine ganzzahlige Variable
 8 
 9     strin.str(str);           // Streaminhalt mit String-Variable füllen
10     strin >> var;             // ganzzahlige Variable von Eingabe-Stream einlesen
11 
12     std::cout << var << std::endl; // Zahl ausgeben
13 }

Statt istringstream und ostringstream können Sie übrigens auch ein stringstream-Objekt verwenden, welches sowohl Ein-, als auch Ausgabe erlaubt, allerdings sollte man immer so präzise wie möglich angeben, was der Code machen soll. Daher ist die Verwendung eines spezialisierten Streams zu empfehlen, wenn Sie nur die speziellen Fähigkeiten (Ein- oder Ausgabe) benötigen.

Sicher sind Sie jetzt bereits in der Lage, zwei Funktionen zu schreiben, welche diese Umwandlung durchführt. Allerdings stehen wir in dem Moment, wo wir andere Datentypen als int in Strings umwandeln wollen vor einem Problem. Wir können der folgenden Funktion zwar ohne weiteres eine double-Variable übergeben, allerdings wird dann der Nachkommateil einfach abgeschnitten. Als Lösung kommt Ihnen nun eventuell in den Sinn, einfach eine double-Variable von der Funktion übernehmen zu lassen.

Nuvola-inspired-terminal.svg
 1 #include <iostream> // Standard-Ein-/Ausgabe
 2 #include <sstream>  // String-Ein-/Ausgabe
 3 
 4 std::string zahlZuString(double wert) {
 5     std::ostringstream strout; // Unser Ausgabe-Stream
 6     std::string str;           // Ein String-Objekt
 7 
 8     strout << wert;            // Zahl auf Ausgabe-Stream ausgeben
 9     str = strout.str();        // Streaminhalt an String-Variable zuweisen
10 
11     return str;                // String zurückgeben
12 }
13 
14 int main() {
15     std::string str;
16     int    ganzzahl  = 19;
17     double kommazahl = 5.55;
18 
19     str = zahlZuString(ganzzahl);
20     std::cout << str << std::endl;
21 
22     str = zahlZuString(kommazahl);
23     std::cout << str << std::endl;
24 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 19
2 5.55

Nun, so weit so gut. Das funktioniert. Leider gibt es da aber auch noch die umgekehrte Umwandlung und obgleich es möglich ist, sie auf ähnliche Weise zu lösen, wird Ihr Compiler sich dann ständig mit einer Warnung beschweren, wenn das Ergebnis Ihrer Umwandlung an eine ganzzahlige Variable zugewiesen wird.

Besser wäre es, eine ganze Reihe von Funktionen zu erzeugen, von denen jede für einen Zahlentyp verantwortlich ist. Tatsächlich können Sie in C++ mehrere Funktionen gleichen Namens erzeugen, die unterschiedliche Parameter(typen) übernehmen. Diese Vorgang nennt sich Überladen von Funktionen. Der Compiler entscheidet dann beim Aufruf der Funktion anhand der übergebenen Parameter, welche Version gemeint war, während der Programmierer immer den gleichen Namen verwendet.

Im Moment haben wir obendrein einen Sonderfall der Überladung. Alle unsere Funktionen besitzen exakt den gleichen Code. Lediglich der Parametertyp ist unterschiedlich. Es wäre ziemlich zeitaufwendig und umständlich, den Code immer wieder zu kopieren, um dann nur den Datentyp in der Parameterliste zu ändern. Noch schlimmer wird es, wenn wir eines Tages eine Änderung am Funktionsinhalt vornehmen und diese dann auf alle Kopien übertragen müssen.

Glücklicherweise bietet C++ für solche Fälle so genannte Templates, die es uns erlauben, den Datentyp vom Compiler ermitteln zu lassen. Wir teilen dem Compiler also mit, was er tun soll, womit muss er dann selbst herausfinden. Die Funktion zahlZuString() (umbenannt in toString()) sieht als Template folgendermaßen aus:

Nuvola-inspired-terminal.svg
 1 #include <iostream> // Standard-Ein-/Ausgabe
 2 #include <sstream>  // String-Ein-/Ausgabe
 3 
 4 template <typename Typ>
 5 std::string toString(Typ wert) {
 6     std::ostringstream strout; // Unser Ausgabe-Stream
 7     std::string str;           // Ein String-Objekt
 8 
 9     strout << wert;            // Zahl auf Ausgabe-Stream ausgeben
10     str = strout.str();        // Streaminhalt an String-Variable zuweisen
11 
12     return str;                // String zurückgeben
13 }
14 
15 int main() {
16     std::string str;
17     int    ganzzahl  = 19;
18     double kommazahl = 5.55;
19     std::string nochnString = "Blödsinn";
20 
21     str = toString(ganzzahl);
22     std::cout << str << std::endl;
23 
24     str = toString(kommazahl);
25     std::cout << str << std::endl;
26 
27     str = toString(nochnString);
28     std::cout << str << std::endl;
29 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 19
2 5.55
3 Blödsinn

Die letzte Ausgabe zeigt deutlich warum die Funktion in toString umbenannt wurde, denn sie ist nun in der Lage, jeden Datentyp, der sich auf einem ostringstream ausgeben lässt, zu verarbeiten und dazu zählen eben auch string-Objekte und nicht nur Zahlen. Sie werden später noch lernen, welches enorme Potenzial diese Technik in Zusammenhang mit eigenen Datentypen hat. An dieser Stelle sei Ihnen noch die Funktion zur Umwandlung von Strings in Zahlen (oder besser: alles was sich von einem istringstream einlesen lässt) mit auf den Weg gegeben:

Nuvola-inspired-terminal.svg
 1 #include <iostream> // Standard-Ein-/Ausgabe
 2 #include <sstream>  // String-Ein-/Ausgabe
 3 
 4 template <typename Typ>
 5 void stringTo(std::string str, Typ &wert) {
 6     std::istringstream strin; // Unser Eingabe-Stream
 7 
 8     strin.str(str);           // Streaminhalt mit String-Variable füllen
 9     strin >> wert;            // Variable von Eingabe-Stream einlesen
10 }
11 
12 int main() {
13     std::string str = "7.65Blödsinn";
14     int    ganzzahl;
15     double kommazahl;
16     std::string nochnString;
17 
18     stringTo(str, ganzzahl);
19     std::cout << ganzzahl << std::endl;
20 
21     stringTo(str, kommazahl);
22     std::cout << kommazahl << std::endl;
23 
24     stringTo(str, nochnString);
25     std::cout << nochnString << std::endl;
26 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 7
2 7.65
3 7.65Blödsinn

Die Variable, die mit dem Wert des Strings belegt werden soll, wird als Referenz an die Funktion übergeben, damit der Compiler ihren Typ feststellen kann. Die Ausgabe zeigt, dass immer nur so viel eingelesen wird, wie der jeweilige Datentyp (zweiter Funktionsparameter) fassen kann. Für eine ganzzahlige Variable wird nur die Zahl Sieben eingelesen, die Gleitkommavariable erhält den Wert 7.65 und das string-Objekt kann die gesamte Zeichenkette übernehmen.

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

Sie werden Überladung im Kapitel „Methoden“ genauer kennen lernen. Templates sind ein sehr umfangreiches Thema, auf sie wird im Abschnitt Templates eingegangen.

C-Strings[Bearbeiten]

Wie bereits erwähnt, handelt es sich bei einem C-String um ein Array von chars. Das Ende eines C-Strings wird durch ein Nullzeichen (Escape-Sequenz '\0') angegeben. Das Arbeiten mit C-Strings ist mühsam, denn es muss immer sichergestellt sein, dass das Array auch groß genug ist, um den String zu beinhalten. Da in C/C++ jedoch auch keine Bereichsüberprüfung durchgeführt wird, macht sich ein Pufferüberlauf (also eine Zeichenkette die größer ist als das Array, das sie beinhaltet) erst durch einen eventuellen Programmabsturz bemerkbar. Allein um dies zu vermeiden sollten Sie, wann immer es Ihnen möglich ist, die C++-string-Klasse verwenden.

Ein weiteres Problem beim Umgang mit C-Strings ist der geringe Komfort beim Arbeiten. Ob Sie einen String mit einem anderen vergleichen wollen, oder ihn an ein anderes Array „zuweisen“ möchten, in jedem Fall benötigen Sie unintuitive Zusatzfunktionen. Diese Funktionen finden Sie in der Standardheaderdatei „cstring“. Wie diese Funktionen heißen und wie man mit ihnen umgeht können Sie im C++-Referenz-Buch nachlesen, falls Sie sie einmal benötigen sollten.

Symbol redirect vote.svg
Buchempfehlung

Wenn Sie sich eingehender mit der Thematik auseinandersetzen möchten, sei Ihnen das Buch C-Programmierung ans Herz gelegt. Wenn Sie in C++ mit der C-Standard-Bibliothek arbeiten möchten, müssen Sie den Headerdateien ein „c“ voranstellen und das „.h“ weglassen. So wird beispielsweise aus dem C-Header „string.h“ der C++-Header „cstring“.


Vorarbeiter des Compilers[Bearbeiten]

Bevor der Compiler eine C++-Datei zu sehen kriegt, läuft noch der Präprozessor durch. Er überarbeitet den Quellcode, sodass der Compiler daraus eine Objektdatei erstellen kann. Diese werden dann wiederum vom Linker zu einem Programm gebunden. In diesem Kapitel soll es um den Präprozessor gehen, wenn Sie allgemeine Informationen über Präprozessor, Compiler und Linker brauchen, dann lesen Sie das Kapitel „Compiler“.

#include[Bearbeiten]

Die Präprozessordirektive #include haben Sie schon häufig benutzt. Sie fügt den Inhalt der angegebenen Datei ein. Dies ist nötig, da der Compiler immer nur eine Datei übersetzen kann. Viele Funktionen werden aber in verschiedenen Dateien benutzt. Daher definiert man die Prototypen der Funktionen (und einige andere Dinge, die Sie noch kennenlernen werden) in so genannten Headerdateien. Diese Headerdateien werden dann über #include eingebunden, wodurch Sie die Funktionen usw. aufrufen können.

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

Ausführlich Informationen über Headerdateien erhalten Sie im gleichnamigen Kapitel.

#include bietet zwei Möglichkeiten, Headerdateien einzubinden:

Nuvola-inspired-terminal.svg
1 #include "name" // Sucht im aktuellen Verzeichnis und dann in den Standardpfaden des Compilers
2 #include <name> // Sucht gleich in den Standardpfaden des Compilers

„Aktuelles Verzeichnis“ bezieht sich immer auf das Verzeichnis, in welchem die Datei liegt.

Die erste Syntax funktioniert immer, hat aber den Nachteil, dass dem Compiler nicht mitgeteilt wird, dass es sich um eine Standardheaderdatei handelt. Wenn sich im aktuellen Verzeichnis beispielsweise eine Datei namens iostream befände und Sie versuchten über die erste Syntax, die Standardheaderdatei iostream einzubinden, bänden Sie stattdessen die Datei im aktuellen Verzeichnis ein, was sehr unwahrscheinlich sein sollte, da Sie hoffentlich immer Dateiendungen wie .hpp oder .h für Ihre eigenen Header verwenden. Außerdem verlängert das Einbinden von Standardheadern in Anführungszeichen den Präprozessordurchlauf, je nach Anzahl der Dateien im aktuellen Quellpfad.

Aus diesem Grund ist es wichtig zu wissen, ob der eingebundene Header für eine Bibliotheksfunktionalität in den vordefinierten Pfaden des verwendeten Compilers steht, oder ob es eigener Inhalt ist, oder es sich um Zusatzbibliotheken handelt, deren Include-Verzeichnisse an anderen Stellen zu finden sind. Es sollte die Variante gewählt werden, bei der sich die Headerdatei vom Präprozessor am schnellsten finden lässt.

Symbol kept vote.svg
Tipp

Verwenden Sie für Verweise auf Ihre eigenen Includes immer eine relative Pfadangabe mit normalen Slashes '/' als Verzeichnisseparator, damit Sie Ihre Quellcodeverzeichnisse auch an anderen Stellen und in anderen Entwicklungsumgebungen schneller kompiliert bekommen. Eine Verzeichnisangabe wie "/home/ichuser/code/cpp/projekt/zusatzlib/bla.h" oder "c:\users\manni\Eigene Dateien\code\cpp\projekt\zusatzlib\bla.h" ist sehr unangenehm und sorgt für große Verwirrung. Schreiben Sie es nun in "../zusatzlib/bla.h" um, können Sie später Ihr gesamtes Projekt leichter in anderen Pfaden kompilieren und sparen sich selbst und Ihrem Präprozessor einiges an Ärger und Verwirrung.

#define und #undef[Bearbeiten]

#define belegt eine Textsubstitution mit dem angegebenen Wert, z.B.:

Nuvola-inspired-terminal.svg
1 #define BEGRUESSUNG "Hallo Welt!\n"
2 cout << BEGRUESSUNG;

Makros sind auch möglich, z.B.:

Nuvola-inspired-terminal.svg
1 #define ADD_DREI(x, y, z) x + y + z + 3
2 int d(1), e(20), f(4), p(0);
3 p = ADD_DREI(d, e, f);              // p = d + e + f + 3;

Diese sind allerdings mit Vorsicht zu genießen, da durch die strikte Textsubstitution des Präprozessors ohne jegliche Logikprüfungen des Compilers fatale Fehler einfließen können, und sollten eher durch (inline)-Funktionen, Konstanten oder sonstige Konzepte realisiert werden. Manchmal lässt es sich allerdings nicht umgehen, ein Makro (weiter) zu verwenden. Beachten Sie bitte immer, dass es sich hierbei um Anweisungen an eine Rohquelltextvorbearbeitungsstufe handelt und nicht um Programmcode.

Da anstelle von einfachen Werten auch komplexere Terme als Parameter für das Makro verwendet werden können und das Makro selbst auch in einen Term eingebettet werden kann, sollten immer Klammern verwendet werden. Bsp.:

Nuvola-inspired-terminal.svg
1 #define MUL_NOK(x, y) x*y
2 #define MUL_OK(x, y) ((x)*(y))
3 
4 resultNok = a*MUL_NOK(b, c + d); // a*b*c + d       = a*b*c + d      <= falsch
5 resultOk = a*MUL_OK(b, c + d);   // a*((b)*(c + d)) = a*b*c + a*b*d  <= richtig

#undef löscht die Belegung einer Textsubstitution/Makro, z.B.:

Nuvola-inspired-terminal.svg
1 #undef BEGRUESSUNG
Symbol redirect vote.svg
Buchempfehlung

Bitte denken Sie bei allen Ideen, auf die Sie nun kommen, dass Sie fast immer eine Alternative zur Makroprogrammierung haben. Verwenden Sie diese Makros vor allem als Zustandsspeicher für den Präprozessordurchlauf an sich und nicht um Funktionalität Ihres Programms zu erweitern.

Einer statischen, konstanten Definition oder Templatefunktionen ist immer der Vorzug zu geben.

#[Bearbeiten]

Der #-Ausdruck erlaubt es, den einem Makro übergebenen Parameter als Zeichenkette zu interpretieren:

Nuvola-inspired-terminal.svg
1 #define STRING(s) #s
2 cout << STRING(Test) << endl;

Das obige Beispiel gibt also den Text "Test" auf die Standard-Ausgabe aus.

##[Bearbeiten]

Der ##-Ausdruck erlaubt es, in Makros definierte Strings innerhalb des Präprozessorlaufs miteinander zu kombinieren, z.B.:

Nuvola-inspired-terminal.svg
1 #define A "Hallo"
2 #define B "Welt"
3 #define A_UND_B A##B

Als Resultat beinhaltet die Konstante A_UND_B die Zeichenkette "HalloWelt". Der ##-Ausdruck verbindet die Namen der symbolischen Konstanten, nicht deren Werte. Ein weiteres Anwendungsbeispiel:

Nuvola-inspired-terminal.svg
 1 #define MAKE_CLASS( NAME )       \
 2 class NAME                       \
 3 {                                \
 4   public:                        \
 5     static void Init##NAME() {}; \
 6 };
 7 ...
 8 MAKE_CLASS( MyClass )
 9 ...
10 MyClass::InitMyClass();

#if, #ifdef, #ifndef, #else, #elif und #endif[Bearbeiten]

Direktiven zur bedingten Übersetzung, d.h. Programmteile werden entweder übersetzt oder ignoriert.

Nuvola-inspired-terminal.svg
 1 #if ''Ausdruck1''
 2 // Programmteil 1
 3 #elif ''Ausdruck2''
 4 // Programmteil 2
 5 /* 
 6    ...
 7  */
 8 #else
 9 // Programmteil sonst
10 #endif

Die Ausdrücke hinter #if bzw. #elif werden der Reihe nach bewertet, bis einer von ihnen einen von 0 verschiedenen Wert liefert. Dann wird der zugehörige Programmteil wie üblich verarbeitet, die restlichen werden ignoriert. Ergeben alle Ausdrücke 0, wird der Programmteil nach #else verarbeitet, sofern vorhanden.

Als Bedingungen sind nur konstante Ausdrücke erlaubt, d.h. solche, die der Präprozessor tatsächlich auswerten kann. Definierte Makros werden dabei expandiert, verbleibende Namen durch 0L ersetzt. Insbesondere dürfen keine Zuweisungen, Funktionsaufrufe, Inkrement- und Dekrementoperatoren vorkommen. Das spezielle Konstrukt

Nuvola-inspired-terminal.svg
1 #defined ''Name''

wird durch 1L bzw. 0L ersetzt, je nachdem, ob das Makro Name definiert ist oder nicht.

#ifdef ist eine Abkürzung für #if defined.

#ifndef ist eine Abkürzung für #if ! defined.

Beispiel: Nehmen wir an, dass Sie Daten in zusammengesetzten Strukturen immer an 4-Byte Grenzen ausrichten wollen. Verschiedene Compiler bieten hierfür verschiedene compilerspezifische Pragma-Direktiven. Da diese Konfiguration nicht im C++-Standard definiert ist, kann nicht sichergestellt werden, dass es eine allgemeingültige Anweisung hierfür gibt. Sie definieren daher mit #define in einer Headerdatei, die überall eingebunden ist, welchen Compiler Sie verwenden. Z.B. mit #define FLAG_XY_COMPILER_SUITE in einer Datei namens "compiler-config-all.hpp". Das gibt Ihnen die Möglichkeit, an Stellen, an denen Sie compilerspezifisches Verhalten verwenden wollen, dieses auch auszuwählen.

Nuvola-inspired-terminal.svg
1 #include "compiler-config-all.hpp"
2 #ifdef WIN32
3   #pragma pack(4)
4 #elif USING_GCC
5   #pragma align=4
6 #elif FLAG_XY_COMPILER_SUITE
7   #pragma ausrichtung(byte4)
8 #endif

#error und #warning[Bearbeiten]

#error gibt eine Fehlermeldung während des Compilerlaufs aus und bricht den Übersetzungsvorgang ab, z.B.:

Nuvola-inspired-terminal.svg
1 #error Dieser Quellcode-Abschnitt sollte nicht mit compiliert werden!

#warning ist ähnlich wie #error, mit dem Unterschied, dass das Kompilieren nicht abgebrochen wird. Es ist allerdings nicht Teil von ISO-C++, auch wenn die meisten Compiler es unterstützen. Meistens wird es zum Debuggen eingesetzt:

Nuvola-inspired-terminal.svg
1 #warning Dieser Quellcode-Abschnitt muss noch überarbeitet werden.

#line[Bearbeiten]

Setzt den Compiler-internen Zeilenzähler auf den angegebenen Wert, z.B.:

Nuvola-inspired-terminal.svg
1 #line 100

#pragma[Bearbeiten]

Das #pragma-Kommando ist vorgesehen, um eine Reihe von Compiler-spezifischen Anweisungen zu implementieren, z.B.:

Nuvola-inspired-terminal.svg
1 #pragma comment(lib, "advapi32.lib")

Kennt ein bestimmter Compiler eine Pragma-Anweisung nicht, so gibt er üblicherweise eine Warnung aus, ignoriert diese nicht für ihn vorgesehene Anweisung aber ansonsten.

Um z.B. bei MS VisualC++ eine "störende" Warnung zu unterdrücken, gibt man folgendes an:

Nuvola-inspired-terminal.svg
1 #pragma warning( disable: 4010 ) // 4010 ist Nummer der Warnung

Vordefinierte Präprozessor-Variablen[Bearbeiten]

  • __LINE__: Zeilennummer
  • __FILE__: Dateiname
  • __DATE__: Datum des Präprozessoraufrufs im Format Monat/Tag/Jahr
  • __TIME__: Zeit des Präprozessoraufrufs im Format Stunden:Minuten:Sekunden
  • __cplusplus: Ist nur definiert, wenn ein C++-Programm verarbeitet wird


Headerdateien[Bearbeiten]

Sie haben bereits mit 2 Headerdateien Bekanntschaft gemacht: iostream und string. Beide sind so genannte Standardheader, das heißt, sie sind in der Standardbibliothek jedes Compilers enthalten.

Was ist eine Headerdatei?[Bearbeiten]

Headerdatei.svg

Headerdateien sind gewöhnliche C++-Dateien, die im Normalfall Funktionsdeklarationen und Ähnliches enthalten. Sicher werden Sie sich erinnern: Deklarationen machen dem Compiler bekannt, wie etwas benutzt wird. Wenn Sie also eine Headerdatei einbinden und darin eine Funktionsdeklaration steht, dann weiß der Compiler wie die Funktion aufgerufen wird. Der Compiler weiß zu diesem Zeitpunkt nicht, was die Funktion tut, aber das ist auch nicht nötig um sie aufrufen zu können.

Das Einbinden einer Headerdatei erfolgt über die Präprozessordirektive #include. Der Code in der Datei die mit include referenziert wird, wird vom Präprozessor einfach an der Stelle eingefügt, an der das include stand.

In der nebenstehenden Darstellung wird die Headerdatei mal2.hpp von den Quelldateien main.cpp und mal2.cpp eingebunden. Um dieses Beispiel zu übersetzen, müssen die Dateien alle im gleichen Verzeichnis liegen. Sie übergeben die Quelldateien an einen Compiler und rufen anschließend den Linker auf, um die entstandenen Objektdateien zu einem Programm zu binden.

Symbol opinion vote.svg
Hinweis

Falls Sie mit der GCC arbeiten, beachten Sie bitte, dass g++ sowohl Compiler als auch Linker ist. Wenn Sie nur die beiden Quelldateien ohne weitere Parameter angeben, wird nach dem Kompilieren automatisch gelinkt. Der zweite Aufruf entfällt somit.

Einige Informationen zu Compilern und Linkern finden Sie übrigens im Kapitel Compiler.

Namenskonventionen[Bearbeiten]

Übliche Dateiendungen für C++-Quelltexte sind „.cpp“ oder „.cc“. Headerdateien haben oft die Endungen „.hpp“, „.hh“ und „.h“. Letztere ist allerdings auch die gebräuchlichste Dateiendung für C-Header, weshalb zugunsten besserer Differenzierung empfohlen wird, diese nicht zu benutzen.

Die Standardheader von C++ haben überhaupt keine Dateiendung, wie Sie vielleicht schon anhand der beiden Headerdateien iostream und string erraten haben. In der Anfangszeit von C++ endeten Sie noch auf „.h“, inzwischen ist diese Notation aber nicht mehr gültig, obwohl sie immer noch von vielen Compilern unterstützt wird. Der Unterschied zwischen „iostream“ und „iostream.h“ besteht darin, dass in ersterer Headerdatei alle Deklarationen im Standardnamespace std vorgenommen werden.

Prinzipiell kommt es nicht darauf an, welche Dateiendungen Sie Ihren Dateien geben, dennoch ist es sinnvoll, eine übliche Endung zu verwenden, wenn auch nur, um einer möglichen Verwechslungsgefahr vorzubeugen. Wenn Sie sich einmal für eine Dateiendung entschieden haben, ist es vorteilhaft, darin eine gewisse Konstanz zu bewahren, nicht nur vielleicht aus Gemütlichkeit und Zeiteinsparnis, sondern auch im Sinne des schnellen Wiederfindens. Einige Beispiele für Headerdateiendungen finden Sie, wenn Sie sich einfach mal einige weitverbreite C++-Bibliotheken ansehen. Boost verwendet „.hpp“, wxWidgets nutzt „.h“ und Qt orientiert sich an der Standardbibliothek, hat also gar keine Dateiendung.

Schutz vor Mehrfacheinbindung[Bearbeiten]

Da Headerdateien oft andere Headerdateien einbinden, kann es leicht passieren, dass eine Headerdatei mehrfach eingebunden wird. Da viele Header nicht nur Deklarationen, sondern auch Definitionen enthalten, führt dies zu Compiler-Fehlermeldungen, da innerhalb einer Übersetzungseinheit ein Name stets nur genau einmal definiert werden darf (mehrfache Deklarationen, die keine Definitionen sind, sind jedoch erlaubt). Um dies zu vermeiden, wird der Präprozessor verwendet. Am Anfang der Headerdatei wird ein Präprozessor-ifndef ausgeführt, das prüft, ob ein Symbol nicht definiert wurde, ist dies der Fall, wird das Symbol definiert. Am Ende der Headerdatei wird die Abfrage mit einem Präprozessor-endif wieder beendet.

Nuvola-inspired-terminal.svg

mal2.hpp


1 #ifndef _mal2_hpp_
2 #define _mal2_hpp_
3 
4 int mal2(int wert);
5 
6 #endif

Das Symbol wird üblicherweise aus dem Dateinamen des Headers abgeleitet. In diesem Fall wurde der Punkt durch einen Unterstrich ersetzt und ein weiterer Unterstrich vor und nach dem Dateinamen eingefügt. Wenn der Präprozessor nun die Anweisung bekommt, diese Datei in eine andere einzubinden, wird er das anstandslos tun. Findet er eine zweite Anweisung, die Datei einzubinden, wird er alles von #ifndef bis #endif überspringen, da das Symbol _mal2_hpp_ ja nun bereits definiert wurde.

Sie können sich eine beliebige Methode zum Generieren von Symbolen ausdenken. Da es schnell passieren kann, dass Sie eine Bibliothek verwenden, in der Headerdateien enthalten sind, welche Sie auch in ihrem eigenen Projekt bereits verwenden, ist es jedoch empfehlenswert an dieser Stelle nicht mit Zeichen zu geizen. Eine mögliche Variante ist beispielsweise neben dem Dateinamen auch noch den Projektnamen zu verwenden und eventuell auch noch eine feste Zeichenfolge, um das Symbol unmissverständlich als Mehrfacheinbindungsschutz zu kennzeichnen. Das könnte dann etwa so aussehen:

_Projektname_Dateiname_Dateiendung_INCLUDED_
Symbol kept vote.svg
Tipp

Mehr Informationen über Präprozessor-Anweisungen finden Sie im Kapitel Vorarbeiter des Compilers.

Inline-Funktionen[Bearbeiten]

Im Kapitel „Prozeduren und Funktionen“ haben Sie bereits erfahren was eine Inline-Funktion ist. Das Schlüsselwort inline empfiehlt dem Compiler, beim Aufruf einer Funktion den Funktionsrumpf direkt durch den Funktionsaufruf zu ersetzen, wodurch bei kurzen Funktionen die Ausführungsgeschwindigkeit gesteigert werden kann. Es bewirkt aber noch mehr. Normalerweise darf eine Definition immer nur einmal gemacht werden. Da für das Inlinen einer Funktion aber die Definition bekannt sein muss, gibt es für Inline-Funktionen eine Ausnahme: Sie dürfen beliebig oft definiert werden, solange alle Definitionen identisch sind. Deshalb dürfen (und sollten) Inline-Funktionen in den Headerdateien definiert werden, ohne dass sich der Linker später über eine mehrfache Definition in verschiedenen Objektdateien beschweren wird.

Symbol opinion vote.svg
Hinweis

Inline-Funktionen dürfen auch in cpp-Dateien definiert werden. Allerdings können sie dann auch nur innerhalb der Objektdatei, die aus der cpp-Datei erzeugt wird, geinlinet werden und das ist in aller Regel nicht beabsichtigt.


Das Klassenkonzept[Bearbeiten]

In einem späteren Abschnitt werden Sie etwas über objektorientierte Programmierung erfahren. Die notwendige Basis dafür werden wir in diesem Abschnitt erarbeiten. Sie haben inzwischen einiges über die verschiedenen Basisdatentypen gelernt und auch erfahren, wie Sie diese Daten mithilfe von Funktionen manipulieren können. Im Prinzip könnten Sie mit diesen Mitteln bereits jedes beliebige Programm schreiben. Allerdings werden Programme, die mit diesen Mitteln geschrieben wurden oft unübersichtlich, sobald eine gewisse Größe überschritten wird. Aus diesem Grund wurde ein neues Konzept erdacht, das für mehr Übersicht sorgt. Anstatt einfach Daten (Variablen) zu haben, die von Funktionen manipuliert werden, fasst man logisch zusammengehörende Daten und die darauf arbeitenden Funktionen zu einem neuen Konstrukt zusammen. Dieses Konstrukt nennt sich „Klasse“ und das Zusammenfassen wird als Kapselung bezeichnet.

Eine Klasse hat üblicherweise einen Namen und besteht aus Variablen und Funktionen, welche als Klassenmember (zu deutsch etwa Mitglieder) bezeichnet werden. Ein Funktionsmember bezeichnet man auch als Methode der Klasse. Ein wesentliche Vorteil der Kapselung besteht darin, dass ein Nutzer der Klasse nicht wissen muss, wie die Klasse intern arbeitet. Andererseits können Sie die konkrete Implementierung der Klasse jederzeit ändern, ohne dass der Code, in dem die Klasse verwendet wird, geändert werden muss. Lediglich bei Schnittstellenänderungen muss auch Code außerhalb der Klasse angepasst werden. Als Schnittstelle bezeichnet man die Member der Klasse, die von außen sichtbar sind. Dies werden meistens eine Reihe von Methoden sein, während Variablen nur sehr selten direkt sichtbar sein sollten.

Eine Klasse ist ein benutzerdefinierter Datentyp. Somit können Sie also, genau wie bei einem Basisdatentyp, Variablen vom Typ der Klasse (= deren Name) erstellen. Eine Variable vom Typ einer Klasse beinhaltet alle in der Klasse deklarierten Variablen. Somit verbraucht eine Klassenvariable so viel Speicherplatz, wie die Variablen, die in ihr deklariert wurden. Natürlich hat der Übersetzer hier einige Freiräume, sodass Sie nicht einfach davon ausgehen können, dass eine Klassenvariable genau so viel Speicherplatz belegt, wie die Summe ihrer Variablenmember. Wenn der Übersetzer es aus Optimierungsgründen für sinnvoll hält, etwas mehr Speicherplatz zu nutzen, um etwa die internen Variablen so im Speicher auszurichten, dass auf sie schnell zugegriffen werden kann, darf er dies tun. Wenn Sie die genaue Größe wissen möchten, die eine Variable einer Klasse im Speicher belegt, können Sie den sizeof-Operator auf die Klasse oder eine Variable vom Typ der Klasse anwenden.

Der Inhalt einer solchen Variable ist ein „Objekt“ der Klasse. Ebenso wie es vom Typ 'int' viele Variablen mit unterschiedlichen Werten in einem Programm geben kann, so kann es viele Objekte mit unterschiedlichen Werten vom selben Klassen-Typ in einem Programm geben.

Eine Klasse ist wie ein Bauplan für Objekte. Klassen haben zwei spezielle Methoden, die beim Erstellen bzw. Zerstören eines Objektes vom Typ der Klasse aufgerufen werden. Erstere bezeichnet man als Konstruktor und die zweite als Destruktor der Klasse.

Ähnlich wie Funktionen ihre lokalen Variablen haben können, auf die „von außen“ nicht zugegriffen werden kann, kann es innerhalb einer Klasse verschiedene Sichtbarkeitsbereiche geben, die darüber entscheiden, ob eine Membervariable nur innerhalb von Methoden der Klasse oder auch von außerhalb verwendet werden kann. Diese Sichtbarkeitsbereiche entscheiden entsprechend darüber, welche Membervariablen zur Schnittstelle gehören.

Es gibt einige allgemeine Operatoren für Klassen und Objekte. Es ist möglich, einige dieser Operatoren für eine Klasse zu überladen, sodass diese dann auf Klassenobjekte angewendet werden können.

Das waren jetzt wieder sehr viele Informationen auf wenig Raum, aber machen Sie sich keine Sorgen, wenn Sie sich nicht alles merken konnten: In den nächsten Kapiteln wird auf die verschiedenen Eigenschaften von Klassen noch näher eingegangen, sodass Sie die Gedanken dahinter nachvollziehen können.

Ein eigener Datentyp[Bearbeiten]

Nun wird es aber Zeit, dass wir auch mal eine eigene Klasse schreiben. Das folgende Beispiel soll die prinzipielle Arbeitsweise einer Klasse demonstrieren.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 class Auto{
 4 public:
 5     Auto(int tankgroesse, float tankinhalt, float verbrauch);
 6 
 7     void info()const;
 8 
 9     void fahren(int km);
10     void tanken(float liter);
11 
12 private:
13     int   tankgroesse_;
14     float tankinhalt_;
15     float verbrauch_;
16 };
17 
18 Auto::Auto(int tankgroesse, float tankinhalt, float verbrauch):
19     tankgroesse_(tankgroesse),
20     tankinhalt_(tankinhalt),
21     verbrauch_(verbrauch)
22     {}
23 
24 void Auto::info()const{
25     std::cout << "In den Tank passen " << tankgroesse_ << " Liter Treibstoff.\n";
26     std::cout << "Aktuell sind noch " << tankinhalt_ << " Liter im Tank.\n";
27     std::cout << "Der Wagen verbraucht " << verbrauch_ << " Liter pro 100 km.\n";
28     std::cout << std::endl;
29 }
30 
31 void Auto::fahren(int km){
32     std::cout << "Fahre " << km << " km.\n";
33     tankinhalt_ -= verbrauch_*km/100;
34 
35     if(tankinhalt_ < 0.0f){
36         tankinhalt_ = 0.0f;
37 
38         std::cout << "Mit dem aktuellen Tankinhalt schaffen Sie die Fahrt leider nicht.\n";
39         std::cout << "Der Wagen ist unterwegs liegengeblieben, Zeit zu tanken!\n";
40     }
41 
42     std::cout << std::endl;
43 }
44 
45 void Auto::tanken( float liter ) {
46     std::cout << "Tanke " << liter << " Liter.\n";
47     tankinhalt_ += liter;
48 
49     if( tankinhalt_ > tankgroesse_ ) {
50         tankinhalt_ = tankgroesse_;
51 
52         std::cout << "Nicht so übereifrig! Ihr Tank ist jetzt wieder voll.\n";
53         std::cout << "Sie haben aber einiges daneben gegossen!\n";
54     }
55 
56     std::cout << std::endl;
57 }

Diese Klasse nutzt vieles, was Sie im Laufe dieses Abschnittes noch kennenlernen werden. Für den Moment sollten Sie wissen, dass diese Klasse drei verschiedene Daten beinhaltet. Diese Daten sind die drei Variablen, deren Namen auf einen Unterstrich (_) enden. Vier Funktionen arbeiten auf diesen Daten.

Sie haben nun gesehen, wie die Klasse aufgebaut ist, und in den folgenden Kapiteln wird dieser Aufbau genauer erläutert. Jetzt sollen Sie jedoch erst einmal den Vorteil einer Klasse verstehen, denn um eine Klasse zu benutzen, müssen Sie keine Ahnung haben, wie diese Klasse intern funktioniert.

Nuvola-inspired-terminal.svg


 1 int main(){
 2     Auto wagen(80, 60.0f, 5.7f);
 3 
 4     wagen.info();
 5 
 6     wagen.tanken(12.4f);
 7     wagen.info();
 8 
 9     wagen.fahren(230);
10     wagen.info();
11 
12     wagen.fahren(12200);
13     wagen.info();
14 
15     wagen.tanken(99.0f);
16     wagen.info();
17 }
Crystal Clear app kscreensaver.svg
Ausgabe:
 1 In den Tank passen 80 Liter Treibstoff.
 2 Aktuell sind noch 60 Liter im Tank.
 3 Der Wagen verbraucht 5.7 Liter pro 100 km.
 4 
 5 Tanke 12.4 Liter.
 6 
 7 In den Tank passen 80 Liter Treibstoff.
 8 Aktuell sind noch 72.4 Liter im Tank.
 9 Der Wagen verbraucht 5.7 Liter pro 100 km.
10 
11 Fahre 230 km.
12 
13 In den Tank passen 80 Liter Treibstoff.
14 Aktuell sind noch 59.29 Liter im Tank.
15 Der Wagen verbraucht 5.7 Liter pro 100 km.
16 
17 Fahre 12200 km.
18 Mit dem aktuellen Tankinhalt schaffen Sie die Fahrt leider nicht.
19 Der Wagen ist unterwegs liegengeblieben, Zeit zu tanken!
20 
21 In den Tank passen 80 Liter Treibstoff.
22 Aktuell sind noch 0 Liter im Tank.
23 Der Wagen verbraucht 5.7 Liter pro 100 km.
24 
25 Tanke 99 Liter.
26 Nicht so übereifrig! Ihr Tank ist jetzt wieder voll.
27 Sie haben aber einiges daneben gegossen!
28 
29 In den Tank passen 80 Liter Treibstoff.
30 Aktuell sind noch 80 Liter im Tank.
31 Der Wagen verbraucht 5.7 Liter pro 100 km.

In der ersten Zeile von main() wird ein Auto-Objekt mit dem Namen wagen erstellt. Anschließend werden Methoden dieses Objekts aufgerufen, um die Daten darin zu verwalten. Von den Daten innerhalb des Objekts kriegen Sie beim Arbeiten mit dem Objekt überhaupt nichts mit. Lediglich die Ausgabe verrät, dass die drei Methoden untereinander über diese Daten „kommunizieren“.

Die vierte Methode (jene, die mit dem Klassennamen identisch ist) wird übrigens auch aufgerufen. Gleich in der ersten Zeile von main() wird diese Methode genutzt, um das Objekt zu erstellen. Es handelt sich also um den Konstruktor der Klasse.


Erstellen und Zerstören[Bearbeiten]

In C++-Klassen gibt es zwei besondere Arten von Methoden: Konstruktoren und den Destruktor. Ein Konstruktor wird beim Anlegen eines Objektes ausgeführt, der Destruktor vor der „Zerstörung“ desselben. Der Name des Konstruktors ist immer gleich dem Klassennamen, der Destruktor entspricht ebenfalls dem Klassennamen, jedoch mit einer führenden Tilde (~).

Konstruktoren und Destruktoren haben keinen Rückgabetyp, auch nicht void. Der Konstruktor kann nicht als Methode aufgerufen werden, beim Destruktor ist dies hingegen möglich (aber nur selten nötig, dazu später mehr).

Konstruktor[Bearbeiten]

Jede Klasse hat einen oder mehrere Konstruktoren. Ein solcher Konstruktor dient zur Initialisierung eines Objektes. Im Folgenden wird eine Klasse Bruch angelegt, die über den Konstruktor die Membervariablen zaehler_ und nenner_ initialisiert.

Nuvola-inspired-terminal.svg
 1 class Bruch{
 2 public:
 3     Bruch(int z, int n):
 4         zaehler_(z), // Initialisierung von zaehler_
 5         nenner_(n)   // Initialisierung von nenner_
 6         {}
 7 
 8 private:
 9     int zaehler_;
10     int nenner_;
11 };
12 
13 int main(){
14     Bruch objekt(7, 10); // Initialisierung von objekt
15 }

Wie Sie sehen, ist der Methodenrumpf von Bruch::Bruch leer. Die Initialisierung findet in den beiden Zeilen über dem Rumpf statt. Nach dem Prototyp wird ein Doppelpunkt geschrieben, darauf folgt eine Liste der Werte, die initialisiert werden sollen. Vielleicht erinnern Sie sich noch, dass es zur Initialisierung zwei syntaktische Varianten gibt:

Nuvola-inspired-terminal.svg
1 int wert(8);
2 int wert = 8;

Innerhalb der Initialisierungsliste ist nur die erste Variante zulässig. Auch in der Hauptfunktion main() findet eine Initialisierung statt. Hier könnte die zweite Variante verwendet werden, jedoch besitzt der Konstruktor zwei Parameter, daher ist die Variante mit dem Gleichheitszeichen nicht sofort offensichtlich. Dieses Thema wird am Ende des Kapitels genauer besprochen, da zum Verständnis dessen ein wenig Hintergrundwissen nötig ist, das im Verlauf des Kapitels vermittelt wird.

Symbol opinion vote.svg
Hinweis

Beachten Sie, dass die Initialisierung der Variablen einer Klasse in der Reihenfolge erfolgt, in der sie in der Klasse deklariert wurden. Die Initialisierungsreihenfolge ist unabhängig von der Reihenfolge, in der sie in der Initialisierungsliste angegeben wurden. Viele Compiler warnen, wenn man so etwas macht, da derartiger Code möglicherweise nicht das tut, was man erwartet.

Natürlich ist es wie bei Funktionen möglich und in der Regel zu empfehlen, die Methodendeklaration von der Methodendefinition zu trennen. Die Definition sieht genau so aus, wie bei einer normalen Funktion. Der einzige auffällige Unterschied besteht darin, dass dem Methodennamen der Klassenname vorangestellt wir