Inhaltsverzeichnis

Alle Kapitel aufklappen
Alle Kapitel zuklappen
Vorwort
23
TEIL I Grundlagen
27
1 Das C++-Handbuch
29
1.1 Neu und Modern
30
1.2 »Dan«-Kapitel
30
1.3 Darstellung in diesem Buch
31
1.4 Verwendete Formatierungen
31
1.5 Sorry for my Denglish
32
2 Programmieren in C++
35
2.1 Übersetzen
36
2.2 Übersetzungsphasen
36
2.3 Aktuelle Compiler
38
2.3.1 Gnu C++
38
2.3.2 Clang++ der LLVM
38
2.3.3 Microsoft Visual Studio
38
2.4 Entwicklungsumgebungen
39
2.5 Die Kommandozeile unter Ubuntu
40
2.5.1 Ein Programm erstellen
41
2.5.2 Automatisieren mit Makefile
43
2.6 Die IDE »Microsoft Visual Studio Community« unter Windows
44
2.7 Das Beispielprogramm beschleunigen
46
3 C++ für Umsteiger
49
4 Die Grundbausteine von C++
55
4.1 Kommentare
58
4.2 Die »include«-Direktive
58
4.3 Die Standardbibliothek
58
4.4 Die Funktion »main()«
59
4.5 Typen
59
4.6 Variablen
60
4.7 Initialisierung
60
4.8 Ausgabe auf der Konsole
61
4.9 Anweisungen
61
4.10 Ohne Eile erklärt
62
4.10.1 Leerräume, Bezeichner und Token
64
4.10.2 Kommentare
65
4.10.3 Funktionen und Argumente
66
4.10.4 Seiteneffekt-Operatoren
67
4.10.5 Die »main«-Funktion
68
4.10.6 Anweisungen
70
4.10.7 Ausdrücke
72
4.10.8 Zuweisungen
74
4.10.9 Typen
75
4.10.10 Variablen – Deklaration, Definition und Initialisierung
80
4.10.11 Initialisieren mit »auto«
81
4.10.12 Details zur »include«-Direktive und »include« direkt
81
4.10.13 Eingabe und Ausgabe
83
4.10.14 Der Namensraum »std«
83
4.11 Operatoren
85
4.11.1 Operatoren und Operanden
86
4.11.2 Überblick über Operatoren
87
4.11.3 Arithmetische Operatoren
87
4.11.4 Bitweise Arithmetik
88
4.11.5 Zusammengesetzte Zuweisung
91
4.11.6 Post- und Präinkrement sowie Post- und Prädekrement
92
4.11.7 Relationale Operatoren
92
4.11.8 Logische Operatoren
93
4.11.9 Pointer- und Dereferenzierungsoperatoren
94
4.11.10 Besondere Operatoren
95
4.11.11 Funktionsähnliche Operatoren
96
4.11.12 Operatorreihenfolge
97
4.12 Eingebaute Datentypen
98
4.12.1 Übersicht
99
4.12.2 Eingebaute Datentypen initialisieren
101
4.12.3 Ganzzahlen
101
4.12.4 Fließkommazahlen
112
4.12.5 Wahrheitswerte
125
4.12.6 Zeichentypen
127
4.12.7 Komplexe Zahlen
129
4.13 Undefiniertes und unspezifiziertes Verhalten
132
5 Guter Code, 1. Dan: Lesbar programmieren
135
5.1 Kommentare
135
5.2 Dokumentation
136
5.3 Einrückungen und Zeilenlänge
137
5.4 Zeilen pro Funktion und Datei
138
5.5 Klammern und Leerzeichen
139
5.6 Namen
140
6 Höhere Datentypen
143
6.1 Strings und Streams
144
6.2 Der Zeichenkettentyp »string«
144
6.2.1 Initialisierung
145
6.2.2 Funktionen und Methoden
146
6.2.3 Andere Stringtypen
147
6.3 Streams
148
6.3.1 Eingabe- und Ausgabeoperatoren
149
6.3.2 »getline«
151
6.3.3 Dateien für die Ein- und Ausgabe
151
6.3.4 Manipulatoren
153
6.3.5 Der Manipulator »endl«
153
6.4 Behälter und Zeiger
155
6.4.1 Container
155
6.4.2 Parametrisierte Typen
155
6.5 Die einfachen Sequenzcontainer
156
6.5.1 »array«
156
6.5.2 »vector«
158
6.6 Algorithmen
161
6.7 Zeiger und C-Arrays
161
6.7.1 Zeigertypen
162
6.7.2 C-Arrays
162
7 Funktionen
163
7.1 Deklaration und Definition einer Funktion
164
7.2 Funktionstyp
165
7.3 Funktionen verwenden
165
7.4 Eine Funktion definieren
167
7.5 Mehr zu Parametern
168
7.5.1 Call-by-Value
168
7.5.2 Call-by-Reference
169
7.5.3 Konstante Referenzen
170
7.5.4 Aufruf als Wert, Referenz oder konstante Referenz?
170
7.6 Funktionskörper
172
7.7 Parameter umwandeln
173
7.8 Funktionen überladen
175
7.9 Default-Parameter
177
7.10 Beliebig viele Argumente
179
7.11 Alternative Schreibweise zur Funktionsdeklaration
179
7.12 Spezialitäten
180
7.12.1 »noexcept«
180
7.12.2 Inline-Funktionen
181
7.12.3 »constexpr«
182
7.12.4 Gelöschte Funktionen
182
7.12.5 Spezialitäten bei Klassenmethoden
182
8 Anweisungen im Detail
185
8.1 Der Anweisungsblock
188
8.2 Die leere Anweisung
190
8.3 Deklarationsanweisung
191
8.4 Die Ausdrucksanweisung
192
8.5 Die »if«-Anweisung
193
8.6 Die »while«-Schleife
195
8.7 Die »do-while«-Schleife
197
8.8 Die »for«-Schleife
198
8.9 Die bereichsbasierte »for«-Schleife
200
8.10 Die »switch«-Verzweigung
202
8.11 Die »break«-Anweisung
206
8.12 Die »continue«-Anweisung
207
8.13 Die »return«-Anweisung
207
8.14 Die »goto«-Anweisung
209
8.15 Der »try-catch«-Block und »throw«
210
8.16 Zusammenfassung
212
9 Ausdrücke im Detail
213
9.1 Berechnungen und Seiteneffekte
214
9.2 Arten von Ausdrücken
215
9.3 Literale
216
9.4 Bezeichner
216
9.5 Klammern
217
9.6 Funktionsaufruf und Index-Zugriff
218
9.7 Zuweisung
218
9.8 Typumwandlung
220
10 Fehlerbehandlung
221
10.1 Fehlerbehandlung mit Fehlercodes
223
10.2 Was ist eine Ausnahme?
226
10.2.1 Ausnahmen auslösen und behandeln
227
10.2.2 Aufrufstapel abwickeln
228
10.3 Kleinere Fehlerbehandlungen
229
10.4 Weiterwerfen – »rethrow«
229
10.5 Die Reihenfolge im »catch«
230
10.5.1 Kein »finally«
231
10.5.2 Exceptions der Standardbibliothek
231
10.6 Typen für Exceptions
232
10.7 Wenn eine Exception aus »main« herausfällt
233
11 Guter Code, 2. Dan: Modularisierung
235
11.1 Programm, Bibliothek, Objektdatei
235
11.2 Bausteine
236
11.3 Trennen der Funktionalitäten
237
11.4 Ein modulares Beispielprojekt
238
11.4.1 Namensräume
241
11.4.2 Implementierung
242
11.4.3 Die Bibliothek nutzen
247
11.5 Spezialthema: Unity-Builds
249
TEIL II Objektorientierte Programmierung und mehr
251
12 Von der Struktur zur Klasse
253
12.1 Initialisierung
255
12.2 Rückgabe eigener Typen
256
12.3 Methoden statt Funktionen
257
12.4 Das bessere »drucke«
260
12.5 Eine Ausgabe wie jede andere
262
12.6 Methoden inline definieren
263
12.7 Implementierung und Definition trennen
264
12.8 Initialisierung per Konstruktor
265
12.8.1 Member-Defaultwerte in der Deklaration
267
12.8.2 Konstruktor-Delegation
268
12.8.3 Defaultwerte für die Konstruktor-Parameter
269
12.8.4 »init«-Methode nicht im Konstruktor aufrufen
270
12.8.5 Exceptions im Konstruktor
271
12.9 Struktur oder Klasse?
271
12.9.1 Kapselung
273
12.9.2 »public« und »private«, Struktur und Klasse
273
12.9.3 Daten mit »struct«, Verhalten mit »class«
273
12.9.4 Initialisierung von Typen mit privaten Daten
274
12.10 Zwischenergebnis
275
12.11 Verwendung eigener Datentypen
276
12.11.1 Klassen als Werte verwenden
278
12.11.2 Konstruktoren nutzen
281
12.11.3 Typumwandlungen
282
12.11.4 Kapseln und entkapseln
284
12.11.5 Typen lokal einen Namen geben
288
12.12 Typinferenz mit »auto«
291
12.13 Eigene Klassen in Standardcontainern
294
13 Namensräume und Qualifizierer
297
13.1 Der Namensraum »std«
297
13.2 Anonymer Namensraum
301
13.3 »static« macht lokal
303
13.4 »static« teilt gern
303
13.5 »static« macht dauerhaft
306
13.5.1 »inline namespace«
308
13.6 Zusammenfassung
309
13.7 Const
310
13.7.1 Const-Parameter
311
13.7.2 Const-Methoden
312
13.7.3 Const-Variablen
313
13.7.4 Const-Rückgaben
314
13.7.5 Const zusammen mit »static«
318
13.7.6 Noch konstanter mit »constexpr«
319
13.7.7 Un-Const mit »mutable«
322
13.7.8 Const-Korrektheit
323
13.7.9 Zusammenfassung
324
13.8 Flüchtig mit »volatile«
324
14 Guter Code, 3. Dan: Testen
327
14.1 Arten des Tests
327
14.1.1 Refactoring
329
14.1.2 Unittests
329
14.1.3 Sozial oder solitär
331
14.1.4 Doppelgänger
333
14.1.5 Suites
334
14.2 Frameworks
335
14.2.1 Arrange, Act, Assert
337
14.2.2 Frameworks zur Auswahl
338
14.3 Boost.Test
339
14.4 Hilfsmakros für Assertions
343
14.5 Ein Beispielprojekt mit Unittests
346
14.5.1 Privates und Öffentliches testen
347
14.5.2 Ein automatisches Testmodul
348
14.5.3 Test compilieren
351
14.5.4 Die Testsuite selbst zusammenbauen
351
14.5.5 Testen von Privatem
355
14.5.6 Parametrisierte Tests
356
15 Vererbung
359
15.1 Beziehungen
360
15.1.1 Hat-ein-Komposition
360
15.1.2 Hat-ein-Aggregation
360
15.1.3 Ist-ein-Vererbung
361
15.1.4 Ist-Instanz-von versus Ist-ein-Beziehung
362
15.2 Vererbung in C++
362
15.3 Hat-ein versus ist-ein
363
15.4 Gemeinsamkeiten finden
364
15.5 Abgeleitete Typen erweitern
366
15.6 Methoden überschreiben
367
15.7 Wie Methoden funktionieren
368
15.8 Virtuelle Methoden
370
15.9 Konstruktoren in Klassenhierarchien
372
15.10 Typumwandlung in Klassenhierarchien
373
15.10.1 Die Vererbungshierarchie aufwärts umwandeln
373
15.10.2 Die Vererbungshierarchie abwärts umwandeln
374
15.10.3 Referenzen behalten auch die Typinformation
374
15.11 Wann virtuell?
375
15.12 Andere Designs zur Erweiterbarkeit
376
16 Der Lebenszyklus von Klassen
379
16.1 Erzeugung und Zerstörung
380
16.2 Temporary: kurzlebige Werte
382
16.3 Der Destruktor zum Konstruktor
383
16.3.1 Kein Destruktor nötig
385
16.3.2 Ressourcen im Destruktor
385
16.4 Yoda-Bedingung
387
16.5 Konstruktion, Destruktion und Exceptions
389
16.6 Kopieren
390
16.7 Zuweisungsoperator
393
16.8 Streichen von Methoden
396
16.9 Verschiebeoperationen
398
16.9.1 Was der Compiler generiert
402
16.10 Operatoren
403
16.11 Eigene Operatoren in einem Datentyp
406
16.12 Besondere Klassenformen
411
16.12.1 Abstrakte Klassen und Methoden
411
16.12.2 Aufzählungsklassen
412
17 Guter Code, 4. Dan: Sicherheit, Qualität und Nachhaltigkeit
415
17.1 Die Nuller-Regel
415
17.1.1 Die großen Fünf
415
17.1.2 Hilfskonstrukt per Verbot
416
17.1.3 Die Nuller-Regel und ihr Einsatz
417
17.1.4 Ausnahmen von der Nuller-Regel
418
17.2 RAII – Resource Acquisition Is Initialization
420
17.2.1 Ein Beispiel mit C
420
17.2.2 Besitzende Raw-Pointer
422
17.2.3 Von C nach C++
423
17.2.4 Es muss nicht immer eine Exception sein
425
17.2.5 Mehrere Konstruktoren
426
17.2.6 Mehrphasige Initialisierung
426
17.2.7 Definieren, wo es gebraucht wird
427
17.2.8 Nothrow-new
427
18 Spezielles für Klassen
429
18.1 Darf alles sehen – »friend«-Klassen
429
18.2 non-public-Vererbung
434
18.2.1 Auswirkungen auf die Außenwelt
435
18.2.2 Nicht-öffentliche Vererbung in der Praxis
437
18.3 Signatur-Klassen als Interfaces
439
18.4 Multiple Vererbung
443
18.4.1 Multiple Vererbung in der Praxis
444
18.4.2 Achtung bei Typumwandlungen von Zeigern
448
18.4.3 Das Beobachter-Muster als praktisches Beispiel
450
18.5 Rautenförmige multiple Vererbung – »virtual« für Klassenhierarchien
452
18.6 Literale Datentypen – »constexpr« für Konstruktoren
456
19 Guter Code, 5. Dan: Klassisches objektorientiertes Design
459
19.1 Objekte in C++
461
19.2 Objektorientiert designen
462
19.2.1 SOLID
462
19.2.2 Seien Sie nicht STUPID
480
TEIL III Fortgeschrittene Themen
481
20 Zeiger
483
20.1 Adressen
484
20.2 Zeiger
485
20.3 Gefahren von Aliasing
487
20.4 Heapspeicher und Stapelspeicher
489
20.4.1 Der Stapel
489
20.4.2 Der Heap
490
20.5 Smarte Pointer
492
20.5.1 »unique ptr«
494
20.5.2 »shared ptr«
498
20.6 Rohe Zeiger
501
20.7 C-Arrays
506
20.7.1 Rechnen mit Zeigern
506
20.7.2 Verfall von C-Arrays
507
20.7.3 Dynamische C-Arrays
509
20.7.4 Zeichenkettenliterale
510
20.8 Iteratoren
511
20.9 Zeiger als Iteratoren
513
20.10 Zeiger im Container
513
20.11 Die Ausnahme: wann das Wegräumen nicht nötig ist
514
21 Makros
517
21.1 Der Präprozessor
518
21.2 Vorsicht vor fehlenden Klammern
521
21.3 Vorsicht vor Mehrfachausführung
522
21.4 Typvariabilität von Makros
523
21.5 Zusammenfassung
526
22 Schnittstelle zu C
527
22.1 Mit Bibliotheken arbeiten
528
22.2 C-Header
529
22.3 C-Ressourcen
532
22.4 »void«-Pointer
532
22.5 Daten lesen
533
22.6 Das Hauptprogramm
534
22.7 Zusammenfassung
535
23 Templates
537
23.1 Funktionstemplates
538
23.1.1 Überladung
539
23.1.2 Ein Typ als Parameter
540
23.1.3 Funktionskörper eines Funktionstemplates
540
23.1.4 Zahlen als Templateparameter
542
23.1.5 Viele Funktionen
543
23.1.6 Parameter mit Extras
544
23.1.7 Methodentemplates sind auch nur Funktionstemplates
546
23.2 Funktionstemplates in der Standardbibliothek
547
23.2.1 Iteratoren statt Container als Templateparameter
548
23.2.2 Beispiel: Informationen über Zahlen
550
23.3 Eine Klasse als Funktion
551
23.3.1 Werte für einen »function«-Parameter
552
23.3.2 C-Funktionspointer
553
23.3.3 Die etwas andere Funktion
555
23.3.4 Praktische Funktoren
558
23.3.5 Algorithmen mit Funktoren
559
23.3.6 Anonyme Funktionen alias Lambda-Ausdrücke
560
23.3.7 Templatefunktionen ohne »template«, aber mit »auto«
564
23.4 Templateklassen
565
23.4.1 Klassentemplates implementieren
565
23.4.2 Methoden von Klassentemplates implementieren
566
23.4.3 Objekte aus Klassentemplates erzeugen
568
23.4.4 Klassentemplates mit mehreren formalen Datentypen
570
23.4.5 Klassentemplates mit Non-Type-Parameter
571
23.4.6 Klassentemplates mit Default
573
23.4.7 Klassentemplates spezialisieren
574
23.5 Templates mit variabler Argumentanzahl
576
23.6 Eigene Literale
580
23.6.1 Was sind Literale?
581
23.6.2 Namensregeln
582
23.6.3 Phasenweise
582
23.6.4 Überladungsvarianten
583
23.6.5 Benutzerdefiniertes Literal mittels Template
584
23.6.6 Roh oder gekocht
587
23.6.7 Automatisch zusammengefügt
588
23.6.8 Unicodeliterale
588
TEIL IV Die Standardbibliothek
591
24 Container
593
24.1 Grundlagen
594
24.1.1 Wiederkehrend
594
24.1.2 Abstrakt
595
24.1.3 Operationen
596
24.1.4 Komplexität
597
24.1.5 Container und ihre Iteratoren
598
24.1.6 Algorithmen
600
24.2 Iteratoren-Grundlagen
601
24.2.1 Iteratoren aus Containern
602
24.2.2 Mehr Funktionalität mit Iteratoren
603
24.3 Allokatoren: Speicherfragen
605
24.4 Container-Gemeinsamkeiten
607
24.5 Ein Überblick über die Standardcontainer-Klassen
608
24.5.1 Typaliase der Container
609
24.6 Die sequenziellen Containerklassen
612
24.6.1 Gemeinsamkeiten und Unterschiede
614
24.6.2 Methoden von Sequenzcontainern
615
24.6.3 »vector«
618
24.6.4 »array«
631
24.6.5 »deque«
636
24.6.6 »list«
639
24.6.7 »forward list«
642
24.7 Assoziativ und geordnet
647
24.7.1 Gemeinsamkeiten und Unterschiede
648
24.7.2 Methoden der geordneten assoziativen Container
649
24.7.3 »set«
651
24.7.4 »map«
663
24.7.5 »multiset«
670
24.7.6 »multimap«
674
24.8 Nur assoziativ und nicht garantiert
678
24.8.1 Gemeinsamkeiten und Unterschiede
682
24.8.2 Methoden der ungeordneten assoziativen Container
684
24.8.3 »unordered set«
685
24.8.4 »unordered map«
693
24.8.5 »unordered multiset«
698
24.8.6 »unordered multimap«
703
24.9 Container-Adapter
706
24.10 Sonderfälle: »string«, »basic string« und »vector<char>«
707
24.11 Sonderfälle: »vector<bool>«, »array<bool,n>« und »bitset<n>«
708
24.11.1 Dynamisch und kompakt: »vector<bool>«
708
24.11.2 Statisch: »array<bool,n>« und »bitset<n>«
708
24.12 Sonderfall: Value-Array mit »valarray<>«
711
25 Container-Unterstützung
721
25.1 Algorithmen
721
25.2 Iteratoren
723
25.3 Iterator-Adapter
723
25.4 Algorithmen der Standardbibliothek
724
25.5 Liste der Algorithmusfunktionen
726
25.6 Kopie statt Zuweisung – Werte in uninitialisierten Speicherbereichen
740
25.7 Eigene Algorithmen
741
26 Guter Code, 6. Dan: Für jede Aufgabe der richtige Container
745
26.1 Alle Container nach Aspekten sortiert
745
26.1.1 Wann ist ein »vector« nicht die beste Wahl?
745
26.1.2 Immer sortiert: »set«, »map«, »multiset« und »multimap«
746
26.1.3 Im Speicher hintereinander: »vector«, »array«
746
26.1.4 Einfügung billig: »list«
747
26.1.5 Wenig Speicheroverhead: »vector«, »array«
748
26.1.6 Größe dynamisch: alle außer »array«
749
26.2 Rezepte für Container
750
26.2.1 Zwei Phasen? »vector« als guter »set«-Ersatz
751
26.2.2 Den Inhalt eines Containers auf einem Stream ausgeben
752
26.2.3 So statisch ist »array« gar nicht
753
26.3 Iteratoren sind mehr als nur Zeiger
756
26.4 Algorithmen je nach Container unterschiedlich implementieren
758
27 Streams
761
27.1 Ein- und Ausgabekonzept
761
27.2 Globale, vordefinierte Standardstreams
762
27.3 Methoden für die Aus- und Eingabe von Streams
764
27.3.1 Methoden für die unformatierte Ausgabe
764
27.3.2 Methoden für die (unformatierte) Eingabe
765
27.4 Fehlerbehandlung und Zustand von Streams
768
27.4.1 Methoden für die Behandlung von Fehlern bei Streams
769
27.5 Streams manipulieren und formatieren
771
27.5.1 Manipulatoren
772
27.5.2 Eigene Manipulatoren ohne Argumente erstellen
777
27.5.3 Eigene Manipulatoren mit Argumenten erstellen
779
27.5.4 Format-Flags direkt ändern
780
27.6 Streams für die Dateiein- und Dateiausgabe
782
27.6.1 Die Streams »ifstream«, »ofstream« und »fstream«
783
27.6.2 Verbindung zu einer Datei herstellen
783
27.6.3 Lesen und Schreiben
788
27.6.4 Wahlfreier Zugriff
795
27.7 Streams für Strings
796
27.8 Streampuffer
801
28 Standardbibliothek – Extras
805
28.1 »pair« und »tuple«
805
28.1.1 Mehrere Werte zurückgeben
806
28.2 Reguläre Ausdrücke
812
28.2.1 Matchen und Suchen
813
28.2.2 Ergebnis und Teile davon
813
28.2.3 Gefundenes Ersetzen
814
28.2.4 Reich an Varianten
814
28.2.5 Iteratoren
815
28.2.6 Matches
816
28.2.7 Optionen
816
28.2.8 Geschwindigkeit
816
28.2.9 Standardsyntax leicht gekürzt
817
28.2.10 Anmerkungen zu regulären Ausdrücken in C++
818
28.3 Zufall
821
28.3.1 Einen Würfel werfen
822
28.3.2 Echter Zufall
824
28.3.3 Andere Generatoren
824
28.3.4 Verteilungen
826
28.4 Mathematisches
830
28.4.1 Brüche und Zeiten – »<ratio>« und »<chrono>«
830
28.4.2 Numerik mit »<numeric>«
843
28.4.3 Vordefinierte Suffixe für benutzerdefinierte Literale
847
28.5 Systemfehlerbehandlung mit »system error«
849
28.5.1 »error code« und »error condition«
851
28.5.2 Fehlerkategorien
855
28.5.3 Eigene Fehlercodes
855
28.5.4 »system error«-Exception
857
28.6 Laufzeit-Typinformationen – »<typeinfo>« und »<typeindex>«
858
28.7 Hilfsklassen rund um Funktoren – »<functional>«
862
28.7.1 Funktionsobjekte
862
28.7.2 Funktionsgeneratoren
866
28.8 Ausblick auf C++17
869
28.8.1 »variant«
869
28.8.2 »optional« und »any«
870
28.8.3 »string view«
871
28.8.4 »filesystem«
872
28.8.5 Spezielle mathematische Funktionen
872
28.8.6 »sample«
873
28.8.7 »search«
874
28.8.8 »byte«
874
29 Threads – Programmieren mit Mehrläufigkeit
875
29.1 C++-Threading-Grundlagen
876
29.1.1 Einer Threadfunktion Parameter übergeben
881
29.1.2 Einen Thread verschieben
886
29.1.3 Wie viele Threads starten?
888
29.1.4 Welcher Thread bin ich?
891
29.2 Gemeinsame Daten
891
29.2.1 Daten mit Mutexen schützen
892
29.2.2 Data Races
895
29.2.3 Interface-Design für Multithreading
896
29.2.4 Sperren können zum Patt führen
901
29.2.5 Flexibleres Sperren mit »unique lock«
903
29.3 Andere Möglichkeiten zur Synchronisation
904
29.3.1 Nur einmal aufrufen mit »once flag« und »call once«
904
29.3.2 Sperren zählen mit »recursive mutex«
907
29.4 Im eigenen Speicher mit »thread local«
908
29.5 Mit »condition variable« auf Ereignisse warten
909
29.6 Einmal warten mit »future«
914
29.6.1 Ausnahmebehandlung bei »future«
919
29.6.2 »promise«
921
29.7 Atomics
924
29.8 Zusammenfassung
930
29.9 Ausblick auf C++17
932
TEIL V Über den Standard hinaus
933
30 Guter Code, 7. Dan: Richtlinien
935
30.1 Guideline Support Library
936
30.2 C++ Core Guidelines
937
30.2.1 Motivation
937
30.2.2 Typsicherheit
938
30.2.3 Nutzen Sie RAII
940
30.2.4 Klassenhierarchien
942
30.2.5 Generische Programmierung
945
30.2.6 Lassen Sie sich nicht von Anachronismen verwirren
948
31 GUI-Programmierung mit Qt
951
31.1 Ein erstes Miniprogramm
955
31.1.1 Kurze Übersicht über die Oberfläche von Qt Creator
956
31.1.2 Ein einfaches Projekt erstellen
957
31.2 Objektbäume und Besitz
966
31.3 Signale und Slots
967
31.3.1 Verbindung zwischen Signal und Slot herstellen
967
31.3.2 Signal und Slot mithilfe der Qt-Referenz ermitteln
970
31.4 Klassenhierarchie von Qt
987
31.4.1 Basisklasse »QObject«
987
31.4.2 Weitere wichtige Klassen
987
31.5 Eigene Widgets mit dem Qt Designer erstellen
990
31.6 Widgets anordnen
996
31.6.1 Grundlegende Widgets für das Layout
996
31.7 Dialoge erstellen mit »QDialog«
1000
31.8 Vorgefertigte Dialoge von Qt
1008
31.8.1 »QMessageBox« – der klassische Nachrichtendialog
1008
31.8.2 »QFileDialog« – der Dateiauswahldialog
1009
31.8.3 »QInputDialog« – Dialog zur Eingabe von Daten
1011
31.8.4 Weitere Dialoge
1015
31.9 Eigenen Dialog mit dem Qt Designer erstellen
1015
31.10 Grafische Bedienelemente von Qt (Qt-Widgets)
1031
31.10.1 Schaltflächen (Basisklasse »QAbstractButton«)
1031
31.10.2 Container-Widgets (Behälter-Widgets)
1033
31.10.3 Widgets zur Zustandsanzeige
1034
31.10.4 Widgets zur Eingabe
1035
31.10.5 Onlinehilfen
1036
31.11 Anwendungen in einem Hauptfenster
1037
31.11.1 Die Klasse für das Hauptfenster »QMainWindow«
1037
31.12 Zusammenfassung
1048
Cheat Sheet
1052
Index
1055