C++

Dieses Standardwerk führt Sie in die moderne C++-Entwicklung ein. Entwickeln Sie Software mit hohen Ansprüchen an Funktionalität, Effizienz und Sicherheit. Ausführlich werden der Sprachkern, die objektorientierte Programmierung und die Standardbibliothek behandelt. Sie lernen zum Beispiel, mit Streams umzugehen, Containertypen zu nutzen und nebenläufige Anwendungen zu entwicklen. Nicht zuletzt geht es dem Autor um das Wie: Freuen Sie sich auf ein Lehrbuch über die Konzepte des Modern C++, die C++ Core Guidelines, Sprachversionen und vor allem über guten Code.

Aus dem Inhalt:

• Sprachgrundlagen
• Fehlerbehandlung
• Objektorientierte Programmierung
• Zeiger
• Schnittstelle zu C
• Templates
• Container
• Standardbibliothek
• C++ Core Guidelines
• Extra: Tutorials zum Thema "guter Code"

Vorwort . . . 25

TEIL I. Grundlagen . . . 29

1. Das C++-Handbuch . . . 31
1. 1 . . . Neu und modern . . . 32
1. 2 . . . »Dan«-Kapitel . . . 32
1. 3 . . . Darstellung in diesem Buch . . . 33
1. 4 . . . Verwendete Formatierungen . . . 33
1. 5 . . . Sorry for my Denglish . . . 34

2. Programmieren in C++ . . . 37
2. 1 . . . Übersetzen . . . 38
2. 2 . . . Übersetzungsphasen . . . 39
2. 3 . . . Aktuelle Compiler . . . 40
2. 4 . . . Entwicklungsumgebungen . . . 41
2. 5 . . . Die Kommandozeile unter Ubuntu . . . 43
2. 6 . . . Die IDE »Visual Studio Code« unter Windows . . . 47
2. 7 . . . Das Beispielprogramm beschleunigen . . . 54

3. C++ für Umsteiger . . . 55

4. Die Grundbausteine von C++ . . . 63
4. 1 . . . Ein schneller Überblick . . . 66
4. 2 . . . Ohne Eile erklärt . . . 71
4. 3 . . . Operatoren . . . 100
4. 4 . . . Eingebaute Datentypen . . . 116
4. 5 . . . Undefiniertes und unspezifiziertes Verhalten . . . 157

5. Guter Code, 1. Dan: Lesbar programmieren . . . 159
5. 1 . . . Kommentare . . . 160
5. 2 . . . Dokumentation . . . 160
5. 3 . . . Einrückungen und Zeilenlänge . . . 161
5. 4 . . . Zeilen pro Funktion und Datei . . . 162
5. 5 . . . Klammern und Leerzeichen . . . 163
5. 6 . . . Namen . . . 164

6. Höhere Datentypen . . . 167
6. 1 . . . Der Zeichenkettentyp »string« . . . 168
6. 2 . . . Streams . . . 174
6. 3 . . . Behälter und Zeiger . . . 181
6. 4 . . . Die einfachen Sequenzcontainer . . . 183
6. 5 . . . Algorithmen . . . 189
6. 6 . . . Zeiger und C-Arrays . . . 189

7. Funktionen . . . 191
7. 1 . . . Deklaration und Definition einer Funktion . . . 192
7. 2 . . . Funktionstyp . . . 193
7. 3 . . . Funktionen verwenden . . . 194
7. 4 . . . Eine Funktion definieren . . . 195
7. 5 . . . Mehr zu Parametern . . . 197
7. 6 . . . Funktionskörper . . . 201
7. 7 . . . Parameter umwandeln . . . 203
7. 8 . . . Funktionen überladen . . . 205
7. 9 . . . Defaultparameter . . . 208
7. 10 . . . Beliebig viele Argumente . . . 209
7. 11 . . . Alternative Schreibweise zur Funktionsdeklaration . . . 210
7. 12 . . . Spezialitäten . . . 211

8. Anweisungen im Detail . . . 215
8. 1 . . . Der Anweisungsblock . . . 218
8. 2 . . . Die leere Anweisung . . . 221
8. 3 . . . Deklarationsanweisung . . . 221
8. 4 . . . Die Ausdrucksanweisung . . . 224
8. 5 . . . Die »if«-Anweisung . . . 224
8. 6 . . . Die »while«-Schleife . . . 229
8. 7 . . . Die »do-while«-Schleife . . . 231
8. 8 . . . Die »for«-Schleife . . . 232
8. 9 . . . Die bereichsbasierte »for«-Schleife . . . 234
8. 10 . . . Die »switch«-Verzweigung . . . 236
8. 11 . . . Die »break«-Anweisung . . . 240
8. 12 . . . Die »continue«-Anweisung . . . 241
8. 13 . . . Die »return«-Anweisung . . . 242
8. 14 . . . Die »goto«-Anweisung . . . 243
8. 15 . . . Der »try-catch«-Block und »throw« . . . 245
8. 16 . . . Zusammenfassung . . . 247

9. Ausdrücke im Detail . . . 249
9. 1 . . . Berechnungen und Seiteneffekte . . . 250
9. 2 . . . Arten von Ausdrücken . . . 251
9. 3 . . . Literale . . . 253
9. 4 . . . Bezeichner . . . 253
9. 5 . . . Klammern . . . 254
9. 6 . . . Funktionsaufruf und Indexzugriff . . . 254
9. 7 . . . Zuweisung . . . 255
9. 8 . . . Typumwandlung . . . 257

10. Fehlerbehandlung . . . 259
10. 1 . . . Fehlerbehandlung mit Fehlercodes . . . 261
10. 2 . . . Was ist eine Ausnahme? . . . 264
10. 3 . . . Kleinere Fehlerbehandlungen . . . 267
10. 4 . . . Weiterwerfen -- »rethrow« . . . 268
10. 5 . . . Die Reihenfolge im »catch« . . . 268
10. 6 . . . Typen für Exceptions . . . 271
10. 7 . . . Wenn eine Exception aus »main« herausfällt . . . 272

11. Guter Code, 2. Dan: Modularisierung . . . 273
11. 1 . . . Programm, Bibliothek, Objektdatei . . . 273
11. 2 . . . Bausteine . . . 274
11. 3 . . . Trennen der Funktionalitäten . . . 275
11. 4 . . . Ein modulares Beispielprojekt . . . 277

TEIL II. Objektorientierte Programmierung und mehr . . . 289

12. Von der Struktur zur Klasse . . . 291
12. 1 . . . Initialisierung . . . 294
12. 2 . . . Rückgabe eigener Typen . . . 295
12. 3 . . . Methoden statt Funktionen . . . 297
12. 4 . . . Das bessere »drucke« . . . 300
12. 5 . . . Eine Ausgabe wie jede andere . . . 302
12. 6 . . . Methoden inline definieren . . . 303
12. 7 . . . Implementierung und Definition trennen . . . 304
12. 8 . . . Initialisierung per Konstruktor . . . 305
12. 9 . . . Struktur oder Klasse? . . . 313
12. 10 . . . Zwischenergebnis . . . 318
12. 11 . . . Eigene Datentypen verwenden . . . 318
12. 12 . . . Typinferenz mit »auto« . . . 335
12. 13 . . . Eigene Klassen in Standardcontainern . . . 339

13. Namensräume und Qualifizierer . . . 343
13. 1 . . . Der Namensraum »std« . . . 344
13. 2 . . . Anonymer Namensraum . . . 347
13. 3 . . . »static« macht lokal . . . 349
13. 4 . . . »static« teilt gern . . . 350
13. 5 . . . Ferne Initialisierung oder »static inline«-Datenfelder . . . 353
13. 6 . . . Garantiert zur Compilezeit initialisiert mit »constinit« . . . 354
13. 7 . . . »static« macht dauerhaft . . . 354
13. 8 . . . »inline namespace« . . . 356
13. 9 . . . Zusammenfassung . . . 358
13. 10 . . . »const« . . . 358
13. 11 . . . Flüchtig mit »volatile« . . . 380

14. Guter Code, 3. Dan: Testen . . . 383
14. 1 . . . Arten des Tests . . . 383
14. 2 . . . Frameworks . . . 391
14. 3 . . . Boost. Test . . . 396
14. 4 . . . Hilfsmakros für Assertions . . . 400
14. 5 . . . Ein Beispielprojekt mit Unittests . . . 403

15. Vererbung . . . 417
15. 1 . . . Beziehungen . . . 418
15. 2 . . . Vererbung in C++ . . . 421
15. 3 . . . Hat-ein versus ist-ein . . . 422
15. 4 . . . Gemeinsamkeiten finden . . . 422
15. 5 . . . Abgeleitete Typen erweitern . . . 425
15. 6 . . . Methoden überschreiben . . . 426
15. 7 . . . Wie Methoden funktionieren . . . 427
15. 8 . . . Virtuelle Methoden . . . 429
15. 9 . . . Konstruktoren in Klassenhierarchien . . . 431
15. 10 . . . Typumwandlung in Klassenhierarchien . . . 433
15. 11 . . . Wann virtuell? . . . 434
15. 12 . . . Andere Designs zur Erweiterbarkeit . . . 436

16. Der Lebenszyklus von Klassen . . . 439
16. 1 . . . Erzeugung und Zerstörung . . . 440
16. 2 . . . Temporary: kurzlebige Werte . . . 442
16. 3 . . . Der Destruktor zum Konstruktor . . . 444
16. 4 . . . Yoda-Bedingung . . . 449
16. 5 . . . Konstruktion, Destruktion und Exceptions . . . 450
16. 6 . . . Kopieren . . . 452
16. 7 . . . Zuweisungsoperator . . . 455
16. 8 . . . Streichen von Methoden . . . 459
16. 9 . . . Verschiebeoperationen . . . 461
16. 10 . . . Operatoren . . . 466
16. 11 . . . Eigene Operatoren in einem Datentyp . . . 470
16. 12 . . . Besondere Klassenformen . . . 478

17. Guter Code, 4. Dan: Sicherheit, Qualität und Nachhaltigkeit . . . 483
17. 1 . . . Die Nullerregel . . . 483
17. 2 . . . RAII -- Resource Acquisition Is Initialization . . . 489

18. Spezielles für Klassen . . . 499
18. 1 . . . Dürfen alles sehen -- »friend«-Klassen . . . 499
18. 2 . . . Non-public-Vererbung . . . 504
18. 3 . . . Signaturklassen als Interfaces . . . 510
18. 4 . . . Multiple Vererbung . . . 514
18. 5 . . . Rautenförmige multiple Vererbung -- »virtual« für Klassenhierarchien . . . 524
18. 6 . . . Literale Datentypen -- »constexpr« für Konstruktoren . . . 528

19. Guter Code, 5. Dan: Klassisches objektorientiertes Design . . . 531
19. 1 . . . Objekte in C++ . . . 533
19. 2 . . . Objektorientiert designen . . . 534

TEIL III. Fortgeschrittene Themen . . . 555

20. Zeiger . . . 557
20. 1 . . . Adressen . . . 558
20. 2 . . . Zeiger . . . 560
20. 3 . . . Gefahren von Aliasing . . . 562
20. 4 . . . Heapspeicher und Stapelspeicher . . . 563
20. 5 . . . Smarte Pointer . . . 567
20. 6 . . . Rohe Zeiger . . . 576
20. 7 . . . C-Arrays . . . 582
20. 8 . . . Iteratoren . . . 588
20. 9 . . . Zeiger als Iteratoren . . . 590
20. 10 . . . Zeiger im Container . . . 590
20. 11 . . . Die Ausnahme: wann das Wegräumen nicht nötig ist . . . 591

21. Makros . . . 595
21. 1 . . . Der Präprozessor . . . 596
21. 2 . . . Vorsicht vor fehlenden Klammern . . . 600
21. 3 . . . Featuremakros . . . 601
21. 4 . . . Information über den Quelltext . . . 602
21. 5 . . . Warnung vor Mehrfachausführung . . . 603
21. 6 . . . Typvariabilität von Makros . . . 604
21. 7 . . . Zusammenfassung . . . 607

22. Schnittstelle zu C . . . 609
22. 1 . . . Mit Bibliotheken arbeiten . . . 610
22. 2 . . . C-Header . . . 611
22. 3 . . . C-Ressourcen . . . 614
22. 4 . . . »void«-Pointer . . . 615
22. 5 . . . Daten lesen . . . 616
22. 6 . . . Das Hauptprogramm . . . 617
22. 7 . . . Zusammenfassung . . . 618

23. Templates . . . 619
23. 1 . . . Funktionstemplates . . . 621
23. 2 . . . Funktionstemplates in der Standardbibliothek . . . 631
23. 3 . . . Eine Klasse als Funktion . . . 637
23. 4 . . . C++ Concepts . . . 654
23. 5 . . . Templateklassen . . . 662
23. 6 . . . Templates mit variabler Argumentanzahl . . . 677
23. 7 . . . Eigene Literale . . . 681

TEIL IV. Die Standardbibliothek . . . 693

24. Container . . . 695
24. 1 . . . Grundlagen . . . 696
24. 2 . . . Iteratoren-Grundlagen . . . 709
24. 3 . . . Allokatoren: Speicherfragen . . . 714
24. 4 . . . Containergemeinsamkeiten . . . 717
24. 5 . . . Ein Überblick über die Standardcontainerklassen . . . 719
24. 6 . . . Die sequenziellen Containerklassen . . . 723
24. 7 . . . Assoziativ und geordnet . . . 769
24. 8 . . . Nur assoziativ und nicht garantiert . . . 805
24. 9 . . . Containeradapter . . . 837
24. 10 . . . Sonderfälle: »string«, »basic_string« und »vector« . . . 840
24. 11 . . . Sonderfälle: »vector«, »array« und »bitset« . . . 842
24. 12 . . . Sonderfall: Value-Array mit »valarray<>« . . . 845

25. Containerunterstützung . . . 855
25. 1 . . . Algorithmen . . . 857
25. 2 . . . Iteratoren und Ranges . . . 858
25. 3 . . . Iteratoradapter . . . 860
25. 4 . . . Algorithmen der Standardbibliothek . . . 861
25. 5 . . . Parallele Ausführung . . . 863
25. 6 . . . Liste der Algorithmusfunktionen und Range-Adapter . . . 866
25. 7 . . . Elemente verknüpfende Algorithmen aus »« und »« . . . 892
25. 8 . . . Kopie statt Zuweisung -- Werte in uninitialisierten Speicherbereichen . . . 899
25. 9 . . . Eigene Algorithmen . . . 901
25. 10 . . . Eigene Views und Range-Adapter schreiben . . . 903

26. Guter Code, 6. Dan: Für jede Aufgabe der richtige Container . . . 907
26. 1 . . . Alle Container nach Aspekten sortiert . . . 907
26. 2 . . . Rezepte für Container . . . 913
26. 3 . . . Algorithmen je nach Container unterschiedlich implementieren . . . 919

27. Streams, Dateien und Formatierung . . . 921
27. 1 . . . Ein- und Ausgabekonzept mit Streams . . . 922
27. 2 . . . Globale, vordefinierte Standardstreams . . . 922
27. 3 . . . Methoden für die Aus- und Eingabe von Streams . . . 925
27. 4 . . . Fehlerbehandlung und Zustand von Streams . . . 929
27. 5 . . . Streams manipulieren und formatieren . . . 933
27. 6 . . . Streams für die Dateiein- und Dateiausgabe . . . 945
27. 7 . . . Streams für Strings . . . 961
27. 8 . . . Streampuffer . . . 966
27. 9 . . . »filesystem« . . . 969
27. 10 . . . Formatieren . . . 971

28. Standardbibliothek -- Extras . . . 979
28. 1 . . . »pair« und »tuple« . . . 979
28. 2 . . . Reguläre Ausdrücke . . . 987
28. 3 . . . Zufall . . . 997
28. 4 . . . Mathematisches . . . 1006
28. 5 . . . Systemfehlerbehandlung mit »system_error« . . . 1033
28. 6 . . . Laufzeittypinformationen -- »« und »« . . . 1043
28. 7 . . . Hilfsklassen rund um Funktoren -- »« . . . 1047
28. 8 . . . »optional« für einen oder keinen Wert . . . 1055
28. 9 . . . »variant« für einen von mehreren Typen . . . 1056
28. 10 . . . »any« hält jeden Typ . . . 1058
28. 11 . . . Spezielle mathematische Funktionen . . . 1059
28. 12 . . . Schnelle Umwandlung mit »« . . . 1060

29. Threads -- Programmieren mit Mehrläufigkeit . . . 1063
29. 1 . . . C++-Threading-Grundlagen . . . 1064
29. 2 . . . Gemeinsame Daten . . . 1082
29. 3 . . . Andere Möglichkeiten zur Synchronisation . . . 1100
29. 4 . . . Im eigenen Speicher mit »thread_local« . . . 1104
29. 5 . . . Mit »condition_variable« auf Ereignisse warten . . . 1105
29. 6 . . . Einmal warten mit »future« . . . 1110
29. 7 . . . Atomics . . . 1122
29. 8 . . . Koroutinen . . . 1127
29. 9 . . . Zusammenfassung . . . 1133

A. Guter Code, 7. Dan: Richtlinien . . . 1137
A. 1 . . . Guideline Support Library . . . 1138
A. 2 . . . C++ Core Guidelines . . . 1139

B. Cheat Sheet . . . 1153

Index . . . 1157