Eine Tour durch C++

Name: Eine Tour durch C++ | Der praktische Leitfaden für modernes C++.Übersetzung der 3. Auflage
Brand: MITP
Price: 19.99 EUR
Availability: OnlineOnly

Der praktische Leitfaden für modernes C++.Übersetzung der 3. Auflage

Bjarne Stroustrup(Autor*in)

MITP (Verlag)

1. Auflage

Erschienen am 27. Juni 2023

408 Seiten

E-Book

PDF mit Wasserzeichen-DRM

Systemvoraussetzungen

978-3-7475-0626-4 (ISBN)

19,99 €inkl. 7% MwSt.

Systemvoraussetzungen

für PDF mit Wasserzeichen-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Die neuesten Sprachfeatures im Überblick
Verfasst vom Entwickler von C++
Übersetzung der 3. Auflage

Dieses Buch bietet erfahrenen Programmierern einen praktischen Überblick über C++20 nach ISO-Standard und damit ein klares Verständnis für den Einsatz von modernem C++. Anhand vieler Codebeispiele und hilfreicher Praxistipps wird ein Großteil der Hauptfeatures der Sprache sowie der Standardbibliothek behandelt, die für den effektiven Einsatz unverzichtbar sind.

Stroustrup stellt die einzelnen Sprachfeatures von C++ vor und zeigt, wie sie im Kontext der unterstützten Programmierstile eingesetzt werden, beispielsweise der objektorientierten oder generischen Programmierung. Seine Tour beginnt mit den Grundlagen und setzt den Fokus anschließend auf fortgeschrittene Techniken, wobei er insbesondere auf die neueren Sprach-features eingeht.

Dieses Buch deckt zahlreiche Features ab, die mit C++20 neu eingeführt wurden, darunter Module, Konzepte, Koroutinen und Bereiche. Selbst einige schon jetzt verfügbare Komponenten, die nicht vor C++23 in den Standard integriert werden sollen, werden vorgestellt.

Wenn Sie bereits Programmierkenntnisse in C++ oder einer anderen Sprache haben, ist dies die kompakteste und verständlichste Einführung, um die Besonderheiten und Vorteile von modernem C++ kennenzulernen.

Aus dem Inhalt

Die Grundlagen: Funktionen, Referenzen, Zeiger und mehr
Benutzerdefinierte Typen
Modularität
Fehlerbehandlung
Klassen
Operationen
Templates
Konzepte und generische Programmierung
Die Standardbibliothek
Strings und reguläre Ausdrücke
Streams
Algorithmen
Bereiche (Ranges)
Zeiger und Container
Utilities
Numerik
Nebenläufigkeit
Zahlreiche Ratschläge für die effektive Programmierung aus den »C++ Core Guidelines«

Rezensionen / Stimmen

»Dem mitp-Verlag ist mit der Übersetzung der dritten Auflage des englischen Originals ein lesenswertes Buch gelungen, das sich zudem durch eine sinnvolle didaktische Struktur auszeichnet.« (Heise online, 10/2023)
»Wer in den letzten Jahren die oft chaotische Weiterentwicklung des C++ Standards nicht immer zu 100% aktiv verfolgt hat, findet hier ein Lehrbuch, das die guten Teile des objektorientierten Oldies gekonnt zu demonstrieren weiß.« (Entwickler Magazin, 10/2023)

Weitere Details

Weitere Ausgaben

Person

Inhalt

1 - Cover [Seite 1]
2 - Titel [Seite 3]
3 - Impressum [Seite 4]
4 - Inhaltsverzeichnis [Seite 5]
5 - Einleitung [Seite 11]
5.1 - Danksagungen [Seite 13]
5.2 - Über die Fachkorrektoren der deutschen Ausgabe [Seite 13]
6 - Kapitel 1: Die Grundlagen [Seite 15]
6.1 - 1.1 Einführung [Seite 15]
6.2 - 1.2 Programme [Seite 15]
6.2.1 - 1.2.1 Hello, World! [Seite 16]
6.3 - 1.3 Funktionen [Seite 18]
6.4 - 1.4 Typen, Variablen und Arithmetik [Seite 21]
6.4.1 - 1.4.1 Rechenoperatoren [Seite 22]
6.4.2 - 1.4.2 Initialisierung [Seite 24]
6.5 - 1.5 Gültigkeitsbereich und Lebensdauer [Seite 25]
6.6 - 1.6 Konstanten [Seite 27]
6.7 - 1.7 Zeiger, Arrays und Referenzen [Seite 29]
6.7.1 - 1.7.1 Der Null-Pointer [Seite 31]
6.8 - 1.8 Bedingungen prüfen [Seite 33]
6.9 - 1.9 Auf Hardware abbilden [Seite 36]
6.9.1 - 1.9.1 Zuweisung [Seite 36]
6.9.2 - 1.9.2 Initialisierung [Seite 38]
6.10 - 1.10 Ratschläge [Seite 39]
7 - Kapitel 2: Benutzerdefinierte Typen [Seite 41]
7.1 - 2.1 Einführung [Seite 41]
7.2 - 2.2 Strukturen [Seite 42]
7.3 - 2.3 Klassen [Seite 44]
7.4 - 2.4 Aufzählungen [Seite 46]
7.5 - 2.5 Unions [Seite 48]
7.6 - 2.6 Ratschläge [Seite 51]
8 - Kapitel 3: Modularität [Seite 53]
8.1 - 3.1 Einführung [Seite 53]
8.2 - 3.2 Separates Kompilieren [Seite 54]
8.2.1 - 3.2.1 Header-Dateien [Seite 55]
8.2.2 - 3.2.2 Module [Seite 58]
8.3 - 3.3 Namensräume [Seite 62]
8.4 - 3.4 Funktionsargumente und Rückgabewerte [Seite 64]
8.4.1 - 3.4.1 Argumentübergabe [Seite 65]
8.4.2 - 3.4.2 Werterückgabe [Seite 66]
8.4.3 - 3.4.3 Rückgabetyp ableiten [Seite 68]
8.4.4 - 3.4.4 Suffix-Rückgabetyp [Seite 69]
8.4.5 - 3.4.5 Strukturierte Bindung [Seite 69]
8.5 - 3.5 Ratschläge [Seite 71]
9 - Kapitel 4: Fehlerbehandlung [Seite 73]
9.1 - 4.1 Einführung [Seite 73]
9.2 - 4.2 Exceptions [Seite 73]
9.3 - 4.3 Invarianten [Seite 75]
9.4 - 4.4 Alternativen für die Fehlerbehandlung [Seite 78]
9.5 - 4.5 Assertions [Seite 81]
9.5.1 - 4.5.1 assert() [Seite 82]
9.5.2 - 4.5.2 Statische Assertionen [Seite 83]
9.5.3 - 4.5.3 noexcept [Seite 84]
9.6 - 4.6 Ratschläge [Seite 84]
10 - Kapitel 5: Klassen [Seite 87]
10.1 - 5.1 Einführung [Seite 87]
10.1.1 - 5.1.1 Klassen [Seite 88]
10.2 - 5.2 Konkrete Typen [Seite 88]
10.2.1 - 5.2.1 Ein arithmetischer Typ [Seite 89]
10.2.2 - 5.2.2 Ein Container [Seite 92]
10.2.3 - 5.2.3 Container initialisieren [Seite 94]
10.3 - 5.3 Abstrakte Typen [Seite 96]
10.4 - 5.4 Virtuelle Funktionen [Seite 100]
10.5 - 5.5 Klassenhierarchien [Seite 101]
10.5.1 - 5.5.1 Vorteile von Hierarchien [Seite 105]
10.5.2 - 5.5.2 Die Navigation in einer Hierarchie [Seite 106]
10.5.3 - 5.5.3 Ressourcenlecks vermeiden [Seite 108]
10.6 - 5.6 Ratschläge [Seite 110]
11 - Kapitel 6: Notwendige Operationen [Seite 113]
11.1 - 6.1 Einführung [Seite 113]
11.1.1 - 6.1.1 Notwendige Operationen [Seite 113]
11.1.2 - 6.1.2 Konvertierungen [Seite 116]
11.1.3 - 6.1.3 Member-Initialisierer [Seite 116]
11.2 - 6.2 Kopieren und Verschieben [Seite 117]
11.2.1 - 6.2.1 Container kopieren [Seite 118]
11.2.2 - 6.2.2 Container verschieben [Seite 120]
11.3 - 6.3 Ressourcenverwaltung [Seite 123]
11.4 - 6.4 Operatoren überladen [Seite 125]
11.5 - 6.5 Konventionelle Operationen [Seite 126]
11.5.1 - 6.5.1 Vergleiche (Relationale Operatoren) [Seite 127]
11.5.2 - 6.5.2 Container-Operationen [Seite 129]
11.5.3 - 6.5.3 Iteratoren und »smarte Zeiger« [Seite 130]
11.5.4 - 6.5.4 Eingabe- und Ausgabeoperationen [Seite 130]
11.5.5 - 6.5.5 swap() [Seite 131]
11.5.6 - 6.5.6 hash<> [Seite 131]
11.6 - 6.6 Benutzerdefinierte Literale [Seite 131]
11.7 - 6.7 Ratschläge [Seite 132]
12 - Kapitel 7: Templates [Seite 135]
12.1 - 7.1 Einführung [Seite 135]
12.2 - 7.2 Parametrisierte Typen [Seite 135]
12.2.1 - 7.2.1 Beschränkte Template-Argumente [Seite 138]
12.2.2 - 7.2.2 Wert-Template-Argumente [Seite 139]
12.2.3 - 7.2.3 Deduktion von Template-Argumenten [Seite 140]
12.3 - 7.3 Parametrisierte Operationen [Seite 142]
12.3.1 - 7.3.1 Funktions-Templates [Seite 143]
12.3.2 - 7.3.2 Funktionsobjekte [Seite 144]
12.3.3 - 7.3.3 Lambda-Ausdrücke [Seite 146]
12.4 - 7.4 Template-Mechanismen [Seite 151]
12.4.1 - 7.4.1 Variablen-Templates [Seite 152]
12.4.2 - 7.4.2 Aliasse [Seite 153]
12.4.3 - 7.4.3 Compile-Zeit-if [Seite 154]
12.5 - 7.5 Ratschläge [Seite 156]
13 - Kapitel 8: Konzepte und generische Programmierung [Seite 157]
13.1 - 8.1 Einführung [Seite 157]
13.2 - 8.2 Konzepte [Seite 158]
13.2.1 - 8.2.1 Verwendung von Konzepten [Seite 158]
13.2.2 - 8.2.2 Konzeptbasiertes Überladen [Seite 160]
13.2.3 - 8.2.3 Gültiger Code [Seite 161]
13.2.4 - 8.2.4 Definition von Konzepten [Seite 163]
13.2.5 - 8.2.5 Konzepte und auto [Seite 167]
13.2.6 - 8.2.6 Konzepte und Typen [Seite 169]
13.3 - 8.3 Generische Programmierung [Seite 169]
13.3.1 - 8.3.1 Verwendung von Konzepten [Seite 170]
13.3.2 - 8.3.2 Abstraktion mittels Templates [Seite 170]
13.4 - 8.4 Variadische Templates [Seite 173]
13.4.1 - 8.4.1 Fold-Ausdrücke [Seite 174]
13.4.2 - 8.4.2 Argumente weitergeben [Seite 176]
13.5 - 8.5 Modell der Template-Kompilierung [Seite 176]
13.6 - 8.6 Ratschläge [Seite 177]
14 - Kapitel 9: Überblick über die Bibliothek [Seite 179]
14.1 - 9.1 Einführung [Seite 179]
14.2 - 9.2 Komponenten der Standardbibliothek [Seite 180]
14.3 - 9.3 Organisation der Standardbibliothek [Seite 181]
14.3.1 - 9.3.1 Namensräume [Seite 182]
14.3.2 - 9.3.2 Der Namensraum ranges [Seite 183]
14.3.3 - 9.3.3 Module [Seite 184]
14.3.4 - 9.3.4 Header [Seite 184]
14.4 - 9.4 Ratschläge [Seite 186]
15 - Kapitel 10: Strings und reguläre Ausdrücke [Seite 187]
15.1 - 10.1 Einführung [Seite 187]
15.2 - 10.2 Strings [Seite 187]
15.2.1 - 10.2.1 Die Implementierung von string [Seite 189]
15.3 - 10.3 String-Views [Seite 191]
15.4 - 10.4 Reguläre Ausdrücke [Seite 193]
15.4.1 - 10.4.1 Suche [Seite 194]
15.4.2 - 10.4.2 Notation regulärer Ausdrücke [Seite 195]
15.4.3 - 10.4.3 Iteratoren [Seite 200]
15.5 - 10.5 Ratschläge [Seite 201]
16 - Kapitel 11: Eingabe und Ausgabe [Seite 203]
16.1 - 11.1 Einführung [Seite 203]
16.2 - 11.2 Ausgabe [Seite 204]
16.3 - 11.3 Eingabe [Seite 205]
16.4 - 11.4 I/O-Status [Seite 207]
16.5 - 11.5 Ein-/Ausgabe benutzerdefinierter Typen [Seite 208]
16.6 - 11.6 Ausgabeformatierung [Seite 210]
16.6.1 - 11.6.1 Stream-Formatierung [Seite 210]
16.6.2 - 11.6.2 Formatierung im printf()-Stil [Seite 212]
16.7 - 11.7 Streams [Seite 216]
16.7.1 - 11.7.1 Standard-Streams [Seite 216]
16.7.2 - 11.7.2 Datei-Streams [Seite 217]
16.7.3 - 11.7.3 String-Streams [Seite 217]
16.7.4 - 11.7.4 Speicher-Streams [Seite 219]
16.7.5 - 11.7.5 Synchronisierte Streams [Seite 219]
16.8 - 11.8 Ein-/Ausgaben im C-Stil [Seite 220]
16.9 - 11.9 Dateisystem [Seite 221]
16.9.1 - 11.9.1 Pfade [Seite 221]
16.9.2 - 11.9.2 Dateien und Verzeichnisse [Seite 225]
16.10 - 11.10 Ratschläge [Seite 226]
17 - Kapitel 12: Container [Seite 229]
17.1 - 12.1 Einführung [Seite 229]
17.2 - 12.2 vector [Seite 229]
17.2.1 - 12.2.1 Elemente [Seite 233]
17.2.2 - 12.2.2 Bereichsüberprüfung [Seite 234]
17.3 - 12.3 list [Seite 236]
17.4 - 12.4 forward_list [Seite 238]
17.5 - 12.5 map [Seite 238]
17.6 - 12.6 unordered_map [Seite 240]
17.7 - 12.7 Allokatoren [Seite 242]
17.8 - 12.8 Ein Überblick über Container [Seite 244]
17.9 - 12.9 Ratschläge [Seite 246]
18 - Kapitel 13: Algorithmen [Seite 249]
18.1 - 13.1 Einführung [Seite 249]
18.2 - 13.2 Verwendung von Iteratoren [Seite 252]
18.3 - 13.3 Iterator-Typen [Seite 255]
18.3.1 - 13.3.1 Stream-Iteratoren [Seite 257]
18.4 - 13.4 Verwendung von Prädikaten [Seite 260]
18.5 - 13.5 Überblick über Algorithmen [Seite 260]
18.6 - 13.6 Parallele Algorithmen [Seite 262]
18.7 - 13.7 Ratschläge [Seite 264]
19 - Kapitel 14: Bereiche (Ranges) [Seite 265]
19.1 - 14.1 Einführung [Seite 265]
19.2 - 14.2 Views [Seite 266]
19.3 - 14.3 Generatoren [Seite 269]
19.4 - 14.4 Pipelines [Seite 270]
19.5 - 14.5 Überblick über Konzepte [Seite 271]
19.5.1 - 14.5.1 Typkonzepte [Seite 271]
19.5.2 - 14.5.2 Iterator-Konzepte [Seite 275]
19.5.3 - 14.5.3 Bereichskonzepte [Seite 277]
19.6 - 14.6 Ratschläge [Seite 278]
20 - Kapitel 15: Zeiger und Container [Seite 279]
20.1 - 15.1 Einführung [Seite 279]
20.2 - 15.2 Zeiger [Seite 280]
20.2.1 - 15.2.1 unique_ptr und shared_ptr [Seite 281]
20.2.2 - 15.2.2 span [Seite 285]
20.3 - 15.3 Container [Seite 287]
20.3.1 - 15.3.1 array [Seite 289]
20.3.2 - 15.3.2 bitset [Seite 291]
20.3.3 - 15.3.3 pair [Seite 292]
20.3.4 - 15.3.4 tuple [Seite 295]
20.4 - 15.4 Alternativen [Seite 297]
20.4.1 - 15.4.1 variant [Seite 297]
20.4.2 - 15.4.2 optional [Seite 300]
20.4.3 - 15.4.3 any [Seite 301]
20.5 - 15.5 Ratschläge [Seite 302]
21 - Kapitel 16: Utilities [Seite 305]
21.1 - 16.1 Einführung [Seite 305]
21.2 - 16.2 Zeit [Seite 305]
21.2.1 - 16.2.1 Uhren [Seite 305]
21.2.2 - 16.2.2 Kalender [Seite 306]
21.2.3 - 16.2.3 Zeitzonen [Seite 308]
21.3 - 16.3 Funktionsanpassung [Seite 309]
21.3.1 - 16.3.1 Lambdas als Adapter [Seite 309]
21.3.2 - 16.3.2 mem_fn() [Seite 309]
21.3.3 - 16.3.3 function [Seite 310]
21.4 - 16.4 Typfunktionen [Seite 310]
21.4.1 - 16.4.1 Typprädikate [Seite 312]
21.4.2 - 16.4.2 Bedingte Eigenschaften [Seite 314]
21.4.3 - 16.4.3 Typgeneratoren [Seite 316]
21.4.4 - 16.4.4 Assoziierte Typen [Seite 317]
21.5 - 16.5 source_location [Seite 317]
21.6 - 16.6 move() und forward() [Seite 318]
21.7 - 16.7 Bitmanipulation [Seite 320]
21.8 - 16.8 Ein Programm beenden [Seite 321]
21.9 - 16.9 Ratschläge [Seite 322]
22 - Kapitel 17: Numerik [Seite 325]
22.1 - 17.1 Einführung [Seite 325]
22.2 - 17.2 Mathematische Funktionen [Seite 325]
22.3 - 17.3 Numerische Algorithmen [Seite 327]
22.3.1 - 17.3.1 Parallele numerische Algorithmen [Seite 328]
22.4 - 17.4 Komplexe Zahlen [Seite 329]
22.5 - 17.5 Zufallszahlen [Seite 330]
22.6 - 17.6 Vektorarithmetik [Seite 333]
22.7 - 17.7 Numerische Grenzen [Seite 333]
22.8 - 17.8 Typ-Aliasse [Seite 334]
22.9 - 17.9 Mathematische Konstanten [Seite 334]
22.10 - 17.10 Ratschläge [Seite 335]
23 - Kapitel 18: Nebenläufigkeit [Seite 337]
23.1 - 18.1 Einführung [Seite 337]
23.2 - 18.2 Tasks und thread [Seite 338]
23.2.1 - 18.2.1 Argumente übergeben [Seite 340]
23.2.2 - 18.2.2 Ergebnisse zurückgeben [Seite 341]
23.3 - 18.3 Daten gemeinsam nutzen [Seite 342]
23.3.1 - 18.3.1 mutexe und Locks [Seite 342]
23.3.2 - 18.3.2 atomic [Seite 344]
23.4 - 18.4 Warten auf Ereignisse [Seite 345]
23.5 - 18.5 Kommunizierende Tasks [Seite 347]
23.5.1 - 18.5.1 future und promise [Seite 348]
23.5.2 - 18.5.2 packaged_task [Seite 350]
23.5.3 - 18.5.3 async() [Seite 351]
23.5.4 - 18.5.4 Einen Thread stoppen [Seite 352]
23.6 - 18.6 Koroutinen [Seite 354]
23.6.1 - 18.6.1 Kooperatives Multitasking [Seite 355]
23.7 - 18.7 Ratschläge [Seite 359]
24 - Kapitel 19: Geschichte und Kompatibilität [Seite 363]
24.1 - 19.1 Geschichte [Seite 363]
24.1.1 - 19.1.1 Chronik [Seite 364]
24.1.2 - 19.1.2 Die frühen Jahre [Seite 366]
24.1.3 - 19.1.3 Die ISO-C++-Standards [Seite 370]
24.1.4 - 19.1.4 Standards und Stil [Seite 372]
24.1.5 - 19.1.5 Verwendung von C++ [Seite 373]
24.1.6 - 19.1.6 Das C++-Modell [Seite 374]
24.2 - 19.2 Die Entwicklung der Merkmale von C++ [Seite 375]
24.2.1 - 19.2.1 Sprachmerkmale von C++11 [Seite 375]
24.2.2 - 19.2.2 Sprachmerkmale von C++14 [Seite 376]
24.2.3 - 19.2.3 Sprachmerkmale von C++17 [Seite 377]
24.2.4 - 19.2.4 Sprachmerkmale von C++20 [Seite 377]
24.2.5 - 19.2.5 Komponenten der C++11-Standardbibliothek [Seite 378]
24.2.6 - 19.2.6 Komponenten der C++14-Standardbibliothek [Seite 379]
24.2.7 - 19.2.7 Komponenten der C++17-Standardbibliothek [Seite 379]
24.2.8 - 19.2.8 Komponenten der C++20-Standardbibliothek [Seite 379]
24.2.9 - 19.2.9 Entfernte und veraltete Funktionsmerkmale [Seite 380]
24.3 - 19.3 C/C++-Kompatibilität [Seite 381]
24.3.1 - 19.3.1 C und C++ sind Geschwister [Seite 381]
24.3.2 - 19.3.2 Kompatibilitätsprobleme [Seite 383]
24.4 - 19.4 Ratschläge [Seite 386]
25 - Anhang A: module std [Seite 389]
25.1 - A.1 Einführung [Seite 389]
25.2 - A.2 Benutzen Sie, was Ihre Implementierung zu bieten hat [Seite 390]
25.3 - A.3 Benutzen Sie Header [Seite 390]
25.4 - A.4 Machen Sie sich Ihr eigenes module std [Seite 391]
25.5 - A.5 Ratschläge [Seite 392]
26 - Anhang B: Literaturverzeichnis [Seite 393]
26.1 - B.1 Literaturhinweise [Seite 393]
27 - Stichwortverzeichnis [Seite 399]

Systemvoraussetzungen

Als PDF speichern Als Link merken