C++ mit Visual Studio 2019

Richard Kaiser

C++ mit Visual Studio 2019C++17 für Studierende und erfahrene Programmierer

Prof. Richard Kaiser Tübingen, Deutschland

ISBN 978-3-662-59475-9 ISBN 978-3-662-59476-6 (eBook)https://doi.org/10.1007/978-3-662-59476-6

Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.

© Springer-Verlag GmbH Deutschland, ein Teil von Springer Nature 2021Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Jede Verwertung, die nicht ausdrücklich vom Urheberrechtsgesetz zugelassen ist, bedarf der vorherigen Zustimmung des Verlags. Das gilt insbesondere für Vervielfältigungen, Bearbeitungen, Übersetzungen, Mikroverfilmungen und die Einspeicherung und Verarbeitung in elektronischen Systemen.Die Wiedergabe von allgemein beschreibenden Bezeichnungen, Marken, Unternehmensnamen etc. in diesem Werk bedeutet nicht, dass diese frei durch jedermann benutzt werden dürfen. Die Berechtigung zur Benutzung unterliegt, auch ohne gesonderten Hinweis hierzu, den Regeln des Markenrechts. Die Rechte des jeweiligen Zeicheninhabers sind zu beachten.Der Verlag, die Autoren und die Herausgeber gehen davon aus, dass die Angaben und Informationen in diesem Werk zum Zeitpunkt der Veröffentlichung vollständig und korrekt sind. Weder der Verlag, noch die Autoren oder die Herausgeber übernehmen, ausdrücklich oder implizit, Gewähr für den Inhalt des Werkes, etwaige Fehler oder Äußerungen. Der Verlag bleibt im Hinblick auf geografische Zuordnungen und Gebietsbezeichnungen in veröffentlichten Karten und Institutionsadressen neutral.

Planung: Martin BörgerSpringer Vieweg ist ein Imprint der eingetragenen Gesellschaft Springer-Verlag GmbH, DE und ist ein Teil von Springer Nature.Die Anschrift der Gesellschaft ist: Heidelberger Platz 3, 14197 Berlin, Germany

Für

Daniel, Alex, Kathy

Emelie, Jonathan, Maximilian, Leonardund Matilda

Vorwort

C++ hat sich in den letzten Jahren rasant entwickelt: Die Neuerungen von C++11, C++14,C++17 und C++20 haben viele Verbesserungen und neue Möglichkeiten gebracht. Vieles,was 2010 noch gut und empfehlenswert war, kann heute besser und sicherer gemacht werden.

Das merkt man als Buchautor und Trainer, der diese ganze Entwicklung begleitet hat,besonders deutlich: Vieles, was man früher einmal geschrieben hat, sollte man heute andersmachen. Zwar würde es immer noch kompiliert werden. Aber es ist kein modernes C++ mehr,das dem aktuellen Stand der Technik entspricht und alle Vorteile nutzt.

Dieses Buch stellt C++ auf dem Stand von Visual Studio 2019 im Mai 2020 vor. Das ist nichtnur der Umfang von C++17, sondern auch schon ein Teil von C++20. Auch wenn Module,concepts, std::span und der dreifache Vergleichsoperator <=> noch nicht vollständigverfügbar sind, kann man die wichtigsten Vorteile schon jetzt zeigen. Wenn der Leser diesesBuch dann in einem oder zwei Jahren in der Hand oder am Bildschirm hat, sieht er schon,wie man sie einsetzen kann.

Dieses Buch entstand einerseits aus meinen Vorlesungen an der Dualen Hochschule Lörrachund andererseits aus zahlreichen Seminaren für Firmen, die sich an Software-Entwicklerrichten, die C++ professionell einsetzen. Dementsprechend richtet es sich einerseits anStudierende ohne Vorkenntnisse. Die Lernziele für diese Gruppe sind:

– Modernes C++ auf dem Stand von 2020 zu lernen. C++ ist nach wie vor eine der amhäufigsten eingesetzten Programmiersprachen.

– Programmieren zu lernen, d.h. Programme zu schreiben, die konkrete, vorgegebene Auf-gaben lösen. Das ist nur mit viel Übung möglich. Programmieren lernt man nur, indemman es tut. Deshalb enthält dieses Buch auch viele Übungsaufgaben. Es ist unerlässlich,zahlreiche Aufgaben selbständig zu lösen (das müssen nicht die aus diesem Buch sein).Der Schwierigkeitsgrad der Aufgaben reicht von einfachen Wiederholungen des Textesbis zu kleinen Projektchen, die ein gewisses Maß an selbständiger Arbeit erfordern. DieLösungen der Aufgaben findet man auf https://www.rkaiser.de.

– Eine moderne Entwicklungsumgebung kennen- und einsetzen lernen. Visual Studio istdas in der Industrie wohl am häufigsten eingesetzte Werkzeug zur Software-Entwicklung.

– Man hört immer wieder, dass C++ zu schwierig ist, um damit das Programmieren zulernen. Dieses Buch soll ein in vielen Jahren erprobtes Gegenargument zu dieser Meinungsein. Damit will ich die Komplexität von C++ nicht abstreiten. Aber wer C++ kann, findetsich leicht mit C#, Java usw. zurecht. Der umgekehrte Weg ist meist schwieriger.

viii

Dieses Buch richtet sich aber ebenso an professionelle Software-Entwickler mit einer jahre-langen C++-Praxis. Viele C++-Neuerungen machen elementare Sprachkonzepte einfacherund sicherer. Dazu kommen anspruchsvollere Neuerungen, die bessere und effizientereLösungen ermöglichen, die so vor einigen Jahren noch nicht möglich waren. Sowohl dieeinfachen als auch die anspruchsvolleren Möglichkeiten haben sich in der industriellen Praxisoft noch nicht herumgesprochen. Oft wird mit C++ noch wie vor 30 Jahren mit C program-miert. Das ist fehleranfällig, unnötig aufwendig und verschenkt Vorteile und Möglichkeiten.

– Für professionelle Entwickler soll dieses Buch einen nahezu vollständigen Überblick überC++17 geben und die Sprachelemente so vorstellen, dass sie in der praktischen Arbeiteingesetzt werden können. Die Erfahrungen aus meinen Firmenseminaren geben mir dieHoffnung, dass die allermeisten Themen abgedeckt sind, die im industriellen Einsatznotwendig sind.

– Da ausschließlich Standard-C++ behandelt wird, ist dieses Buch nicht auf Visual Studiobeschränkt. Praktisch alle Ausführungen gelten für jeden standardkonformen C++-Compiler (gcc, Intel, Embarcadero usw.).

– Das moderne C++ bietet auch Programmierern von eingebetteten Anwendungen vieleVorteile gegenüber dem in diesem Anwendungsbereich verbreiteten C. Mit dem moder-nen C++ gibt es noch weniger Gründe als vorher, solche Anwendungen in C zu schreiben.

– Professionelle Entwickler sollen sich nicht an den Übungsaufgaben stören. Sie habenschon genügend Aufgaben gemacht, sonst wären sie keine Profis geworden. Und außer-dem bietet das Tagesgeschäft genügend Übungsaufgaben.

Ich habe nicht nur versucht, die Sprachelemente anschaulich zu beschreiben, sondern auchKriterien dafür anzugeben, wann und wie man sie sinnvoll einsetzen kann. Viele Empfehlun-gen aus style guides (z.B. der C++ Core Guidelines, siehe Abschnitt 2.13) sind in den Texteingearbeitet, ohne dass explizit darauf hingewiesen wird.

Dieses Buch erscheint in zwei weitgehend identischen Ausgaben:

– In der vorliegenden Ausgabe werden reine Standard-C++-Programme geschrieben, d.h.ohne graphische Benutzeroberfläche. Alle Ein- und Ausgaben erfolgen über die Konsole.

– In der anderen Ausgabe „C++ mit Visual Studio 2019 und Windows-Forms-Anwen-dungen“ werden Programme mit einer grafischen Benutzeroberfläche geschrieben. AlleEin- und Ausgaben erfolgen über eine Windows-Benutzeroberfläche.

Der Unterschied zwischen den beiden Ausgaben ist meist nur, dass in „C++ mit Visual Studio2019 und Windows Forms Anwendungen“ Ein- und Ausgaben über ein Windows-Steuer-element (meist eine TextBox) erfolgen

textBox1->AppendText("Hello World");

während in „C++ mit Visual Studio 2019“ die Konsole verwendet wird:

cout << "Hallo world" << endl;

Dazu kommen noch etwa 100 Seiten mit unterschiedlichen Inhalten, da diese in Visual Studionur für den jeweiligen Anwendungstyp verfügbar sind. Die folgenden Themen sind nur in

ix

„C++ mit Visual Studio 2019“ enthalten: Multithreading (Kapitel 17), 15.10 parallele Algo-rithmen der Standardbibliothek, 2.13 C++ Core Guideline Checks, 11.2 polymorphe MemoryRessourcen (pmr,), Sprachelemente von C++20: 2.14 Module, 14.6 concepts, 4.2.4 std::span, 8.2.5 der dreifache Vergleichsoperator <=> usw.

Dagegen sind diese Themen nur in der Ausgabe für Windows Forms Anwendungen enthal-ten: „Steuerelemente für die Benutzeroberfläche“ und „C#/.NET Interoperabilität“ (Kapitel2 und 19).

Die vorliegende Ausgabe ist eine umfassende Überarbeitung meiner Bücher über C++ mitVisual Studio 2017. Obwohl sich die beiden Jahreszahlen im Titel nur um 2 unterscheiden,ist über die Hälfte komplett neu:

– Große Teile, die heute nicht mehr aktuell sind, wurden entfernt. Vieles wurde auf denaktuellen Stand des modernen C++ gebracht. Wichtige Erweiterungen kamen dazu.

– Eigentlich wollte ich den Umfang wieder auf ca. 800 Seiten begrenzen, um potenzielleLeser nicht schon allein durch das Gewicht und die Fülle des Stoffs abzuschrecken. Dasist mir aber trotz intensivster Bemühungen nicht gelungen.

Anregungen, Korrekturhinweise und Verbesserungsvorschläge sind willkommen. Bittesenden Sie diese an die Mail-Adresse auf meiner Internetseite www.rkaiser.de.

Bei meinen Seminarteilnehmern und Studenten bedanke ich mich für die zahlreichenAnregungen. Dem Team vom Springer-Verlag danke ich für die Unterstützung und Geduld.

Tübingen, im Juni 2020 Richard Kaiser

Inhalt

1 Die Entwicklungsumgebung .......................................................................... 11.1 Installation von Visual Studio für C++ Projekte ..................................................... 11.2 Ein erstes C++-Projekt .......................................................................................... 2

1.2.1 Ein Projekt für ein Standard-C++-Programm anlegen ...................................... 21.2.2 Ein- und Ausgaben über die Konsole ............................................................... 41.2.3 Fehler beim Kompilieren ................................................................................. 61.2.4 Den Quelltext auf Header-Dateien aufteilen ..................................................... 81.2.5 Ein Projekt für die Lösung der Übungsaufgaben .............................................. 91.2.6 An einem Projekt weiterarbeiten.................................................................... 101.2.7 Der Start des Compilers von der Kommandozeile Ө ...................................... 10

1.3 Der Quelltexteditor ............................................................................................. 111.3.1 Tastenkombinationen .................................................................................... 121.3.2 Intellisense .................................................................................................... 131.3.3 Die Formatierung des Quelltexts ................................................................... 141.3.4 Definitionen einsehen.................................................................................... 141.3.5 Symbole suchen ............................................................................................ 151.3.6 Namen umbenennen ...................................................................................... 161.3.7 Zeichenfolgen suchen und ersetzen ................................................................ 17

1.4 Kontextmenüs und Symbolleisten ....................................................................... 191.5 Online-Dokumentation ........................................................................................ 20

1.5.1 Die Microsoft-Dokumentation ....................................................................... 201.5.2 en.cppreference.com ..................................................................................... 23

1.6 Projekte und der Projektmappen-Explorer ........................................................... 231.6.1 Projekte, Projektdateien und Projektoptionen ................................................. 241.6.2 Projektmappen und der Projektmappen-Explorer ........................................... 25

1.7 Weiterführende Möglichkeiten Ө ........................................................................ 261.7.1 Navigieren .................................................................................................... 271.7.2 Code-Ausschnitte .......................................................................................... 281.7.3 Aufgabenliste ................................................................................................ 291.7.4 Der Objektkatalog und die Klassenansicht Ө ................................................. 291.7.5 Die Fenster von Visual Studio anordnen Ө .................................................... 301.7.6 Einstellungen für den Editor Ө ...................................................................... 30

1.8 Bereitstellung (Deployment) Ө ............................................................................ 31

xii Inhalt

2 Elementare Datentypen und Anweisungen ................................................. 332.1 Syntaxregeln ....................................................................................................... 332.2 Variablen und Bezeichner ................................................................................... 372.3 Ganzzahldatentypen ............................................................................................ 41

2.3.1 Die interne Darstellung von Ganzzahlwerten ................................................. 432.3.2 Ganzzahlliterale und ihr Datentyp ................................................................. 462.3.3 Typ-Inferenz: Implizite Typzuweisungen mit auto ......................................... 492.3.4 Initialisierungslisten und Konversionen ......................................................... 502.3.5 Zuweisungen und Standardkonversionen bei Ganzzahlausdrücken Ө ............. 512.3.6 Operatoren und die „üblichen arithmetischen Konversionen“ ......................... 542.3.7 Die Datentypen char und wchar_t ................................................................. 592.3.8 Der Datentyp bool ......................................................................................... 63

2.4 Kontrollstrukturen und Funktionen ...................................................................... 682.4.1 Die if- und die Verbundanweisung................................................................. 682.4.2 Die for-, die while- und die do-Schleife ......................................................... 722.4.3 Funktionen und der Datentyp void ................................................................. 762.4.4 Eine kleine Anleitung zum Erarbeiten der Lösungen ...................................... 802.4.5 Wert- und Referenzparameter ........................................................................ 842.4.6 Die Verwendung von Bibliotheken und Namensbereichen ............................. 842.4.7 Zufallszahlen ................................................................................................ 862.4.8 Default-Argumente ....................................................................................... 882.4.9 if und switch mit Variablendefinitionen ......................................................... 902.4.10 Programmierstil für Funktionen ..................................................................... 922.4.11 Rekursive Funktionen ................................................................................... 972.4.12 Die switch-Anweisung Ө ............................................................................. 1042.4.13 Bedingte Kompilation mit if constexpr Ө ..................................................... 1072.4.14 Die Sprunganweisungen goto, break und continue Ө ................................... 1082.4.15 Assembler-Anweisungen Ө ......................................................................... 110

2.5 Gleitkommadatentypen ..................................................................................... 1112.5.1 Die interne Darstellung von Gleitkommawerten........................................... 1112.5.2 Der Datentyp von Gleitkommaliteralen ....................................................... 1142.5.3 Standardkonversionen ................................................................................. 1152.5.4 Mathematische Funktionen.......................................................................... 122

2.6 Der Debugger, Tests und Ablaufprotokolle ........................................................ 1262.6.1 Der Debugger ............................................................................................. 1272.6.2 Der Debugger – Weitere Möglichkeiten Ө ................................................... 1302.6.3 CPU Auslastung beobachten mit dem Leistungs-Profiler Ө .......................... 1352.6.4 Speicherauslastung beobachten mit dem Leistungs-Profiler Ө ...................... 1362.6.5 Systematisches Testen ................................................................................. 1382.6.6 Unittests: Funktionen, die Funktionen testen ................................................ 1442.6.7 Ablaufprotokolle ......................................................................................... 1482.6.8 Symbolische Ablaufprotokolle .................................................................... 152

2.7 Konstanten........................................................................................................ 1572.7.1 Laufzeitkonstanten mit const ....................................................................... 1602.7.2 Compilezeit-Konstanten mit constexpr ........................................................ 1612.7.3 constexpr Funktionen .................................................................................. 1632.7.4 static_assert und Unittests zur Compilezeit ................................................. 165

2.8 Kommentare ..................................................................................................... 166

Inhalt xiii

2.8.1 Kommentare zur internen Dokumentation ................................................... 1672.8.2 Intellisense- und Doxygen Kommentare ...................................................... 170

2.9 Exception-Handling Grundlagen: try, catch und throw....................................... 1712.10 Namensbereiche – Grundlagen .......................................................................... 1762.11 Präprozessoranweisungen ................................................................................. 178

2.11.1 Die #include-Anweisung ............................................................................. 1782.11.2 Makros Ө .................................................................................................... 1792.11.3 Bedingte Kompilation ................................................................................. 1822.11.4 Pragmas Ө .................................................................................................. 186

2.12 Attribute ........................................................................................................... 1882.13 Der Visual Studio C++ Core Guidelines Checker .............................................. 1902.14 Module (C++20) ............................................................................................... 193

2.14.1 Installation und Einstellungen für Module in Visual Studio 2019 16.5 .......... 1942.14.2 Die Standardbibliothek als Modul verwenden .............................................. 1952.14.3 Module definieren ....................................................................................... 196

2.15 Compiler Feature Test Makros .......................................................................... 1982.15.1 Der Präprozessorkonstanten-Ausdruck __has_include.................................. 1982.15.2 Die __cpp_xxx-Makros ............................................................................... 1982.15.3 __has_cpp_attribute .................................................................................... 199

3 Die Stringklassen: string, wstring usw. ...................................................... 2013.1 Die Definition von Variablen eines Klassentyps ................................................ 2023.2 Einige Elementfunktionen der Klasse string ...................................................... 2043.3 Raw-String-Literale (Rohzeichenfolgen) ........................................................... 2143.4 Stringkonversionen ........................................................................................... 216

3.4.1 C++11-Konversionsfunktionen: to_string, stoi usw. .................................... 2173.4.2 C++17-Konversionsfunktionen: to_chars und from_chars ........................... 2193.4.3 Konversionen mit Stringstreams Ө .............................................................. 223

3.5 string_view –Strings zum Anschauen ................................................................ 2253.6 Unicode-Strings Ө ............................................................................................ 2293.7 Landespezifische Einstellungen Ө ..................................................................... 2303.8 Reguläre Ausdrücke Ө ...................................................................................... 232

4 Arrays und Container ................................................................................ 2434.1 Synonyme für Datentypen ................................................................................. 244

4.1.1 Einfache typedef-Deklarationen ................................................................... 2444.1.2 Synonyme für Datentypen mit using ............................................................ 244

4.2 Eindimensionale Arrays .................................................................................... 2454.2.1 Arrays im Stil von C ................................................................................... 2454.2.2 Arrays des Typs std::array .......................................................................... 2484.2.3 Dynamische Arrays des Typs std::vector ..................................................... 2494.2.4 Arrays mit std::span als Parameter übergeben ............................................. 2524.2.5 Die Initialisierung von Arrays bei ihrer Definition ....................................... 2534.2.6 Vorteile von std::array und std::vector gegenüber C-Arrays ........................ 2554.2.7 Ein einfaches Sortierverfahren (Auswahlsort) .............................................. 258

xiv Inhalt

4.3 Arrays als Container ......................................................................................... 2594.4 Mehrdimensionale Arrays Ө ............................................................................. 2624.5 Dynamische Programmierung Ө ........................................................................ 264

5 Einfache selbstdefinierte Datentypen ........................................................ 2675.1 Mit struct definierte Klassen ............................................................................. 2675.2 Aufzählungstypen ............................................................................................. 272

5.2.1 Schwach typisierte Aufzählungstypen (C/C++03) ........................................ 2735.2.2 enum Konstanten und Konversionen Ө ........................................................ 2745.2.3 Stark typisierte Aufzählungstypen (C++11) ................................................. 275

6 Zeiger, dynamisch erzeugte Variablen und smart pointer ....................... 2796.1 Die Definition von Zeigervariablen ................................................................... 2806.2 Der Adressoperator, Zuweisungen und generische Zeiger .................................. 2836.3 Explizite Konversionen Ө ................................................................................. 2886.4 Ablaufprotokolle für Zeigervariable .................................................................. 2896.5 Dynamisch erzeugte Variablen .......................................................................... 290

6.5.1 new und delete ............................................................................................ 2916.5.2 Der Unterschied zu „gewöhnlichen“ Variablen ............................................ 2946.5.3 Der Smart Pointer Typ unique_ptr ............................................................... 2976.5.4 Dynamische erzeugte eindimensionale Arrays ............................................. 2986.5.5 nothrow-new Ө ........................................................................................... 300

6.6 Stringliterale, nullterminierte Strings und char*-Zeiger ..................................... 3016.7 Memory Leaks finden ....................................................................................... 306

6.7.1 Mit Visual C++ memory-leaks finden Ө ...................................................... 3066.7.2 Mit überladenen new- und delete-Operatoren memory-leaks finden Ө .......... 307

6.8 Verkettete Listen ............................................................................................... 3116.9 Binärbäume Ө ................................................................................................... 321

7 Überladene Funktionen und Operatoren .................................................. 3277.1 Inline-Funktionen Ө .......................................................................................... 3277.2 Überladene Funktionen ..................................................................................... 330

7.2.1 Funktionen, die nicht überladen werden können........................................... 3327.2.2 Regeln für die Auswahl einer passenden Funktion ....................................... 333

7.3 Überladene Operatoren mit globalen Operatorfunktionen................................... 3397.3.1 Globale Operatorfunktionen ........................................................................ 3417.3.2 Die Ein- und Ausgabe von selbst definierten Datentypen ............................. 3447.3.3 new und delete überladen ............................................................................ 346

7.4 Referenztypen, Wert- und Referenzparameter .................................................... 3507.4.1 Wertparameter ............................................................................................ 3507.4.2 Referenztypen ............................................................................................. 3517.4.3 Referenzparameter ...................................................................................... 3527.4.4 Referenzen als Rückgabetypen .................................................................... 3557.4.5 Konstante Referenzparameter ...................................................................... 357

Inhalt xv

7.5 Reihenfolge der Auswertung von Ausdrücken seit C++17 ................................. 358

8 Objektorientierte Programmierung .......................................................... 3618.1 Klassen ............................................................................................................. 362

8.1.1 Datenelemente und Elementfunktionen ........................................................ 3628.1.2 Der Gültigkeitsbereich von Klassenelementen ............................................. 3678.1.3 Datenkapselung: Die Zugriffsrechte private und public ................................ 3708.1.4 Der Aufruf von Elementfunktionen und der this-Zeiger ............................... 3768.1.5 Konstruktoren und Destruktoren .................................................................. 3778.1.6 shared_ptr: Smart Pointer für Klassenelemente ........................................... 3908.1.7 OO Analyse und Design: Der Entwurf von Klassen ..................................... 3918.1.8 Klassendiagramme ...................................................................................... 3958.1.9 Initialisierungslisten für Variablen, Argumente und Rückgabewerte ............. 3968.1.10 Initialisierungslisten als Parameter............................................................... 3988.1.11 Implizite Typzuweisungen mit auto ............................................................. 400

8.2 Klassen als Datentypen ..................................................................................... 4058.2.1 Der Standardkonstruktor ............................................................................. 4068.2.2 Elementinitialisierer .................................................................................... 4088.2.3 friend-Funktionen und –Klassen .................................................................. 4148.2.4 Überladene Operatoren mit Elementfunktionen............................................ 4178.2.5 Der dreifache Vergleichsoperator <=> (Spaceship Operator) ........................ 4218.2.6 Der Kopierkonstruktor ................................................................................ 4268.2.7 Der Zuweisungsoperator = für Klassen ........................................................ 4308.2.8 Die Angaben =delete und =default .............................................................. 4368.2.9 Konvertierende und explizite Konstruktoren Ө ............................................ 4388.2.10 Konversionsfunktionen mit und ohne explicit Ө ........................................... 4428.2.11 Statische Klassenelemente ........................................................................... 4438.2.12 inline Variablen, insbesondere static inline Datenelemente .......................... 4488.2.13 Konstante Objekte und Elementfunktionen .................................................. 4508.2.14 std::function: Ein Datentyp für Funktionen und aufrufbare Objekte .............. 4528.2.15 Delegierende Konstruktoren Ө .................................................................... 4578.2.16 Klassen und Header-Dateien ....................................................................... 458

8.3 Vererbung und Komposition ............................................................................. 4608.3.1 Die Elemente von abgeleiteten Klassen ....................................................... 4618.3.2 Zugriffsrechte auf die Elemente von Basisklassen ........................................ 4638.3.3 Verdeckte Elemente .................................................................................... 4658.3.4 Konstruktoren, Destruktoren und implizit erzeugte Funktionen .................... 4688.3.5 OO Design: public Vererbung und „ist ein“-Beziehungen ............................ 4758.3.6 OO Design: Komposition und „hat ein“-Beziehungen .................................. 4808.3.7 Konversionen zwischen public abgeleiteten Klassen .................................... 4818.3.8 Mehrfachvererbung und virtuelle Basisklassen ............................................ 484

8.4 Virtuelle Funktionen, späte Bindung und Polymorphie ...................................... 4888.4.1 Der statische und der dynamische Datentyp ................................................. 4888.4.2 Virtuelle Funktionen in C++03 .................................................................... 4908.4.3 Virtuelle Funktionen mit override in C++11 ................................................ 4918.4.4 Die Implementierung von virtuellen Funktionen: vptr und vtbl ..................... 5018.4.5 Virtuelle Konstruktoren und Destruktoren ................................................... 507

xvi Inhalt

8.4.6 Virtuelle Funktionen in Konstruktoren und Destruktoren ............................. 5098.4.7 OO-Design: Einsatzbereich und Test von virtuellen Funktionen ................... 5108.4.8 OO-Design und Erweiterbarkeit .................................................................. 5128.4.9 Rein virtuelle Funktionen und abstrakte Basisklassen .................................. 5158.4.10 OO-Design: Virtuelle Funktionen und abstrakte Basisklassen ...................... 5198.4.11 Interfaces und Mehrfachvererbung .............................................................. 5218.4.12 Objektorientierte Programmierung: Zusammenfassung ................................ 523

8.5 R-Wert Referenzen und Move-Semantik ........................................................... 5258.5.1 R-Werte und R-Wert Referenzen ................................................................. 5258.5.2 move-Semantik ........................................................................................... 5288.5.3 R-Werte mit std::move erzwingen ............................................................... 5308.5.4 Move-Semantik in der C++11 Standardbibliothek........................................ 5358.5.5 Move-Semantik für eigene Klassen ............................................................. 5368.5.6 Perfect forwarding Ө ................................................................................... 539

9 Namensbereiche ......................................................................................... 5419.1 Die Definition von Namensbereichen ................................................................ 5429.2 Die Verwendung von Namen aus Namensbereichen .......................................... 5459.3 Header-Dateien und Namensbereiche ................................................................ 5489.4 Aliasnamen für Namensbereiche Ө.................................................................... 5529.5 inline namespaces Ө ......................................................................................... 553

10 Exception-Handling ................................................................................... 55510.1 Die try-Anweisung ............................................................................................ 55610.2 Exception-Handler und Exceptions der Standardbibliothek ................................ 56110.3 throw-Ausdrücke und selbst definierte Exceptions ............................................. 56410.4 Exceptions weitergeben..................................................................................... 57010.5 Fehler und Exceptions ....................................................................................... 57310.6 Die Freigabe von Ressourcen bei Exceptions: RAII ........................................... 57610.7 Exceptions in Konstruktoren und Destruktoren .................................................. 57810.8 noexcept ........................................................................................................... 58410.9 Exception-Sicherheit ......................................................................................... 58510.10Die Exception-Klasse system_error Ө ............................................................... 588

11 Containerklassen der C++-Standardbibliothek ........................................ 59111.1 Sequenzielle Container der Standardbibliothek .................................................. 591

11.1.1 Die Container-Klasse vector ........................................................................ 59111.1.2 Iteratoren .................................................................................................... 59611.1.3 Geprüfte Iteratoren (Checked Iterators)........................................................ 59911.1.4 Die bereichsbasierte for-Schleife ................................................................. 60111.1.5 Iteratoren und die Algorithmen der Standardbibliothek ................................ 60411.1.6 Die Speicherverwaltung bei Vektoren Ө ...................................................... 60711.1.7 Mehrdimensionale Vektoren Ө .................................................................... 60911.1.8 Gemeinsamkeiten und Unterschiede der sequenziellen Container ................. 610

Inhalt xvii

11.1.9 Die Container-Adapter stack, queue und priority_queue Ө ........................... 61311.1.10Container mit Zeigern ................................................................................ 614

11.2 Allokatoren und polymorphic memory ressources.............................................. 61511.3 Assoziative Container ....................................................................................... 620

11.3.1 Die Container set und multiset ..................................................................... 62011.3.2 Die Container map und multimap ................................................................ 62111.3.3 Iteratoren der assoziativen Container ........................................................... 62311.3.4 Ungeordnete Assoziative Container (Hash-Container) ................................. 626

11.4 Zusammenfassungen von Datentypen ................................................................ 63011.4.1 Wertepaare mit std::pair ............................................................................. 63111.4.2 Tupel mit std::tuple ..................................................................................... 63211.4.3 Strukturierte Bindungen Ө........................................................................... 63311.4.4 std::optional – Eine Klasse für einen oder keinen Wert ................................ 63711.4.5 std::variant – Eine Klasse für Werte bestimmter Typen ............................... 64111.4.6 std::any: Ein Datentyp für Werte beliebiger Typen Ө .................................. 644

12 Dateibearbeitung mit den Stream-Klassen ............................................... 64712.1 Stream-Variablen, ihre Verbindung mit Dateien und ihr Zustand ....................... 64712.2 Fehler und der Zustand von Stream-Variablen ................................................... 65112.3 Lesen und Schreiben von Binärdaten mit read und write .................................... 65312.4 Lesen und Schreiben mit den Operatoren << und >> .......................................... 65912.5 Dateibearbeitung im Direktzugriff Ө ................................................................. 66712.6 Manipulatoren und Funktionen zur Formatierung von Texten Ө......................... 66912.7 Filesystem ........................................................................................................ 671

13 Funktoren, Funktionsobjekte und Lambda-Ausdrücke ........................... 67713.1 Der Aufrufoperator () ........................................................................................ 67713.2 Prädikate und Vergleichsfunktionen .................................................................. 68113.3 Binder Ө ........................................................................................................... 68613.4 Lambda-Ausdrücke ........................................................................................... 68913.5 Lambda-Ausdrücke – Weitere Konzepte Ө ........................................................ 698

13.5.1 Lambda-Ausdrücke werden zu Funktionsobjekten ....................................... 69813.5.2 Nachstehende Rückgabetypen ..................................................................... 69913.5.3 Generische Lambda-Ausdrücke ................................................................... 70013.5.4 Lambda-Ausdrücke höherer Ordnung Ө ...................................................... 700

13.6 Kompatible function-Typen: Kovarianz und Kontravarianz Ө ............................ 701

14 Templates ................................................................................................... 70314.1 Generische Funktionen: Funktions-Templates ................................................... 704

14.1.1 Die Deklaration von Funktions-Templates mit Typ-Parametern ................... 70514.1.2 Spezialisierungen von Funktions-Templates ................................................ 70614.1.3 Fehlersuche bei Template-Instanziierungen ................................................. 71314.1.4 Funktions-Templates mit Nicht-Typ-Parametern ......................................... 71514.1.5 Explizit instanziierte Funktions-Templates Ө ............................................... 717

xviii Inhalt

14.1.6 Explizit spezialisierte und überladene Templates ......................................... 71814.1.7 Rekursive Funktions-Templates Ө ............................................................... 722

14.2 Generische Klassen: Klassen-Templates ............................................................ 72514.2.1 Die Deklaration von Klassen-Templates mit Typ-Parametern ...................... 72514.2.2 Spezialisierungen von Klassen-Templates ................................................... 72614.2.3 Klassen-Templates mit Nicht-Typ-Parametern ............................................. 73314.2.4 Explizit instanziierte Klassen-Templates Ө .................................................. 73514.2.5 Partielle und vollständige Spezialisierungen Ө ............................................. 73614.2.6 Vererbung mit Klassen-Templates Ө ........................................................... 74214.2.7 Die Ableitung von Typ-Argumenten bei Klassen-Templates ........................ 74314.2.8 Alias Templates Ө....................................................................................... 747

14.3 Variablen-Templates Ө ..................................................................................... 74814.4 Typ-Argument abhängige Templates mit Type Traits ........................................ 750

14.4.1 Eine Konstruktion von type traits ................................................................ 75014.4.2 Die type traits Kategorien ............................................................................ 75114.4.3 Type traits und static_assert......................................................................... 75314.4.4 Templates mit if constexpr und type traits optimieren .................................. 75514.4.5 Typ-Inferenz mit decltype ........................................................................... 756

14.5 Variadische Templates ...................................................................................... 76014.5.1 Variadische Funktions-Templates ................................................................ 76114.5.2 Fold Ausdrücke ........................................................................................... 76414.5.3 Variadische Klassen-Templates am Beispiel von std::tuple .......................... 766

14.6 Concepts ........................................................................................................... 76714.6.1 concepts mit requires-Ausdrücken............................................................... 76714.6.2 Vordefinierte concepts ................................................................................ 77014.6.3 Ein Ausblick auf ranges: Algorithmen mit concepts ..................................... 771

14.7 Kovarianz und Kontravarianz ............................................................................ 771

15 STL-Algorithmen und Lambda-Ausdrücke.............................................. 77315.1 Iteratoren .......................................................................................................... 774

15.1.1 Die verschiedenen Arten von Iteratoren ....................................................... 77415.1.2 Umkehriteratoren ........................................................................................ 77615.1.3 Einfügefunktionen und Einfügeiteratoren .................................................... 77715.1.4 Stream-Iteratoren ........................................................................................ 77915.1.5 Container-Konstruktoren mit Iteratoren ....................................................... 78115.1.6 Globale Iterator-Funktionen Ө ..................................................................... 782

15.2 Nichtmodifizierende Algorithmen ..................................................................... 78415.2.1 Lineares Suchen .......................................................................................... 78515.2.2 Zählen ........................................................................................................ 78715.2.3 Der Vergleich von Bereichen ...................................................................... 78715.2.4 Suche nach Teilfolgen ................................................................................. 78815.2.5 Minimum und Maximum ............................................................................ 79015.2.6 Mit all_of, any_of, none_of alle Elemente in einem Bereich prüfen .............. 791

15.3 Kopieren und Verschieben von Bereichen ......................................................... 79215.4 Elemente transformieren und ersetzen ............................................................... 79415.5 Elementen in einem Bereich Werte zuweisen Ө ................................................. 79515.6 Elemente entfernen – das erase-remove Idiom ................................................... 797

Inhalt xix

15.7 Die Reihenfolge von Elementen vertauschen ..................................................... 79915.7.1 Elemente vertauschen.................................................................................. 79915.7.2 Permutationen Ө ......................................................................................... 80015.7.3 Die Reihenfolge umkehren und Elemente rotieren Ө .................................... 80115.7.4 Elemente durcheinander mischen Ө ............................................................. 802

15.8 Algorithmen zum Sortieren und für sortierte Bereiche ....................................... 80215.8.1 Partitionen Ө ............................................................................................... 80215.8.2 Bereiche sortieren ....................................................................................... 80315.8.3 Binäres Suchen in sortierten Bereichen ........................................................ 80715.8.4 Mischen von sortierten Bereichen ................................................................ 808

15.9 Numerische Algorithmen und Datentypen ......................................................... 81015.9.1 Numerische Algorithmen ............................................................................ 81015.9.2 Valarrays Ө................................................................................................. 81215.9.3 Zufallszahlen mit <random> Ө .................................................................... 81415.9.4 Komplexe Zahlen Ө .................................................................................... 81715.9.5 Numerische Bibliotheken neben dem C++-Standard Ө ................................ 820

15.10Parallele Algorithmen der STL .......................................................................... 82015.10.1std::sort ..................................................................................................... 82215.10.2Parallel for mit for_each ............................................................................ 82315.10.3std::reduce und std::transform_reduce ....................................................... 826

16 Zeiten und Kalenderdaten mit chrono ...................................................... 82916.1 Brüche als Datentypen: Das Klassen-Template ratio .......................................... 82916.2 Ein Datentyp für Zeiteinheiten: duration ........................................................... 83116.3 Datentypen für Zeitpunkte: time_point .............................................................. 83416.4 Uhren: system_clock und steady_clock .............................................................. 837

17 Multithreading ........................................................................................... 84117.1 Funktionen als Threads starten .......................................................................... 842

17.1.1 Funktionen mit async als Threads starten ..................................................... 84317.1.2 Funktionen mit thread als Threads starten ................................................... 84717.1.3 Lambda-Ausdrücke als Threads starten ....................................................... 84917.1.4 Zuweisungen und move für Threads ............................................................ 85417.1.5 Die Klassen future und promise ................................................................... 85517.1.6 Exceptions in Threads und ihre Weitergabe mit promise .............................. 85817.1.7 Der Programmablauf mit async ................................................................... 86317.1.8 Informationen über Threads ........................................................................ 87017.1.9 Sleep-Funktionen ........................................................................................ 87317.1.10Threads im Debugger ................................................................................. 875

17.2 Kritische Abschnitte.......................................................................................... 87617.2.1 Atomare Datentypen ................................................................................... 87917.2.2 Kritische Bereiche mit mutex und lock_guard bzw. scoped_lock sperren ...... 88117.2.3 Read/Write-Mutexe mit shared_mutex und shared_lock .............................. 89017.2.4 Die Lock-Klasse unique_lock Ө .................................................................. 89117.2.5 Deadlocks ................................................................................................... 892

xx Inhalt

17.2.6 call_once zur Initialisierung von Daten ........................................................ 89617.2.7 Thread-lokale Daten .................................................................................... 897

17.3 Bedingungsvariablen zur Synchronisation von Threads...................................... 89817.4 Die „Parallel Patterns Library“ von Microsoft.................................................... 901

18 Smart Pointer: shared_ptr, unique_ptr und weak_ptr................................ 90318.1 Gemeinsamkeiten von unique_ptr und shared_ptr ............................................. 90418.2 unique_ptr ........................................................................................................ 91218.3 shared_ptr ........................................................................................................ 91318.4 Deleter und smart pointer für Arrays ................................................................. 91918.5 weak_ptr Ө ....................................................................................................... 921

Literaturverzeichnis ....................................................................................... 925

Index................................................................................................................ 927

Ө Angesichts des Umfangs dieses Buches habe ich einige Abschnitte mit dem Zeichen Ө inder Überschrift als „weniger wichtig“ gekennzeichnet. Damit will ich dem Anfänger einekleine Orientierung durch die Fülle des Stoffes geben. Diese Kennzeichnung bedeutetaber keineswegs, dass dieser Teil unwichtig ist – vielleicht sind gerade diese Inhalte fürSie besonders relevant.