Die C++-Programmiersprache

aktuell zum C++11-Standard
 
 
Hanser (Verlag)
  • 1. Auflage
  • |
  • erschienen am 7. April 2015
  • |
  • 1467 Seiten
 
E-Book | PDF mit Wasserzeichen-DRM | Systemvoraussetzungen
978-3-446-43981-8 (ISBN)
 
DIE C++-PROGRAMMIERSPRACHE//

- C++11 - zugänglich für Programmierer, die von C++98 oder anderen Sprachen kommen, wobei die vorgestellten Einblicke und Techniken selbst C++11-Spitzenprogrammierer unverzichtbar finden werden.
- Referenz und Tutorial für Programmierer, die C++ möglichst effektiv einsetzen möchten.
- Der neue C++11-Standard ermöglicht es Programmierern, Ideen klarer, einfacher und direkter auszudrücken sowie schnelleren und effizienteren Code zu schreiben.

Die C++-Programmiersprache ist eine akkurate, ausführlich erläuterte und ganzheitliche Darstellung der vollständigen Sprache - mit all ihren Instrumenten, Abstraktionsmechanismen, Standardbibliotheken und wichtigsten Entwurfstechniken. Stroustrup präsentiert das ganze Buch hindurch knappe, "reine C++11-Beispiele", die sowohl den Einsatz der Sprachmittel als auch den Programmentwurf anschaulich darstellen. Zum umfassenden Verständnis gibt der Autor zahlreiche Querverweise auf andere Stellen im Buch sowie auf den ISO-Standard an.

Neuigkeiten im Rahmen von C++11 sind
- Unterstützung für Nebenläufigkeit,
- reguläre Ausdrücke, Ressourcenverwaltungszeiger, Zufallszahlen und verbesserte Container,
- Allgemeine und einheitliche Initialisierung, vereinfachte for-Anweisungen, Verschiebesemantik und Unicode-Unterstützung,
- Lambda-Ausdrücke, allgemeine konstante Ausdrücke, Kontrolle über Standardwerte von Klassen, variadische Templates, Template-Alias und benutzerdefinierte Literale,
- Kompatibilitätsfragen.

AUS DEM INHALT //
Elementare Sprachmittel: Typ, Objekt, Gültigkeitsbereich, Speicherung, arithmetische Grundlagen und weitere // Modularität, die durch Namespaces, Quelldateien und Ausnahmenbehandlung unterstützt wird // C++-Abstraktion einschließlich Klassen, Klassenhierarchien und Templates für eine Synthese von herkömmlicher, objektorientierter und generischer Programmierung // Standardbibliothek: Container, Algorithmen, Iteratoren, Utilities, Strings, Stream-E/A, Locales, Numerik und weitere // Das grundlegende C++-Speichermodell im Detail
  • Deutsch
  • München
  • |
  • Deutschland
  • 10,80 MB
978-3-446-43981-8 (9783446439818)
http://dx.doi.org/10.3139/9783446439818
weitere Ausgaben werden ermittelt
Dr. Bjarne Stroustrup hat C++ entwickelt und als Erster implementiert. Er ist Professor an der Texas A&M University und Mitglied der US National Academy of Engineering, IEEE-Fellow und ACM-Fellow. Seine Forschungen befassen sich mit verteilten Systemen, Entwurf, Programmiertechniken, Softwareentwicklungs-Tools und Programmiersprachen. Er ist aktiv an der ISO-Standardisierung von C++ beteiligt.
1 - Inhalt [Seite 6]
2 - Vorwort [Seite 32]
3 - Teil I Einführung [Seite 36]
3.1 - 1 Vorbemerkungen [Seite 38]
3.1.1 - 1.1?Zum Aufbau dieses Buchs [Seite 38]
3.1.1.1 - 1.1.1?Einführung [Seite 39]
3.1.1.2 - 1.1.2?Grundlegende Sprachmittel [Seite 39]
3.1.1.3 - 1.1.3?Abstraktionsmechanismen [Seite 40]
3.1.1.4 - 1.1.4?Die Standardbibliothek [Seite 42]
3.1.1.5 - 1.1.5?Beispiele und Referenzen [Seite 43]
3.1.2 - 1.2?Der Entwurf von C++ [Seite 45]
3.1.2.1 - 1.2.1?Programmierstile [Seite 47]
3.1.2.2 - 1.2.2?Typprüfung [Seite 50]
3.1.2.3 - 1.2.3?C-Kompatibilität [Seite 51]
3.1.2.4 - 1.2.4?Sprache, Bibliotheken und Systeme [Seite 52]
3.1.3 - 1.3?C++ lernen [Seite 54]
3.1.3.1 - 1.3.1?In C++ programmieren [Seite 56]
3.1.3.2 - 1.3.2?Ratschläge für C++-Programmierer [Seite 57]
3.1.3.3 - 1.3.3?Ratschläge für C-Programmierer [Seite 58]
3.1.3.4 - 1.3.4?Ratschläge für Java-Programmierer [Seite 59]
3.1.4 - 1.4?Historische Anmerkungen [Seite 60]
3.1.4.1 - 1.4.1?Chronik [Seite 61]
3.1.4.2 - 1.4.2?Die frühen Jahre [Seite 62]
3.1.4.2.1 - 1.4.2.1?Sprachfeatures und Bibliotheksinstrumente [Seite 63]
3.1.4.3 - 1.4.3?Der 1998-Standard [Seite 65]
3.1.4.3.1 - 1.4.3.1?Sprachfeatures [Seite 65]
3.1.4.3.2 - 1.4.3.2?Die Standardbibliothek [Seite 66]
3.1.4.4 - 1.4.4?Der 2011-Standard [Seite 67]
3.1.4.4.1 - 1.4.4.1?Sprachfeatures [Seite 68]
3.1.4.4.2 - 1.4.4.2?Standardbibliothek [Seite 69]
3.1.4.5 - 1.4.5?Wofür wird C++ verwendet? [Seite 70]
3.1.5 - 1.5?Ratschläge [Seite 72]
3.1.6 - 1.6?Literaturhinweise [Seite 73]
3.2 - 2 Ein Rundreise durch C++: Die Grundlagen [Seite 78]
3.2.1 - 2.1?Einführung [Seite 78]
3.2.2 - 2.2?Die Grundlagen [Seite 79]
3.2.2.1 - 2.2.1?Hello, World! [Seite 79]
3.2.2.2 - 2.2.2?Typen, Variablen und Arithmetik [Seite 81]
3.2.2.3 - 2.2.3?Konstanten [Seite 83]
3.2.2.4 - 2.2.4?Tests und Schleifen [Seite 84]
3.2.2.5 - 2.2.5?Zeiger, Arrays und Schleifen [Seite 86]
3.2.3 - 2.3?Benutzerdefinierte Typen [Seite 88]
3.2.3.1 - 2.3.1?Strukturen [Seite 88]
3.2.3.2 - 2.3.2?Klassen [Seite 90]
3.2.3.3 - 2.3.3?Aufzählungen [Seite 92]
3.2.4 - 2.4?Modularität [Seite 93]
3.2.4.1 - 2.4.1?Separate Kompilierung [Seite 94]
3.2.4.2 - 2.4.2?Namespaces [Seite 95]
3.2.4.3 - 2.4.3?Fehlerbehandlung [Seite 96]
3.2.4.3.1 - 2.4.3.1?Ausnahmen [Seite 97]
3.2.4.3.2 - 2.4.3.2?Invarianten [Seite 98]
3.2.4.3.3 - 2.4.3.3?Statische Assertionen [Seite 99]
3.2.5 - 2.5?Nachbemerkung [Seite 100]
3.2.6 - 2.6?Ratschläge [Seite 100]
3.3 - 3 Eine Rundreise durch C++: Abstraktionsmechanismen [Seite 102]
3.3.1 - 3.1?Einführung [Seite 102]
3.3.2 - 3.2?Klassen [Seite 103]
3.3.2.1 - 3.2.1?Konkrete Typen [Seite 103]
3.3.2.1.1 - 3.2.1.1?Ein arithmetischer Typ [Seite 104]
3.3.2.1.2 - 3.2.1.2?Ein Container [Seite 106]
3.3.2.1.3 - 3.2.1.3?Container initialisieren [Seite 107]
3.3.2.2 - 3.2.2?Abstrakte Typen [Seite 108]
3.3.2.3 - 3.2.3?Virtuelle Funktionen [Seite 111]
3.3.2.4 - 3.2.4?Klassenhierarchien [Seite 112]
3.3.3 - 3.3?Kopieren und verschieben [Seite 116]
3.3.3.1 - 3.3.1?Container kopieren [Seite 116]
3.3.3.2 - 3.3.2?Container verschieben [Seite 118]
3.3.3.3 - 3.3.3?Ressourcenverwaltung [Seite 120]
3.3.3.4 - 3.3.4?Operationen unterdrücken [Seite 121]
3.3.4 - 3.4?Templates [Seite 122]
3.3.4.1 - 3.4.1?Parametrisierte Typen [Seite 122]
3.3.4.2 - 3.4.2?Funktions-Templates [Seite 123]
3.3.4.3 - 3.4.3?Funktionsobjekte [Seite 124]
3.3.4.4 - 3.4.4?Variadische Templates [Seite 127]
3.3.4.5 - 3.4.5?Alias [Seite 128]
3.3.5 - 3.5?Ratschläge [Seite 129]
3.4 - 4 Eine Rundreise durch C++: Container und Algorithmen [Seite 130]
3.4.1 - 4.1?Bibliotheken [Seite 130]
3.4.1.1 - 4.1.1?Überblick über die Standardbibliothek [Seite 131]
3.4.1.2 - 4.1.2?Header und Namespace der Standardbibliothek [Seite 132]
3.4.2 - 4.2?Strings [Seite 133]
3.4.3 - 4.3?Stream-Ein-/Ausgabe [Seite 135]
3.4.3.1 - 4.3.1?Ausgabe [Seite 135]
3.4.3.2 - 4.3.2?Eingabe [Seite 136]
3.4.3.3 - 4.3.3?Ein-/Ausgabe von benutzerdefinierten Typen [Seite 137]
3.4.4 - 4.4?Container [Seite 139]
3.4.4.1 - 4.4.1?vector [Seite 139]
3.4.4.1.1 - 4.4.1.1?Elemente [Seite 141]
3.4.4.1.2 - 4.4.1.2?Bereichsüberprüfung [Seite 141]
3.4.4.2 - 4.4.2?list [Seite 142]
3.4.4.3 - 4.4.3?map [Seite 144]
3.4.4.4 - 4.4.4?unordered_map [Seite 145]
3.4.4.5 - 4.4.5?Überblick über Container [Seite 145]
3.4.5 - 4.5?Algorithmen [Seite 147]
3.4.5.1 - 4.5.1?Iteratoren verwenden [Seite 148]
3.4.5.2 - 4.5.2?Iteratortypen [Seite 150]
3.4.5.3 - 4.5.3?Stream-Iteratoren [Seite 151]
3.4.5.4 - 4.5.4?Prädikate [Seite 153]
3.4.5.5 - 4.5.5?Überblick über Algorithmen [Seite 153]
3.4.5.6 - 4.5.6?Containeralgorithmen [Seite 154]
3.4.6 - 4.6?Ratschläge [Seite 155]
3.5 - 5 Eine Rundreise durch C++: Nebenläufigkeit und Dienstprogramme [Seite 156]
3.5.1 - 5.1?Einführung [Seite 156]
3.5.2 - 5.2?Ressourcenverwaltung [Seite 156]
3.5.2.1 - 5.2.1?unique_ptr und shared_ptr [Seite 157]
3.5.3 - 5.3?Nebenläufigkeit [Seite 159]
3.5.3.1 - 5.3.1?Tasks und Threads [Seite 160]
3.5.3.2 - 5.3.2?Argumente übergeben [Seite 161]
3.5.3.3 - 5.3.3?Ergebnisse zurückgeben [Seite 162]
3.5.3.4 - 5.3.4?Daten gemeinsam nutzen [Seite 162]
3.5.3.4.1 - 5.3.4.1?Warten auf Ereignisse [Seite 164]
3.5.3.5 - 5.3.5?Kommunizierende Tasks [Seite 165]
3.5.3.5.1 - 5.3.5.1?future und promise [Seite 166]
3.5.3.5.2 - 5.3.5.2?packaged_task [Seite 167]
3.5.3.5.3 - 5.3.5.3?async() [Seite 168]
3.5.4 - 5.4?Kleine Hilfskomponenten [Seite 169]
3.5.4.1 - 5.4.1?Zeit [Seite 169]
3.5.4.2 - 5.4.2?Typfunktionen [Seite 170]
3.5.4.2.1 - 5.4.2.1?iterator_traits [Seite 170]
3.5.4.2.2 - 5.4.2.2?Typprädikate [Seite 172]
3.5.4.3 - 5.4.3?pair und tuple [Seite 173]
3.5.5 - 5.5?Reguläre Ausdrücke [Seite 174]
3.5.6 - 5.6?Mathematik [Seite 175]
3.5.6.1 - 5.6.1?Mathematische Funktionen und Algorithmen [Seite 175]
3.5.6.2 - 5.6.2?Komplexe Zahlen [Seite 175]
3.5.6.3 - 5.6.3?Zufallszahlen [Seite 176]
3.5.6.4 - 5.6.4?Vektorarithmetik [Seite 178]
3.5.6.5 - 5.6.5?Numerische Grenzen [Seite 179]
3.5.7 - 5.7?Ratschläge [Seite 179]
4 - Teil II Grundlegende Sprachelemente [Seite 180]
4.1 - 6 Typen und Deklarationen [Seite 182]
4.1.1 - 6.1?Der ISO-C++-Standard [Seite 182]
4.1.1.1 - 6.1.1?Implementierungen [Seite 184]
4.1.1.2 - 6.1.2?Der grundlegende Quellzeichensatz [Seite 184]
4.1.2 - 6.2?Typen [Seite 185]
4.1.2.1 - 6.2.1?Fundamentale Typen [Seite 185]
4.1.2.2 - 6.2.2?Boolesche Typen [Seite 186]
4.1.2.3 - 6.2.3?Zeichentypen [Seite 188]
4.1.2.3.1 - 6.2.3.1?Vorzeichenbehaftete und vorzeichenlose Zeichen [Seite 190]
4.1.2.3.2 - 6.2.3.2?Zeichenliterale [Seite 191]
4.1.2.4 - 6.2.4?Ganzzahltypen [Seite 193]
4.1.2.4.1 - 6.2.4.1?Ganzzahlliterale [Seite 193]
4.1.2.4.2 - 6.2.4.2?Typen von Ganzzahlliteralen [Seite 194]
4.1.2.5 - 6.2.5?Gleitkommatypen [Seite 195]
4.1.2.5.1 - 6.2.5.1?Gleitkommaliterale [Seite 195]
4.1.2.6 - 6.2.6?Präfixe und Suffixe [Seite 196]
4.1.2.7 - 6.2.7?void [Seite 197]
4.1.2.8 - 6.2.8?Größen [Seite 197]
4.1.2.9 - 6.2.9?Ausrichtung [Seite 200]
4.1.3 - 6.3?Deklarationen [Seite 201]
4.1.3.1 - 6.3.1?Die Struktur von Deklarationen [Seite 203]
4.1.3.2 - 6.3.2?Mehrere Namen deklarieren [Seite 204]
4.1.3.3 - 6.3.3?Namen [Seite 205]
4.1.3.3.1 - 6.3.3.1?Schlüsselwörter [Seite 206]
4.1.3.4 - 6.3.4?Gültigkeitsbereiche [Seite 207]
4.1.3.5 - 6.3.5?Initialisierung [Seite 209]
4.1.3.5.1 - 6.3.5.1?Fehlende Initialisierer [Seite 212]
4.1.3.5.2 - 6.3.5.2?Initialisierungslisten [Seite 213]
4.1.3.6 - 6.3.6?Einen Typ herleiten: auto und decltype() [Seite 214]
4.1.3.6.1 - 6.3.6.1?Der Typspezifizierer auto [Seite 214]
4.1.3.6.2 - 6.3.6.2?auto und {}-Listen [Seite 215]
4.1.3.6.3 - 6.3.6.3?Der Spezifizierer decltype() [Seite 216]
4.1.4 - 6.4?Objekte und Werte [Seite 217]
4.1.4.1 - 6.4.1?L-Werte und R-Werte [Seite 217]
4.1.4.2 - 6.4.2?Lebensdauer von Objekten [Seite 218]
4.1.5 - 6.5?Typalias [Seite 219]
4.1.6 - 6.6?Ratschläge [Seite 220]
4.2 - 7 Zeiger, Arrays und Referenzen [Seite 222]
4.2.1 - 7.1?Einführung [Seite 222]
4.2.2 - 7.2?Zeiger [Seite 222]
4.2.2.1 - 7.2.1?void* [Seite 223]
4.2.2.2 - 7.2.2?nullptr [Seite 224]
4.2.3 - 7.3?Arrays [Seite 225]
4.2.3.1 - 7.3.1?Array-Initialisierer [Seite 226]
4.2.3.2 - 7.3.2?Stringliterale [Seite 227]
4.2.3.2.1 - 7.3.2.1?Rohe Zeichen-Strings [Seite 229]
4.2.3.2.2 - 7.3.2.2?Größere Zeichensätze [Seite 230]
4.2.4 - 7.4?Zeiger auf Arrays [Seite 231]
4.2.4.1 - 7.4.1?Navigieren in Arrays [Seite 233]
4.2.4.2 - 7.4.2?Mehrdimensionale Arrays [Seite 235]
4.2.4.3 - 7.4.3?Arrays übergeben [Seite 236]
4.2.5 - 7.5?Zeiger und const [Seite 238]
4.2.6 - 7.6?Zeiger und Besitz [Seite 240]
4.2.7 - 7.7?Referenzen [Seite 241]
4.2.7.1 - 7.7.1?L-Wert-Referenzen [Seite 243]
4.2.7.2 - 7.7.2?R-Wert-Referenzen [Seite 246]
4.2.7.3 - 7.7.3?Referenzen auf Referenzen [Seite 249]
4.2.7.4 - 7.7.4?Zeiger und Referenzen [Seite 250]
4.2.8 - 7.8?Ratschläge [Seite 252]
4.3 - 8 Strukturen, Unions und Aufzählungen [Seite 254]
4.3.1 - 8.1?Einführung [Seite 254]
4.3.2 - 8.2?Strukturen [Seite 254]
4.3.2.1 - 8.2.1?Layout einer Struktur [Seite 256]
4.3.2.2 - 8.2.2?Namen von Strukturen [Seite 257]
4.3.2.3 - 8.2.3?Strukturen und Klassen [Seite 259]
4.3.2.4 - 8.2.4?Strukturen und Arrays [Seite 260]
4.3.2.5 - 8.2.5?Typäquivalenz [Seite 262]
4.3.2.6 - 8.2.6?Plain Old Data [Seite 263]
4.3.2.7 - 8.2.7?Felder [Seite 265]
4.3.3 - 8.3?Unions [Seite 266]
4.3.3.1 - 8.3.1?Unions und Klassen [Seite 268]
4.3.3.2 - 8.3.2?Anonyme Unions [Seite 269]
4.3.4 - 8.4?Aufzählungen [Seite 272]
4.3.4.1 - 8.4.1?Aufzählungsklassen [Seite 272]
4.3.4.2 - 8.4.2?Einfache Aufzählungen [Seite 276]
4.3.4.3 - 8.4.3?Unbenannte Aufzählungen [Seite 278]
4.3.5 - 8.5?Ratschläge [Seite 278]
4.4 - 9 Anweisungen [Seite 280]
4.4.1 - 9.1?Einführung [Seite 280]
4.4.2 - 9.2?Zusammenfassung der Anweisungen [Seite 280]
4.4.3 - 9.3?Deklarationen als Anweisungen [Seite 282]
4.4.4 - 9.4?Auswahlanweisungen [Seite 283]
4.4.4.1 - 9.4.1?if-Anweisungen [Seite 283]
4.4.4.2 - 9.4.2?switch-Anweisungen [Seite 285]
4.4.4.2.1 - 9.4.2.1?Deklarationen in case-Zweigen [Seite 287]
4.4.4.3 - 9.4.3?Deklarationen in Bedingungen [Seite 287]
4.4.5 - 9.5?Schleifenanweisungen [Seite 288]
4.4.5.1 - 9.5.1?Bereichsbasierte for-Anweisungen [Seite 289]
4.4.5.2 - 9.5.2?for-Anweisungen [Seite 290]
4.4.5.3 - 9.5.3?while-Anweisungen [Seite 291]
4.4.5.4 - 9.5.4?do-Anweisungen [Seite 292]
4.4.5.5 - 9.5.5?Schleifen verlassen [Seite 292]
4.4.6 - 9.6?goto-Anweisungen [Seite 293]
4.4.7 - 9.7?Kommentare und Einrückungen [Seite 294]
4.4.8 - 9.8?Ratschläge [Seite 296]
4.5 - 10 Ausdrücke [Seite 298]
4.5.1 - 10.1?Einführung [Seite 298]
4.5.2 - 10.2?Ein Taschenrechner [Seite 298]
4.5.2.1 - 10.2.1?Der Parser [Seite 299]
4.5.2.2 - 10.2.2?Eingabe [Seite 303]
4.5.2.3 - 10.2.3?Low-level-Eingabe [Seite 307]
4.5.2.4 - 10.2.4?Fehlerbehandlung [Seite 309]
4.5.2.5 - 10.2.5?Das Rahmenprogramm [Seite 309]
4.5.2.6 - 10.2.6?Header [Seite 310]
4.5.2.7 - 10.2.7?Befehlszeilenargumente [Seite 311]
4.5.2.8 - 10.2.8?Eine Anmerkung zum Stil [Seite 312]
4.5.3 - 10.3?Zusammenfassung der Operatoren [Seite 313]
4.5.3.1 - 10.3.1?Ergebnisse [Seite 317]
4.5.3.2 - 10.3.2?Reihenfolge der Auswertung [Seite 318]
4.5.3.3 - 10.3.3?Operatorrangfolge [Seite 319]
4.5.3.4 - 10.3.4?Temporäre Objekte [Seite 320]
4.5.4 - 10.4?Konstante Ausdrücke [Seite 322]
4.5.4.1 - 10.4.1?Symbolische Konstanten [Seite 324]
4.5.4.2 - 10.4.2?const-Typen in konstanten Ausdrücken [Seite 325]
4.5.4.3 - 10.4.3?Literale Typen [Seite 325]
4.5.4.4 - 10.4.4?Referenzargumente [Seite 326]
4.5.4.5 - 10.4.5?Adresse konstanter Ausdrücke [Seite 327]
4.5.5 - 10.5?Implizite Typkonvertierung [Seite 327]
4.5.5.1 - 10.5.1?Heraufstufungen [Seite 328]
4.5.5.2 - 10.5.2?Konvertierungen [Seite 328]
4.5.5.2.1 - 10.5.2.1?Integrale Konvertierungen [Seite 329]
4.5.5.2.2 - 10.5.2.2?Gleitkommakonvertierungen [Seite 329]
4.5.5.2.3 - 10.5.2.3?Zeiger- und Referenzkonvertierungen [Seite 330]
4.5.5.2.4 - 10.5.2.4?Zeiger-auf-Member-Konvertierungen [Seite 330]
4.5.5.2.5 - 10.5.2.5?Boolesche Konvertierungen [Seite 330]
4.5.5.2.6 - 10.5.2.6?Gleitkomma-Ganzzahl-Konvertierungen [Seite 331]
4.5.5.3 - 10.5.3?Übliche arithmetische Konvertierungen [Seite 332]
4.5.6 - 10.6?Ratschläge [Seite 332]
4.6 - 11 Auswahloperationen [Seite 334]
4.6.1 - 11.1?Diverse Operatoren [Seite 334]
4.6.1.1 - 11.1.1?Logische Operatoren [Seite 334]
4.6.1.2 - 11.1.2?Bitweise logische Operatoren [Seite 334]
4.6.1.3 - 11.1.3?Bedingte Ausdrücke [Seite 336]
4.6.1.4 - 11.1.4?Inkrementieren und Dekrementieren [Seite 336]
4.6.2 - 11.2?Freispeicher [Seite 338]
4.6.2.1 - 11.2.1?Speicherverwaltung [Seite 340]
4.6.2.2 - 11.2.2?Arrays [Seite 343]
4.6.2.3 - 11.2.3?Speicherplatz beschaffen [Seite 344]
4.6.2.4 - 11.2.4?Überladen von new [Seite 345]
4.6.2.4.1 - 11.2.4.1?nothrow new [Seite 347]
4.6.3 - 11.3?Listen [Seite 348]
4.6.3.1 - 11.3.1?Implementierungsmodell [Seite 348]
4.6.3.2 - 11.3.2?Qualifizierte Listen [Seite 350]
4.6.3.3 - 11.3.3?Unqualifizierte Listen [Seite 350]
4.6.4 - 11.4?Lambda-Ausdrücke [Seite 352]
4.6.4.1 - 11.4.1?Implementierungsmodelle [Seite 353]
4.6.4.2 - 11.4.2?Alternativen für Lambda-Ausdrücke [Seite 354]
4.6.4.3 - 11.4.3?Erfassung [Seite 356]
4.6.4.3.1 - 11.4.3.1?Lambda und Lebensdauer [Seite 358]
4.6.4.3.2 - 11.4.3.2?Namen von Namespaces [Seite 359]
4.6.4.3.3 - 11.4.3.3?Lambda und this [Seite 359]
4.6.4.3.4 - 11.4.3.4?Veränderbare Lambda-Ausdrücke [Seite 359]
4.6.4.4 - 11.4.4?Aufruf und Rückgabe [Seite 360]
4.6.4.5 - 11.4.5?Der Typ eines Lambda-Ausdrucks [Seite 360]
4.6.5 - 11.5?Explizite Typumwandlung [Seite 361]
4.6.5.1 - 11.5.1?Konstruktion [Seite 363]
4.6.5.2 - 11.5.2?Benannte Typumwandlungen [Seite 364]
4.6.5.3 - 11.5.3?C-Typumwandlungen [Seite 366]
4.6.5.4 - 11.5.4?Funktionale Typumwandlung [Seite 366]
4.6.6 - 11.6?Ratschläge [Seite 367]
4.7 - 12 Funktionen [Seite 368]
4.7.1 - 12.1?Funktionsdeklarationen [Seite 368]
4.7.1.1 - 12.1.1?Warum Funktionen? [Seite 369]
4.7.1.2 - 12.1.2?Bestandteile einer Funktionsdeklaration [Seite 369]
4.7.1.3 - 12.1.3?Funktionsdefinitionen [Seite 370]
4.7.1.4 - 12.1.4?Werte zurückgeben [Seite 372]
4.7.1.5 - 12.1.5?Inline-Funktionen [Seite 374]
4.7.1.6 - 12.1.6?constexpr-Funktionen [Seite 375]
4.7.1.6.1 - 12.1.6.1?constexpr und Referenzen [Seite 376]
4.7.1.6.2 - 12.1.6.2?Bedingte Auswertung [Seite 377]
4.7.1.7 - 12.1.7?[[noreturn]]-Funktionen [Seite 377]
4.7.1.8 - 12.1.8?Lokale Variablen [Seite 378]
4.7.2 - 12.2?Argumentübergabe [Seite 379]
4.7.2.1 - 12.2.1?Referenzargumente [Seite 380]
4.7.2.2 - 12.2.2?Array-Argumente [Seite 382]
4.7.2.3 - 12.2.3?Listenargumente [Seite 384]
4.7.2.4 - 12.2.4?Nicht angegebene Anzahl von Argumenten [Seite 385]
4.7.2.5 - 12.2.5?Standardargumente [Seite 389]
4.7.3 - 12.3?Überladene Funktionen [Seite 391]
4.7.3.1 - 12.3.1?Automatische Auflösung von Überladungen [Seite 391]
4.7.3.2 - 12.3.2?Überladen und Rückgabetyp [Seite 393]
4.7.3.3 - 12.3.3?Überladen und Gültigkeitsbereiche [Seite 394]
4.7.3.4 - 12.3.4?Auflösung für mehrere Argumente [Seite 395]
4.7.3.5 - 12.3.5?Manuelle Auflösung von Überladungen [Seite 395]
4.7.4 - 12.4?Vor- und Nachbedingungen [Seite 396]
4.7.5 - 12.5?Zeiger auf Funktion [Seite 398]
4.7.6 - 12.6?Makros [Seite 402]
4.7.6.1 - 12.6.1?Bedingte Übersetzung [Seite 405]
4.7.6.2 - 12.6.2?Vordefinierte Makros [Seite 406]
4.7.6.3 - 12.6.3?Pragmas [Seite 407]
4.7.7 - 12.7?Ratschläge [Seite 407]
4.8 - 13 Ausnahmenbehandlung [Seite 410]
4.8.1 - 13.1?Fehlerbehandlung [Seite 410]
4.8.1.1 - 13.1.1?Ausnahmen [Seite 411]
4.8.1.2 - 13.1.2?Herkömmliche Fehlerbehandlung [Seite 413]
4.8.1.3 - 13.1.3?Durchhangeln [Seite 414]
4.8.1.4 - 13.1.4?Alternative Ansichten von Ausnahmen [Seite 415]
4.8.1.4.1 - 13.1.4.1?Asynchrone Ereignisse [Seite 415]
4.8.1.4.2 - 13.1.4.2?Ausnahmen, die keine Fehler sind [Seite 415]
4.8.1.5 - 13.1.5?Wann Sie keine Ausnahmen verwenden können [Seite 416]
4.8.1.6 - 13.1.6?Hierarchische Fehlerbehandlung [Seite 417]
4.8.1.7 - 13.1.7?Ausnahmen und Effizienz [Seite 419]
4.8.2 - 13.2?Ausnahmegarantien [Seite 421]
4.8.3 - 13.3?Ressourcenverwaltung [Seite 423]
4.8.3.1 - 13.3.1?finally [Seite 426]
4.8.4 - 13.4?Invarianten erzwingen [Seite 428]
4.8.5 - 13.5?Ausnahmen auslösen und abfangen [Seite 433]
4.8.5.1 - 13.5.1?Ausnahmen auslösen [Seite 433]
4.8.5.1.1 - 13.5.1.1?noexcept-Funktionen [Seite 435]
4.8.5.1.2 - 13.5.1.2?Der Operator noexcept [Seite 435]
4.8.5.1.3 - 13.5.1.3?Ausnahmespezifikationen [Seite 436]
4.8.5.2 - 13.5.2?Ausnahmen abfangen [Seite 437]
4.8.5.2.1 - 13.5.2.1?Ausnahmen erneut auslösen [Seite 438]
4.8.5.2.2 - 13.5.2.2?Jede Ausnahme abfangen [Seite 439]
4.8.5.2.3 - 13.5.2.3?Mehrere Handler [Seite 440]
4.8.5.2.4 - 13.5.2.4?try-Blöcke in Funktionen [Seite 440]
4.8.5.2.5 - 13.5.2.5?Beendigung [Seite 442]
4.8.5.3 - 13.5.3?Ausnahmen und Threads [Seite 444]
4.8.6 - 13.6?Eine vector-Implementierung [Seite 445]
4.8.6.1 - 13.6.1?Ein einfacher vector [Seite 445]
4.8.6.2 - 13.6.2?Speicher explizit darstellen [Seite 449]
4.8.6.3 - 13.6.3?Zuweisung [Seite 452]
4.8.6.4 - 13.6.4?Größe ändern [Seite 454]
4.8.6.4.1 - 13.6.4.1?reserve() [Seite 455]
4.8.6.4.2 - 13.6.4.2?resize() [Seite 456]
4.8.6.4.3 - 13.6.4.3?push_back() [Seite 456]
4.8.6.4.4 - 13.6.4.4?Abschließende Gedanken [Seite 457]
4.8.7 - 13.7?Ratschläge [Seite 458]
4.9 - 14 Namespaces [Seite 460]
4.9.1 - 14.1?Kompositionsprobleme [Seite 460]
4.9.2 - 14.2?Namespaces [Seite 461]
4.9.2.1 - 14.2.1?Explizite Qualifizierung [Seite 463]
4.9.2.2 - 14.2.2?using-Deklarationen [Seite 464]
4.9.2.3 - 14.2.3?using-Direktiven [Seite 465]
4.9.2.4 - 14.2.4?Argumentabhängige Namensauflösung [Seite 466]
4.9.2.5 - 14.2.5?Namespaces sind offen [Seite 469]
4.9.3 - 14.3?Modularisierung und Schnittstellen [Seite 470]
4.9.3.1 - 14.3.1?Namespaces als Module [Seite 471]
4.9.3.2 - 14.3.2?Implementierungen [Seite 473]
4.9.3.3 - 14.3.3?Schnittstellen und Implementierungen [Seite 475]
4.9.4 - 14.4?Komposition mit Namespaces [Seite 477]
4.9.4.1 - 14.4.1?Komfort vs. Sicherheit [Seite 477]
4.9.4.2 - 14.4.2?Namespace-Alias [Seite 478]
4.9.4.3 - 14.4.3?Namespaces zusammensetzen [Seite 479]
4.9.4.4 - 14.4.4?Komposition und Auswahl [Seite 480]
4.9.4.5 - 14.4.5?Namespaces und Überladen [Seite 481]
4.9.4.6 - 14.4.6?Versionsverwaltung [Seite 483]
4.9.4.7 - 14.4.7?Verschachtelte Namespaces [Seite 485]
4.9.4.8 - 14.4.8?Unbenannte Namespaces [Seite 486]
4.9.4.9 - 14.4.9?C-Header [Seite 487]
4.9.5 - 14.5?Ratschläge [Seite 488]
4.10 - 15 Quelldateien und Programme [Seite 490]
4.10.1 - 15.1?Separate Übersetzung [Seite 490]
4.10.2 - 15.2?Binden [Seite 491]
4.10.2.1 - 15.2.1?Dateilokale Namen [Seite 494]
4.10.2.2 - 15.2.2?Header-Dateien [Seite 495]
4.10.2.3 - 15.2.3?Die Eine-Definition-Regel [Seite 497]
4.10.2.4 - 15.2.4?Header der Standardbibliothek [Seite 499]
4.10.2.5 - 15.2.5?Binden mit Nicht-C++-Code [Seite 500]
4.10.2.6 - 15.2.6?Binden und Zeiger auf Funktionen [Seite 502]
4.10.3 - 15.3?Header-Dateien verwenden [Seite 503]
4.10.3.1 - 15.3.1?Organisation mit einzelnem Header [Seite 503]
4.10.3.2 - 15.3.2?Organisation mit mehreren Header-Dateien [Seite 507]
4.10.3.2.1 - 15.3.2.1?Andere Taschenrechnermodule [Seite 510]
4.10.3.2.2 - 15.3.2.2?Header verwenden [Seite 512]
4.10.3.3 - 15.3.3?Include-Wächter [Seite 513]
4.10.4 - 15.4?Programme [Seite 514]
4.10.4.1 - 15.4.1?Initialisierung von nichtlokalen Variablen [Seite 514]
4.10.4.2 - 15.4.2?Initialisierung und Nebenläufigkeit [Seite 515]
4.10.4.3 - 15.4.3?Programmbeendigung [Seite 516]
4.10.5 - 15.5?Ratschläge [Seite 518]
5 - Teil III Abstraktions­mechanismen [Seite 520]
5.1 - 16 Klassen [Seite 522]
5.1.1 - 16.1?Einführung [Seite 522]
5.1.2 - 16.2?Grundlagen von Klassen [Seite 523]
5.1.2.1 - 16.2.1?Member-Funktionen [Seite 524]
5.1.2.2 - 16.2.2?Standardmäßiges Kopieren [Seite 525]
5.1.2.3 - 16.2.3?Zugriffskontrolle [Seite 526]
5.1.2.4 - 16.2.4?class und struct [Seite 527]
5.1.2.5 - 16.2.5?Konstruktoren [Seite 529]
5.1.2.6 - 16.2.6?Explizite Konstruktoren [Seite 531]
5.1.2.7 - 16.2.7?Klasseninterne Initialisierer [Seite 533]
5.1.2.8 - 16.2.8?Klasseninterne Funktionsdefinitionen [Seite 534]
5.1.2.9 - 16.2.9?Veränderlichkeit [Seite 535]
5.1.2.9.1 - 16.2.9.1?Konstante Member-Funktionen [Seite 535]
5.1.2.9.2 - 16.2.9.2?Physische und logische Konstanz [Seite 536]
5.1.2.9.3 - 16.2.9.3?mutable [Seite 537]
5.1.2.9.4 - 16.2.9.4?Veränderlichkeit über Indirektion [Seite 537]
5.1.2.10 - 16.2.10?Selbstreferenz [Seite 538]
5.1.2.11 - 16.2.11?Member-Zugriff [Seite 540]
5.1.2.12 - 16.2.12?Statische Member [Seite 541]
5.1.2.13 - 16.2.13?Member-Typen [Seite 543]
5.1.3 - 16.3?Konkrete Klassen [Seite 544]
5.1.3.1 - 16.3.1?Member-Funktionen [Seite 547]
5.1.3.2 - 16.3.2?Hilfsfunktionen [Seite 550]
5.1.3.3 - 16.3.3?Überladene Operatoren [Seite 551]
5.1.3.4 - 16.3.4?Der Stellenwert von konkreten Klassen [Seite 552]
5.1.4 - 16.4?Ratschläge [Seite 553]
5.2 - 17 Konstruieren, Aufräumen, Kopieren und Verschieben [Seite 556]
5.2.1 - 17.1?Einführung [Seite 556]
5.2.2 - 17.2?Konstruktoren und Destruktoren [Seite 558]
5.2.2.1 - 17.2.1?Konstruktoren und Invarianten [Seite 559]
5.2.2.2 - 17.2.2?Destruktoren und Ressourcen [Seite 560]
5.2.2.3 - 17.2.3?Basis- und Member-Destruktoren [Seite 561]
5.2.2.4 - 17.2.4?Konstruktoren und Destruktoren aufrufen [Seite 562]
5.2.2.5 - 17.2.5?Virtuelle Destruktoren [Seite 563]
5.2.3 - 17.3?Initialisierung von Klassenobjekten [Seite 564]
5.2.3.1 - 17.3.1?Initialisierung ohne Konstruktoren [Seite 564]
5.2.3.2 - 17.3.2?Initialisierung mithilfe von Konstruktoren [Seite 566]
5.2.3.2.1 - 17.3.2.1?Initialisierung durch Konstruktoren [Seite 568]
5.2.3.3 - 17.3.3?Standardkonstruktoren [Seite 569]
5.2.3.4 - 17.3.4?Initialisierungslisten-Konstruktoren [Seite 571]
5.2.3.4.1 - 17.3.4.1?Mehrdeutigkeiten bei Initialisierungslisten-Konstruktoren auflösen [Seite 572]
5.2.3.4.2 - 17.3.4.2?Initialisierungslisten verwenden [Seite 573]
5.2.3.4.3 - 17.3.4.3?Direkte und Kopierinitialisierung [Seite 574]
5.2.4 - 17.4 Initialisierung von Membern und Basisklassen [Seite 576]
5.2.4.1 - 17.4.1?Member-Initialisierung [Seite 576]
5.2.4.1.1 - 17.4.1.1?Member-Initialisierung und -Zuweisung [Seite 577]
5.2.4.2 - 17.4.2?Basisklassen-Initialisierer [Seite 578]
5.2.4.3 - 17.4.3?Konstruktoren delegieren [Seite 578]
5.2.4.4 - 17.4.4?Klasseninterne Initialisierer [Seite 579]
5.2.4.5 - 17.4.5?Initialisierer statischer Member [Seite 581]
5.2.5 - 17.5?Kopieren und verschieben [Seite 582]
5.2.5.1 - 17.5.1?Kopieren [Seite 583]
5.2.5.1.1 - 17.5.1.1?Vorsicht vor Standardkonstruktoren [Seite 585]
5.2.5.1.2 - 17.5.1.2?Kopieren von Basisklassen [Seite 585]
5.2.5.1.3 - 17.5.1.3?Was Kopieren bedeutet [Seite 586]
5.2.5.1.4 - 17.5.1.4?Slicing [Seite 589]
5.2.5.2 - 17.5.2?Verschieben [Seite 590]
5.2.6 - 17.6?Standardoperationen generieren [Seite 594]
5.2.6.1 - 17.6.1?Explizite Standardoperationen [Seite 595]
5.2.6.2 - 17.6.2?Standardoperationen [Seite 596]
5.2.6.3 - 17.6.3?Standardoperationen verwenden [Seite 597]
5.2.6.3.1 - 17.6.3.1?Standardkonstruktoren [Seite 597]
5.2.6.3.2 - 17.6.3.2?Invarianten bewahren [Seite 597]
5.2.6.3.3 - 17.6.3.3?Ressourceninvarianten [Seite 598]
5.2.6.3.4 - 17.6.3.4?Partiell spezifizierte Invarianten [Seite 599]
5.2.6.4 - 17.6.4?Gelöschte Funktionen [Seite 601]
5.2.7 - 17.7?Ratschläge [Seite 603]
5.3 - 18 Überladen von Operatoren [Seite 606]
5.3.1 - 18.1?Einführung [Seite 606]
5.3.2 - 18.2?Operatorfunktionen [Seite 608]
5.3.2.1 - 18.2.1?Binäre und unäre Operatoren [Seite 609]
5.3.2.2 - 18.2.2?Vordefinierte Bedeutungen für Operatoren [Seite 610]
5.3.2.3 - 18.2.3?Operatoren und benutzerdefinierte Typen [Seite 611]
5.3.2.4 - 18.2.4?Objekte übergeben [Seite 611]
5.3.2.5 - 18.2.5?Operatoren in Namespaces [Seite 613]
5.3.3 - 18.3?Ein Typ für komplexe Zahlen [Seite 615]
5.3.3.1 - 18.3.1?Member- und Nicht-Member-Operatoren [Seite 615]
5.3.3.2 - 18.3.2?Arithmetik mit gemischten Datentypen [Seite 616]
5.3.3.3 - 18.3.3?Konvertierungen [Seite 617]
5.3.3.3.1 - 18.3.3.1?Konvertierung von Operanden [Seite 619]
5.3.3.4 - 18.3.4?Literale [Seite 620]
5.3.3.5 - 18.3.5?Zugriffsfunktionen [Seite 621]
5.3.3.6 - 18.3.6?Hilfsfunktionen [Seite 622]
5.3.4 - 18.4?Typumwandlung [Seite 623]
5.3.4.1 - 18.4.1?Konvertierungsoperatoren [Seite 623]
5.3.4.2 - 18.4.2?Explizite Konvertierungsoperatoren [Seite 625]
5.3.4.3 - 18.4.3?Mehrdeutigkeiten [Seite 626]
5.3.5 - 18.5?Ratschläge [Seite 628]
5.4 - 19 Spezielle Operatoren [Seite 630]
5.4.1 - 19.1?Einführung [Seite 630]
5.4.2 - 19.2?Spezielle Operatoren [Seite 630]
5.4.2.1 - 19.2.1?Indizierung [Seite 630]
5.4.2.2 - 19.2.2?Funktionsaufruf [Seite 631]
5.4.2.3 - 19.2.3?Dereferenzieren [Seite 633]
5.4.2.4 - 19.2.4?Inkrementieren und Dekrementieren [Seite 635]
5.4.2.5 - 19.2.5?Allokation und Deallokation [Seite 637]
5.4.2.6 - 19.2.6?Benutzerdefinierte Literale [Seite 639]
5.4.3 - 19.3?Eine String-Klasse [Seite 642]
5.4.3.1 - 19.3.1?Wesentliche Operationen [Seite 643]
5.4.3.2 - 19.3.2?Zugriff auf Zeichen [Seite 643]
5.4.3.3 - 19.3.3?Darstellung [Seite 644]
5.4.3.3.1 - 19.3.3.1?Ergänzende Funktionen [Seite 646]
5.4.3.4 - 19.3.4?Member-Funktionen [Seite 647]
5.4.3.5 - 19.3.5?Hilfsfunktionen [Seite 650]
5.4.3.6 - 19.3.6?Unsere String-Klasse verwenden [Seite 652]
5.4.4 - 19.4?Friends [Seite 652]
5.4.4.1 - 19.4.1?Friends finden [Seite 654]
5.4.4.2 - 19.4.2?Friends und Member [Seite 655]
5.4.5 - 19.5?Ratschläge [Seite 657]
5.5 - 20 Abgeleitete Klassen [Seite 660]
5.5.1 - 20.1?Einführung [Seite 660]
5.5.2 - 20.2?Abgeleitete Klassen [Seite 661]
5.5.2.1 - 20.2.1?Member-Funktionen [Seite 664]
5.5.2.2 - 20.2.2?Konstruktoren und Destruktoren [Seite 665]
5.5.3 - 20.3?Klassenhierarchien [Seite 666]
5.5.3.1 - 20.3.1?Typfelder [Seite 666]
5.5.3.2 - 20.3.2?Virtuelle Funktionen [Seite 669]
5.5.3.3 - 20.3.3?Explizite Qualifizierung [Seite 672]
5.5.3.4 - 20.3.4?Überschreiben steuern [Seite 672]
5.5.3.4.1 - 20.3.4.1?override [Seite 674]
5.5.3.4.2 - 20.3.4.2?final [Seite 675]
5.5.3.5 - 20.3.5?Member der Basisklasse verwenden [Seite 677]
5.5.3.5.1 - 20.3.5.1?Konstruktoren vererben [Seite 678]
5.5.3.6 - 20.3.6?Lockerung bei Rückgabetypen [Seite 680]
5.5.4 - 20.4?Abstrakte Klassen [Seite 682]
5.5.5 - 20.5?Zugriffskontrolle [Seite 684]
5.5.5.1 - 20.5.1?Geschützte Member [Seite 688]
5.5.5.1.1 - 20.5.1.1?Geschützte Member verwenden [Seite 689]
5.5.5.2 - 20.5.2?Zugriff auf Basisklassen [Seite 689]
5.5.5.2.1 - 20.5.2.1?Mehrfachvererbung und Zugriffskontrolle [Seite 690]
5.5.5.3 - 20.5.3?using-Deklarationen und Zugriffskontrolle [Seite 691]
5.5.6 - 20.6?Zeiger auf Member [Seite 692]
5.5.6.1 - 20.6.1?Zeiger auf Funktions-Member [Seite 692]
5.5.6.2 - 20.6.2?Zeiger auf Daten-Member [Seite 694]
5.5.6.3 - 20.6.3?Basis- und abgeleitete Member [Seite 695]
5.5.7 - 20.7?Ratschläge [Seite 696]
5.6 - 21 Klassenhierarchien [Seite 698]
5.6.1 - 21.1?Einführung [Seite 698]
5.6.2 - 21.2?Klassenhierarchien entwerfen [Seite 698]
5.6.2.1 - 21.2.1?Implementierungsvererbung [Seite 699]
5.6.2.1.1 - 21.2.1.1?Kritische Betrachtungen [Seite 702]
5.6.2.2 - 21.2.2?Schnittstellenvererbung [Seite 703]
5.6.2.3 - 21.2.3?Alternative Implementierungen [Seite 705]
5.6.2.3.1 - 21.2.3.1?Kritische Betrachtungen [Seite 708]
5.6.2.4 - 21.2.4?Objekterstellung örtlich begrenzen [Seite 709]
5.6.3 - 21.3?Mehrfachvererbung [Seite 710]
5.6.3.1 - 21.3.1?Mehrfachschnittstellen [Seite 711]
5.6.3.2 - 21.3.2?Mehrere Implementierungsklassen [Seite 711]
5.6.3.3 - 21.3.3?Auflösung von Mehrdeutigkeiten [Seite 713]
5.6.3.4 - 21.3.4?Eine Basisklasse wiederholt verwenden [Seite 717]
5.6.3.5 - 21.3.5?Virtuelle Basisklassen [Seite 718]
5.6.3.5.1 - 21.3.5.1?Virtuelle Basisklassen konstruieren [Seite 721]
5.6.3.5.2 - 21.3.5.2?Member einer virtuellen Klasse nur einmal aufrufen [Seite 722]
5.6.3.6 - 21.3.6?Replizierte und virtuelle Basisklassen [Seite 724]
5.6.3.6.1 - 21.3.6.1?Funktionen virtueller Basisklassen überschreiben [Seite 726]
5.6.4 - 21.4?Ratschläge [Seite 727]
5.7 - 22 Laufzeit-Typinformationen [Seite 728]
5.7.1 - 22.1?Einführung [Seite 728]
5.7.2 - 22.2?Navigation in der Klassenhierarchie [Seite 728]
5.7.2.1 - 22.2.1?dynamic_cast [Seite 730]
5.7.2.1.1 - 22.2.1.1?dynamic_cast in Referenz [Seite 732]
5.7.2.2 - 22.2.2?Mehrfachvererbung [Seite 733]
5.7.2.3 - 22.2.3?static_cast und dynamic_cast [Seite 735]
5.7.2.4 - 22.2.4?Eine Schnittstelle zurückgewinnen [Seite 736]
5.7.3 - 22.3?Doppelte Bindung und Besucher [Seite 740]
5.7.3.1 - 22.3.1?Doppelte Bindung [Seite 741]
5.7.3.2 - 22.3.2?Besucher [Seite 743]
5.7.4 - 22.4?Konstruktion und Destruktion [Seite 745]
5.7.5 - 22.5?Typidentifizierung [Seite 746]
5.7.5.1 - 22.5.1?Erweiterte Typinformationen [Seite 748]
5.7.6 - 22.6?RTTI - richtig und falsch eingesetzt [Seite 749]
5.7.7 - 22.7?Ratschläge [Seite 751]
5.8 - 23 Templates [Seite 754]
5.8.1 - 23.1?Einführung und Überblick [Seite 754]
5.8.2 - 23.2?Ein einfaches String-Template [Seite 757]
5.8.2.1 - 23.2.1?Ein Template definieren [Seite 759]
5.8.2.2 - 23.2.2?Template-Instanziierung [Seite 760]
5.8.3 - 23.3?Typprüfung [Seite 761]
5.8.3.1 - 23.3.1?Typäquivalenz [Seite 763]
5.8.3.2 - 23.3.2?Fehlererkennung [Seite 764]
5.8.4 - 23.4?Member von Klassen-Templates [Seite 765]
5.8.4.1 - 23.4.1?Daten-Member [Seite 765]
5.8.4.2 - 23.4.2?Member-Funktionen [Seite 766]
5.8.4.3 - 23.4.3?Member-Typalias [Seite 766]
5.8.4.4 - 23.4.4?Statische Member [Seite 767]
5.8.4.5 - 23.4.5?Member-Typen [Seite 767]
5.8.4.6 - 23.4.6?Member-Templates [Seite 768]
5.8.4.6.1 - 23.4.6.1?Templates und Konstruktoren [Seite 769]
5.8.4.6.2 - 23.4.6.2?Templates und virtual [Seite 770]
5.8.4.6.3 - 23.4.6.3?Verschachtelungen [Seite 770]
5.8.4.7 - 23.4.7?Friends [Seite 773]
5.8.5 - 23.5?Funktions-Templates [Seite 774]
5.8.5.1 - 23.5.1?Argumente von Funktions-Templates [Seite 776]
5.8.5.2 - 23.5.2?Funktions-Template-Argumente herleiten [Seite 777]
5.8.5.2.1 - 23.5.2.1?Referenzherleitung [Seite 778]
5.8.5.3 - 23.5.3?Überladen von Funktions-Templates [Seite 780]
5.8.5.3.1 - 23.5.3.1?Mehrdeutigkeiten auflösen [Seite 781]
5.8.5.3.2 - 23.5.3.2?Fehler bei Argumentersetzung [Seite 782]
5.8.5.3.3 - 23.5.3.3?Überladen und Ableitung [Seite 784]
5.8.5.3.4 - 23.5.3.4?Überladen und nicht hergeleitete Parameter [Seite 784]
5.8.6 - 23.6?Template-Alias [Seite 785]
5.8.7 - 23.7?Quellcodeorganisation [Seite 786]
5.8.7.1 - 23.7.1?Binden [Seite 788]
5.8.8 - 23.8?Ratschläge [Seite 789]
5.9 - 24 Generische Programmierung [Seite 792]
5.9.1 - 24.1?Einführung [Seite 792]
5.9.2 - 24.2?Algorithmen und Lifting [Seite 793]
5.9.3 - 24.3?Konzepte [Seite 797]
5.9.3.1 - 24.3.1?Ein Konzept erkennen [Seite 798]
5.9.3.2 - 24.3.2?Konzepte und Einschränkungen [Seite 801]
5.9.4 - 24.4?Konzepte konkret machen [Seite 803]
5.9.4.1 - 24.4.1?Axiome [Seite 807]
5.9.4.2 - 24.4.2?Konzepte mit mehreren Argumenten [Seite 808]
5.9.4.3 - 24.4.3?Wertkonzepte [Seite 810]
5.9.4.4 - 24.4.4?Einschränkungsüberprüfungen [Seite 810]
5.9.4.5 - 24.4.5?Überprüfung von Template-Definitionen [Seite 812]
5.9.5 - 24.5?Ratschläge [Seite 814]
5.10 - 25 Spezialisierung [Seite 816]
5.10.1 - 25.1?Einführung [Seite 816]
5.10.2 - 25.2?Template-Parameter und -Argumente [Seite 817]
5.10.2.1 - 25.2.1?Typen als Argumente [Seite 817]
5.10.2.2 - 25.2.2?Werte als Argumente [Seite 819]
5.10.2.3 - 25.2.3?Operationen als Argumente [Seite 821]
5.10.2.4 - 25.2.4?Templates als Argumente [Seite 823]
5.10.2.5 - 25.2.5?Template-Standardargumente [Seite 824]
5.10.2.5.1 - 25.2.5.1?Standardargumente bei Funktions-Templates [Seite 825]
5.10.3 - 25.3?Spezialisierung [Seite 826]
5.10.3.1 - 25.3.1?Schnittstellenspezialisierung [Seite 829]
5.10.3.1.1 - 25.3.1.1?Implementierungsspezialisierung [Seite 830]
5.10.3.2 - 25.3.2?Das primäre Template [Seite 830]
5.10.3.3 - 25.3.3?Reihenfolge der Spezialisierung [Seite 832]
5.10.3.4 - 25.3.4?Funktions-Template-Spezialisierung [Seite 833]
5.10.3.4.1 - 25.3.4.1?Spezialisierung und Überladen [Seite 833]
5.10.3.4.2 - 25.3.4.2?Spezialisierung, die kein Überladen ist [Seite 834]
5.10.4 - 25.4?Ratschläge [Seite 835]
5.11 - 26 Instanziierung [Seite 836]
5.11.1 - 26.1?Einführung [Seite 836]
5.11.2 - 26.2?Template-Instanziierung [Seite 837]
5.11.2.1 - 26.2.1?Wann wird Instanziierung gebraucht? [Seite 838]
5.11.2.2 - 26.2.2?Manuelle Kontrolle der Instanziierung [Seite 839]
5.11.3 - 26.3?Namensbindung [Seite 840]
5.11.3.1 - 26.3.1?Abhängige Namen [Seite 842]
5.11.3.2 - 26.3.2?Bindung am Punkt der Definition [Seite 844]
5.11.3.3 - 26.3.3?Bindung am Punkt der Instanziierung [Seite 845]
5.11.3.4 - 26.3.4?Mehrere Punkte der Instanziierung [Seite 847]
5.11.3.5 - 26.3.5?Templates und Namespaces [Seite 849]
5.11.3.6 - 26.3.6?Zu aggressive ADL [Seite 850]
5.11.3.7 - 26.3.7?Namen aus Basisklassen [Seite 852]
5.11.4 - 26.4?Ratschläge [Seite 854]
5.12 - 27 Templates und Hierarchien [Seite 856]
5.12.1 - 27.1?Einführung [Seite 856]
5.12.2 - 27.2?Parametrisierung und Hierarchie [Seite 857]
5.12.2.1 - 27.2.1?Generierte Typen [Seite 859]
5.12.2.2 - 27.2.2?Template-Konvertierungen [Seite 861]
5.12.3 - 27.3?Hierarchien von Klassen-Templates [Seite 862]
5.12.3.1 - 27.3.1?Templates als Schnittstellen [Seite 864]
5.12.4 - 27.4?Template-Parameter als Basisklassen [Seite 864]
5.12.4.1 - 27.4.1?Datenstrukturen zusammensetzen [Seite 865]
5.12.4.2 - 27.4.2?Klassenhierarchien linearisieren [Seite 869]
5.12.5 - 27.5?Ratschläge [Seite 874]
5.13 - 28 Metaprogrammierung [Seite 876]
5.13.1 - 28.1?Einführung [Seite 876]
5.13.2 - 28.2?Typfunktionen [Seite 878]
5.13.2.1 - 28.2.1?Typalias [Seite 881]
5.13.2.1.1 - 28.2.1.1?Wann man keinen Alias verwendet [Seite 882]
5.13.2.2 - 28.2.2?Typprädikate [Seite 883]
5.13.2.3 - 28.2.3?Eine Funktion auswählen [Seite 885]
5.13.2.4 - 28.2.4?Traits [Seite 885]
5.13.3 - 28.3?Steuerungsstrukturen [Seite 887]
5.13.3.1 - 28.3.1?Auswahl [Seite 887]
5.13.3.1.1 - 28.3.1.1?Zwischen zwei Typen auswählen [Seite 888]
5.13.3.1.2 - 28.3.1.2?Übersetzungszeit versus Laufzeit [Seite 888]
5.13.3.1.3 - 28.3.1.3?Zwischen mehreren Typen auswählen [Seite 890]
5.13.3.2 - 28.3.2?Iteration und Rekursion [Seite 891]
5.13.3.2.1 - 28.3.2.1?Rekursion mit Klassen [Seite 892]
5.13.3.3 - 28.3.3?Wann man Metaprogrammierung verwendet [Seite 892]
5.13.4 - 28.4?Bedingte Definition: Enable_if [Seite 894]
5.13.4.1 - 28.4.1?Enable_if verwenden [Seite 895]
5.13.4.2 - 28.4.2?Enable_if implementieren [Seite 897]
5.13.4.3 - 28.4.3?Enable_if und Konzepte [Seite 898]
5.13.4.4 - 28.4.4?Weitere Beispiele mit Enable_if [Seite 898]
5.13.5 - 28.5?Eine Liste zur Übersetzungszeit: Tuple [Seite 901]
5.13.5.1 - 28.5.1?Eine einfache Ausgabefunktion [Seite 903]
5.13.5.2 - 28.5.2?Elementzugriff [Seite 904]
5.13.5.2.1 - 28.5.2.1?Konstante Tupel [Seite 906]
5.13.5.3 - 28.5.3?make_tuple [Seite 907]
5.13.6 - 28.6?Variadische Templates [Seite 908]
5.13.6.1 - 28.6.1?Eine typsichere printf()-Funktion [Seite 908]
5.13.6.2 - 28.6.2?Technische Details [Seite 911]
5.13.6.3 - 28.6.3?Weiterleitung [Seite 913]
5.13.6.4 - 28.6.4?Der Typ tuple der Standardbibliothek [Seite 914]
5.13.7 - 28.7?Beispiel: SI-Einheiten [Seite 918]
5.13.7.1 - 28.7.1?Einheiten [Seite 918]
5.13.7.2 - 28.7.2?Größen [Seite 919]
5.13.7.3 - 28.7.3?Literale für Einheiten [Seite 921]
5.13.7.4 - 28.7.4?Hilfsfunktionen [Seite 923]
5.13.8 - 28.8?Ratschläge [Seite 924]
5.14 - 29 Ein Matrix-Design [Seite 926]
5.14.1 - 29.1?Einführung [Seite 926]
5.14.1.1 - 29.1.1?Einfache Anwendungen von Matrix [Seite 926]
5.14.1.2 - 29.1.2?Anforderungen an Matrix [Seite 928]
5.14.2 - 29.2?Ein Matrix-Template [Seite 929]
5.14.2.1 - 29.2.1?Konstruktion und Zuweisung [Seite 931]
5.14.2.2 - 29.2.2?Indizierung und Slicing [Seite 932]
5.14.3 - 29.3?Arithmetische Matrix-Operationen [Seite 935]
5.14.3.1 - 29.3.1?Skalaroperationen [Seite 936]
5.14.3.2 - 29.3.2?Addition [Seite 936]
5.14.3.3 - 29.3.3?Multiplikation [Seite 938]
5.14.4 - 29.4?Matrix-Implementierung [Seite 940]
5.14.4.1 - 29.4.1?slice() [Seite 940]
5.14.4.2 - 29.4.2?Matrix-Slices [Seite 940]
5.14.4.3 - 29.4.3?Matrix_ref [Seite 942]
5.14.4.4 - 29.4.4?Matrix-Listeninitialisierung [Seite 943]
5.14.4.5 - 29.4.5?Matrix-Zugriff [Seite 945]
5.14.4.6 - 29.4.6?Nulldimensionale Matrix [Seite 948]
5.14.5 - 29.5?Lineare Gleichungen lösen [Seite 949]
5.14.5.1 - 29.5.1?Das klassische gaußsche Eliminationsverfahren [Seite 950]
5.14.5.2 - 29.5.2?Pivotisierung [Seite 951]
5.14.5.3 - 29.5.3?Testen [Seite 952]
5.14.5.4 - 29.5.4?Verschmolzene Operationen [Seite 953]
5.14.6 - 29.6?Ratschläge [Seite 956]
6 - Teil IVDie Standardbibliothek [Seite 958]
6.1 - 30 Überblick über die Standardbibliothek [Seite 960]
6.1.1 - 30.1?Einführung [Seite 960]
6.1.1.1 - 30.1.1?Komponenten der Standardbibliothek [Seite 961]
6.1.1.2 - 30.1.2?Designeinschränkungen [Seite 962]
6.1.1.3 - 30.1.3?Beschreibungsstil [Seite 964]
6.1.2 - 30.2?Header [Seite 964]
6.1.3 - 30.3?Sprachunterstützung [Seite 969]
6.1.3.1 - 30.3.1?Unterstützung für Initialisierungslisten [Seite 969]
6.1.3.2 - 30.3.2?Unterstützung für bereichsbasierte for-Anweisung [Seite 970]
6.1.4 - 30.4?Fehlerbehandlung [Seite 970]
6.1.4.1 - 30.4.1?Ausnahmen [Seite 971]
6.1.4.1.1 - 30.4.1.1?Die Hierarchie der Standardausnahmen [Seite 972]
6.1.4.1.2 - 30.4.1.2?Weiterleitung von Ausnahmen [Seite 973]
6.1.4.1.3 - 30.4.1.3?terminate() [Seite 976]
6.1.4.2 - 30.4.2?Assertionen [Seite 976]
6.1.4.3 - 30.4.3?system_error [Seite 977]
6.1.4.3.1 - 30.4.3.1?Fehlercodes [Seite 978]
6.1.4.3.2 - 30.4.3.2?Fehlerkategorien [Seite 980]
6.1.4.3.3 - 30.4.3.3?system_error-Ausnahme [Seite 981]
6.1.4.3.4 - 30.4.3.4?Potenziell portable Fehlerbedingungen [Seite 982]
6.1.4.3.5 - 30.4.3.5?Fehlercodes zuordnen [Seite 982]
6.1.4.3.6 - 30.4.3.6?errc-Fehlercodes [Seite 984]
6.1.4.3.7 - 30.4.3.7?future_errc-Fehlercodes [Seite 987]
6.1.4.3.8 - 30.4.3.8?io_errc-Fehlercodes [Seite 987]
6.1.5 - 30.5?Ratschläge [Seite 987]
6.2 - 31 STL-Container [Seite 990]
6.2.1 - 31.1?Einführung [Seite 990]
6.2.2 - 31.2?Überblick über Container [Seite 990]
6.2.2.1 - 31.2.1?Containerdarstellung [Seite 993]
6.2.2.2 - 31.2.2?Anforderungen an die Elemente [Seite 995]
6.2.2.2.1 - 31.2.2.1?Vergleiche [Seite 996]
6.2.2.2.2 - 31.2.2.2?Andere relationale Operatoren [Seite 997]
6.2.3 - 31.3?Operatoren im Überblick [Seite 998]
6.2.3.1 - 31.3.1?Member-Typen [Seite 1001]
6.2.3.2 - 31.3.2?Konstruktoren, Destruktor und Zuweisungen [Seite 1002]
6.2.3.3 - 31.3.3?Größe und Kapazität [Seite 1004]
6.2.3.4 - 31.3.4?Iteratoren [Seite 1004]
6.2.3.5 - 31.3.5?Elementzugriff [Seite 1006]
6.2.3.6 - 31.3.6?Stack-Operationen [Seite 1006]
6.2.3.7 - 31.3.7?Listenoperationen [Seite 1007]
6.2.3.8 - 31.3.8?Andere Operationen [Seite 1008]
6.2.4 - 31.4?Container [Seite 1009]
6.2.4.1 - 31.4.1?vector [Seite 1009]
6.2.4.1.1 - 31.4.1.1?vector und Wachstum [Seite 1009]
6.2.4.1.2 - 31.4.1.2?vector und Verschachtelung [Seite 1011]
6.2.4.1.3 - 31.4.1.3?vector und Arrays [Seite 1013]
6.2.4.1.4 - 31.4.1.4?vector und string [Seite 1013]
6.2.4.2 - 31.4.2?Listen [Seite 1014]
6.2.4.3 - 31.4.3?Assoziative Container [Seite 1016]
6.2.4.3.1 - 31.4.3.1?Geordnete assoziative Container [Seite 1017]
6.2.4.3.2 - 31.4.3.2?Ungeordnete assoziative Container [Seite 1021]
6.2.4.3.3 - 31.4.3.3?Ungeordnete Maps konstruieren [Seite 1022]
6.2.4.3.4 - 31.4.3.4?Hash- und Gleichheitsfunktionen [Seite 1024]
6.2.4.3.5 - 31.4.3.5?Lastfaktor und Buckets [Seite 1027]
6.2.5 - 31.5?Containeradapter [Seite 1028]
6.2.5.1 - 31.5.1?stack [Seite 1029]
6.2.5.2 - 31.5.2?queue [Seite 1031]
6.2.5.3 - 31.5.3?priority_queue [Seite 1031]
6.2.6 - 31.6?Ratschläge [Seite 1032]
6.3 - 32 STL-Algorithmen [Seite 1036]
6.3.1 - 32.1?Einführung [Seite 1036]
6.3.2 - 32.2?Algorithmen [Seite 1036]
6.3.2.1 - 32.2.1?Sequenzen [Seite 1037]
6.3.3 - 32.3?Richtlinienargumente [Seite 1038]
6.3.3.1 - 32.3.1?Komplexität [Seite 1040]
6.3.4 - 32.4 Nichtmodifizierende Sequenz­algorithmen [Seite 1041]
6.3.4.1 - 32.4.1?for_each() [Seite 1041]
6.3.4.2 - 32.4.2?Sequenzprädikate [Seite 1041]
6.3.4.3 - 32.4.3?count() [Seite 1042]
6.3.4.4 - 32.4.4?find() [Seite 1042]
6.3.4.5 - 32.4.5?equal() und mismatch() [Seite 1043]
6.3.4.6 - 32.4.6?search() [Seite 1044]
6.3.5 - 32.5?Modifizierende Sequenzalgorithmen [Seite 1045]
6.3.5.1 - 32.5.1?copy() [Seite 1046]
6.3.5.2 - 32.5.2?unique() [Seite 1047]
6.3.5.3 - 32.5.3?remove(), reverse() und replace() [Seite 1048]
6.3.5.4 - 32.5.4?rotate(), random_shuffle() und partition() [Seite 1049]
6.3.5.5 - 32.5.5?Permutationen [Seite 1050]
6.3.5.6 - 32.5.6?fill() [Seite 1051]
6.3.5.7 - 32.5.7?swap() [Seite 1052]
6.3.6 - 32.6?Sortieren und Suchen [Seite 1053]
6.3.6.1 - 32.6.1?Binäre Suche [Seite 1056]
6.3.6.2 - 32.6.2?merge() [Seite 1057]
6.3.6.3 - 32.6.3?Mengenalgorithmen [Seite 1058]
6.3.6.4 - 32.6.4?Heaps [Seite 1059]
6.3.6.5 - 32.6.5?lexicographical_compare() [Seite 1061]
6.3.7 - 32.7?Minimum und Maximum [Seite 1061]
6.3.8 - 32.8?Ratschläge [Seite 1063]
6.4 - 33 STL-Iteratoren [Seite 1064]
6.4.1 - 33.1?Einführung [Seite 1064]
6.4.1.1 - 33.1.1?Iteratormodell [Seite 1064]
6.4.1.2 - 33.1.2?Iteratorkategorien [Seite 1066]
6.4.1.3 - 33.1.3?Iterator-Traits [Seite 1067]
6.4.1.4 - 33.1.4?Iteratoroperationen [Seite 1070]
6.4.2 - 33.2?Iteratoradapter [Seite 1071]
6.4.2.1 - 33.2.1?Reverse-Iteratoren [Seite 1071]
6.4.2.2 - 33.2.2?Einfügeiteratoren [Seite 1074]
6.4.2.3 - 33.2.3?Verschiebeiteratoren [Seite 1075]
6.4.3 - 33.3?Bereichszugriffsfunktionen [Seite 1076]
6.4.4 - 33.4?Funktionsobjekte [Seite 1077]
6.4.5 - 33.5?Funktionsadapter [Seite 1078]
6.4.5.1 - 33.5.1?bind() [Seite 1079]
6.4.5.2 - 33.5.2?mem_fn() [Seite 1081]
6.4.5.3 - 33.5.3?function [Seite 1081]
6.4.6 - 33.6?Ratschläge [Seite 1084]
6.5 - 34 Speicher und Ressourcen [Seite 1086]
6.5.1 - 34.1?Einführung [Seite 1086]
6.5.2 - 34.2?"Beinahe-Container" [Seite 1086]
6.5.2.1 - 34.2.1?array [Seite 1087]
6.5.2.2 - 34.2.2?bitset [Seite 1090]
6.5.2.2.1 - 34.2.2.1?Konstruktoren [Seite 1091]
6.5.2.2.2 - 34.2.2.2?bitset-Operationen [Seite 1093]
6.5.2.3 - 34.2.3?vector [Seite 1095]
6.5.2.4 - 34.2.4?Tupel [Seite 1096]
6.5.2.4.1 - 34.2.4.1?pair [Seite 1096]
6.5.2.4.2 - 34.2.4.2?tuple [Seite 1098]
6.5.3 - 34.3?Ressourcenverwaltungszeiger [Seite 1100]
6.5.3.1 - 34.3.1?unique_ptr [Seite 1101]
6.5.3.2 - 34.3.2?shared_ptr [Seite 1104]
6.5.3.3 - 34.3.3?weak_ptr [Seite 1108]
6.5.4 - 34.4?Allokatoren [Seite 1111]
6.5.4.1 - 34.4.1?Der Standard-Allokator [Seite 1112]
6.5.4.2 - 34.4.2?Allokator-Traits [Seite 1114]
6.5.4.3 - 34.4.3?Zeiger-Traits [Seite 1115]
6.5.4.4 - 34.4.4?Allokatoren mit eigenem Gültigkeitsbereich [Seite 1115]
6.5.5 - 34.5?Die Schnittstelle zur Garbage Collection [Seite 1117]
6.5.6 - 34.6?Nichtinitialisierter Speicher [Seite 1120]
6.5.6.1 - 34.6.1?Temporäre Puffer [Seite 1121]
6.5.6.2 - 34.6.2?raw_storage_iterator [Seite 1121]
6.5.7 - 34.7?Ratschläge [Seite 1123]
6.6 - 35 Utilities [Seite 1124]
6.6.1 - 35.1?Einführung [Seite 1124]
6.6.2 - 35.2?Zeit [Seite 1124]
6.6.2.1 - 35.2.1?duration [Seite 1125]
6.6.2.2 - 35.2.2?time_point [Seite 1128]
6.6.2.3 - 35.2.3?Zeitgeber [Seite 1130]
6.6.2.4 - 35.2.4?Zeit-Traits [Seite 1131]
6.6.3 - 35.3 Rationale Arithmetik zur ­Übersetzungszeit [Seite 1132]
6.6.4 - 35.4?Typfunktionen [Seite 1134]
6.6.4.1 - 35.4.1?Typ-Traits [Seite 1134]
6.6.4.2 - 35.4.2?Typgeneratoren [Seite 1139]
6.6.5 - 35.5?Kleinere Utilities [Seite 1144]
6.6.5.1 - 35.5.1?move() and forward() [Seite 1144]
6.6.5.2 - 35.5.2?swap() [Seite 1145]
6.6.5.3 - 35.5.3?Relationale Operatoren [Seite 1146]
6.6.5.4 - 35.5.4?Vergleichen und Hashing von type_info [Seite 1147]
6.6.6 - 35.6?Ratschläge [Seite 1148]
6.7 - 36 Strings [Seite 1150]
6.7.1 - 36.1?Einführung [Seite 1150]
6.7.2 - 36.2?Zeichenklassifizierung [Seite 1150]
6.7.2.1 - 36.2.1?Klassifizierungsfunktionen [Seite 1150]
6.7.2.2 - 36.2.2?Zeichen-Traits [Seite 1152]
6.7.3 - 36.3?Strings [Seite 1153]
6.7.3.1 - 36.3.1?string im Vergleich zu C-Strings [Seite 1154]
6.7.3.2 - 36.3.2?Konstruktoren [Seite 1156]
6.7.3.3 - 36.3.3?Fundamentale Operationen [Seite 1158]
6.7.3.4 - 36.3.4?String-Ein-/Ausgabe [Seite 1160]
6.7.3.5 - 36.3.5?Numerische Konvertierungen [Seite 1160]
6.7.3.6 - 36.3.6?STL-ähnliche Operationen [Seite 1162]
6.7.3.7 - 36.3.7?Die find-Familie [Seite 1165]
6.7.3.8 - 36.3.8?Teilstrings [Seite 1167]
6.7.4 - 36.4?Ratschläge [Seite 1168]
6.8 - 37 Reguläre Ausdrücke [Seite 1170]
6.8.1 - 37.1?Reguläre Ausdrücke [Seite 1170]
6.8.1.1 - 37.1.1?Notation regulärer Ausdrücke [Seite 1171]
6.8.2 - 37.2?regex [Seite 1176]
6.8.2.1 - 37.2.1?Übereinstimmungsergebnisse [Seite 1178]
6.8.2.2 - 37.2.2?Formatierung [Seite 1181]
6.8.3 - 37.3?Funktionen für reguläre Ausdrücke [Seite 1182]
6.8.3.1 - 37.3.1?regex_match() [Seite 1182]
6.8.3.2 - 37.3.2?regex_search() [Seite 1184]
6.8.3.3 - 37.3.3?regex_replace() [Seite 1185]
6.8.4 - 37.4?Iteratoren für reguläre Ausdrücke [Seite 1187]
6.8.4.1 - 37.4.1?regex_iterator [Seite 1187]
6.8.4.2 - 37.4.2?regex_token_iterator [Seite 1188]
6.8.5 - 37.5?regex_traits [Seite 1191]
6.8.6 - 37.6?Ratschläge [Seite 1192]
6.9 - 38 E/A-Streams [Seite 1194]
6.9.1 - 38.1?Einführung [Seite 1194]
6.9.2 - 38.2?Die E/A-Stream-Hierarchie [Seite 1196]
6.9.2.1 - 38.2.1?Datei-Streams [Seite 1197]
6.9.2.2 - 38.2.2?String-Streams [Seite 1199]
6.9.3 - 38.3?Fehlerbehandlung [Seite 1201]
6.9.4 - 38.4?Ein-/Ausgabeoperationen [Seite 1203]
6.9.4.1 - 38.4.1?Eingabeoperationen [Seite 1203]
6.9.4.1.1 - 38.4.1.1?Formatierte Eingabe [Seite 1204]
6.9.4.1.2 - 38.4.1.2?Unformatierte Eingabe [Seite 1205]
6.9.4.2 - 38.4.2?Ausgabeoperationen [Seite 1206]
6.9.4.2.1 - 38.4.2.1?Virtuelle Ausgabefunktionen [Seite 1208]
6.9.4.3 - 38.4.3?Manipulatoren [Seite 1209]
6.9.4.4 - 38.4.4?Stream-Status [Seite 1210]
6.9.4.5 - 38.4.5?Formatierung [Seite 1214]
6.9.4.5.1 - 38.4.5.1?Formatierungsstatus [Seite 1215]
6.9.4.5.2 - 38.4.5.2?Standardmanipulatoren [Seite 1217]
6.9.4.5.3 - 38.4.5.3?Benutzerdefinierte Manipulatoren [Seite 1220]
6.9.5 - 38.5?Stream-Iteratoren [Seite 1222]
6.9.6 - 38.6?Puffer [Seite 1223]
6.9.6.1 - 38.6.1?Ausgabe-Streams und -puffer [Seite 1227]
6.9.6.2 - 38.6.2?Eingabe-Streams und -puffer [Seite 1228]
6.9.6.3 - 38.6.3?Pufferiteratoren [Seite 1229]
6.9.6.3.1 - 38.6.3.1?istreambuf_iterator [Seite 1230]
6.9.6.3.2 - 38.6.3.2?ostreambuf_iterator [Seite 1231]
6.9.7 - 38.7?Ratschläge [Seite 1231]
6.10 - 39 Locales [Seite 1234]
6.10.1 - 39.1?Kulturelle Unterschiede behandeln [Seite 1234]
6.10.2 - 39.2?Die Klasse locale [Seite 1237]
6.10.2.1 - 39.2.1?Benannte Locales [Seite 1239]
6.10.2.1.1 - 39.2.1.1?Neue Locales konstruieren [Seite 1242]
6.10.2.2 - 39.2.2?Strings vergleichen [Seite 1243]
6.10.3 - 39.3?Die Klasse facet [Seite 1244]
6.10.3.1 - 39.3.1?Auf Facetten in einem Locale zugreifen [Seite 1245]
6.10.3.2 - 39.3.2?Eine einfache benutzerdefinierte Facette [Seite 1246]
6.10.3.3 - 39.3.3?Locales und Facetten verwenden [Seite 1249]
6.10.4 - 39.4?Standardfacetten [Seite 1250]
6.10.4.1 - 39.4.1?String-Vergleich [Seite 1252]
6.10.4.1.1 - 39.4.1.1?Benannte collate-Facetten [Seite 1255]
6.10.4.2 - 39.4.2?Numerische Formatierung [Seite 1255]
6.10.4.2.1 - 39.4.2.1?Numerische Interpunktion [Seite 1256]
6.10.4.2.2 - 39.4.2.2?Numerische Ausgabe [Seite 1257]
6.10.4.2.3 - 39.4.2.3?Numerische Eingabe [Seite 1260]
6.10.4.3 - 39.4.3?Formatierung von Geldbeträgen [Seite 1261]
6.10.4.3.1 - 39.4.3.1?Interpunktion bei Geldbeträgen [Seite 1262]
6.10.4.3.2 - 39.4.3.2?Ausgabe von Geldbeträgen [Seite 1265]
6.10.4.3.3 - 39.4.3.3?Eingabe von Geldbeträgen [Seite 1266]
6.10.4.4 - 39.4.4?Datum und Uhrzeit formatieren [Seite 1267]
6.10.4.4.1 - 39.4.4.1?time_put [Seite 1267]
6.10.4.4.2 - 39.4.4.2?time_get [Seite 1268]
6.10.4.5 - 39.4.5?Zeichenklassifizierung [Seite 1270]
6.10.4.6 - 39.4.6?Zeichencodes konvertieren [Seite 1274]
6.10.4.7 - 39.4.7?Meldungen [Seite 1278]
6.10.4.7.1 - 39.4.7.1?Meldungen von anderen Facetten verwenden [Seite 1281]
6.10.5 - 39.5?Komfortschnittstellen [Seite 1282]
6.10.5.1 - 39.5.1?Zeichenklassifizierung [Seite 1282]
6.10.5.2 - 39.5.2?Zeichenkonvertierungen [Seite 1283]
6.10.5.3 - 39.5.3?String-Konvertierungen [Seite 1283]
6.10.5.4 - 39.5.4?Pufferkonvertierungen [Seite 1285]
6.10.6 - 39.6?Ratschläge [Seite 1285]
6.11 - 40 Numerische Berechnungen [Seite 1288]
6.11.1 - 40.1?Einführung [Seite 1288]
6.11.2 - 40.2?Numerische Grenzen [Seite 1288]
6.11.2.1 - 40.2.1?Makros für Grenzwerte [Seite 1291]
6.11.3 - 40.3?Mathematische Standardfunktionen [Seite 1292]
6.11.4 - 40.4?Komplexe Zahlen [Seite 1294]
6.11.5 - 40.5?Ein numerisches Array: valarray [Seite 1295]
6.11.5.1 - 40.5.1?Konstruktoren und Zuweisungen [Seite 1296]
6.11.5.2 - 40.5.2?Indizierung [Seite 1298]
6.11.5.3 - 40.5.3?Operationen [Seite 1299]
6.11.5.4 - 40.5.4?Slices [Seite 1302]
6.11.5.5 - 40.5.5?slice_array [Seite 1304]
6.11.5.6 - 40.5.6?Verallgemeinerte Slices [Seite 1305]
6.11.6 - 40.6 Verallgemeinerte numerische ­Algorithmen [Seite 1306]
6.11.6.1 - 40.6.1?accumulate() [Seite 1307]
6.11.6.2 - 40.6.2?inner_product() [Seite 1308]
6.11.6.3 - 40.6.3?partial_sum() und adjacent_difference() [Seite 1309]
6.11.6.4 - 40.6.4?iota() [Seite 1310]
6.11.7 - 40.7?Zufallszahlen [Seite 1310]
6.11.7.1 - 40.7.1?Zufallszahlenmodule [Seite 1313]
6.11.7.2 - 40.7.2?Zufallsgerät [Seite 1315]
6.11.7.3 - 40.7.3?Verteilungen [Seite 1316]
6.11.7.4 - 40.7.4?Zufallszahlen im Stil von C [Seite 1320]
6.11.8 - 40.8?Ratschläge [Seite 1321]
6.12 - 41 Nebenläufigkeit [Seite 1322]
6.12.1 - 41.1?Einführung [Seite 1322]
6.12.2 - 41.2?Speichermodelle [Seite 1324]
6.12.2.1 - 41.2.1?Speicherstellen [Seite 1325]
6.12.2.2 - 41.2.2?Umordnung von Befehlen [Seite 1326]
6.12.2.3 - 41.2.3?Speicherordnung [Seite 1327]
6.12.2.4 - 41.2.4?Data Races [Seite 1328]
6.12.3 - 41.3?Atomare Datentypen [Seite 1330]
6.12.3.1 - 41.3.1?Atomare Typen [Seite 1333]
6.12.3.2 - 41.3.2?Flags und Fences [Seite 1338]
6.12.3.3 - 41.3.3?Atomare Flags [Seite 1338]
6.12.3.3.1 - 41.3.3.1?Fences [Seite 1339]
6.12.4 - 41.4?volatile [Seite 1339]
6.12.5 - 41.5?Ratschläge [Seite 1340]
6.13 - 42 Threads und Tasks [Seite 1342]
6.13.1 - 42.1?Einführung [Seite 1342]
6.13.2 - 42.2?Threads [Seite 1342]
6.13.2.1 - 42.2.1?Identität [Seite 1344]
6.13.2.2 - 42.2.2?Konstruktion [Seite 1345]
6.13.2.3 - 42.2.3?Zerstörung [Seite 1346]
6.13.2.4 - 42.2.4?join() [Seite 1347]
6.13.2.5 - 42.2.5?detach() [Seite 1348]
6.13.2.6 - 42.2.6?Namespace this_thread [Seite 1350]
6.13.2.7 - 42.2.7?Einen Thread vorzeitig beenden [Seite 1351]
6.13.2.8 - 42.2.8?thread_local-Daten [Seite 1351]
6.13.3 - 42.3?Data Races vermeiden [Seite 1353]
6.13.3.1 - 42.3.1?Mutexe [Seite 1354]
6.13.3.1.1 - 42.3.1.1?mutex und recursive_mutex [Seite 1355]
6.13.3.1.2 - 42.3.1.2?mutex-Fehler [Seite 1357]
6.13.3.1.3 - 42.3.1.3?timed_mutex und recursive_timed_mutex [Seite 1358]
6.13.3.1.4 - 42.3.1.4?lock_guard und unique_lock [Seite 1359]
6.13.3.2 - 42.3.2?Mehrere Sperren [Seite 1363]
6.13.3.3 - 42.3.3?call_once() [Seite 1364]
6.13.3.4 - 42.3.4?Bedingungsvariablen [Seite 1365]
6.13.3.4.1 - 42.3.4.1?condition_variable_any [Seite 1370]
6.13.4 - 42.4?Task-basierte Nebenläufigkeit [Seite 1371]
6.13.4.1 - 42.4.1?future und promise [Seite 1372]
6.13.4.2 - 42.4.2?promise [Seite 1373]
6.13.4.3 - 42.4.3?packaged_task [Seite 1374]
6.13.4.4 - 42.4.4?future [Seite 1377]
6.13.4.5 - 42.4.5?shared_future [Seite 1380]
6.13.4.6 - 42.4.6?async() [Seite 1381]
6.13.4.7 - 42.4.7?Ein paralleles find()-Beispiel [Seite 1384]
6.13.5 - 42.5?Ratschläge [Seite 1388]
6.14 - 43 Die C-Standard­bibliothek [Seite 1390]
6.14.1 - 43.1?Einführung [Seite 1390]
6.14.2 - 43.2?Dateien [Seite 1390]
6.14.3 - 43.3?Die printf()-Familie [Seite 1391]
6.14.4 - 43.4?C-Strings [Seite 1396]
6.14.5 - 43.5?Speicher [Seite 1397]
6.14.6 - 43.6?Datum und Uhrzeit [Seite 1399]
6.14.7 - 43.7?Diverses [Seite 1402]
6.14.8 - 43.8?Ratschläge [Seite 1404]
6.15 - 44 Kompatibilität [Seite 1406]
6.15.1 - 44.1?Einführung [Seite 1406]
6.15.2 - 44.2?C++11-Erweiterungen [Seite 1407]
6.15.2.1 - 44.2.1?Sprachfeatures [Seite 1407]
6.15.2.2 - 44.2.2?Komponenten der Standardbibliothek [Seite 1408]
6.15.2.3 - 44.2.3?Veraltete Features [Seite 1409]
6.15.2.4 - 44.2.4?Umgang mit älteren C++-Implementierungen [Seite 1410]
6.15.3 - 44.3?C/C++-Kompatibilität [Seite 1411]
6.15.3.1 - 44.3.1?C und C++ sind Geschwister [Seite 1411]
6.15.3.2 - 44.3.2?"Stillschweigende" Unterschiede [Seite 1413]
6.15.3.3 - 44.3.3?C-Code, der kein C++ ist [Seite 1414]
6.15.3.3.1 - 44.3.3.1?Probleme mit "klassischem C" [Seite 1417]
6.15.3.3.2 - 44.3.3.2?C-Features, die von C++ nicht übernommen wurden [Seite 1417]
6.15.3.4 - 44.3.4?C++-Code, der kein C ist [Seite 1417]
6.15.4 - 44.4?Ratschläge [Seite 1419]
7 - Index [Seite 1422]

Dateiformat: PDF
Kopierschutz: Wasserzeichen-DRM (Digital Rights Management)

Systemvoraussetzungen:

Computer (Windows; MacOS X; Linux): Verwenden Sie zum Lesen die kostenlose Software Adobe Reader, Adobe Digital Editions oder einen anderen PDF-Viewer Ihrer Wahl (siehe E-Book Hilfe).

Tablet/Smartphone (Android; iOS): Installieren Sie die kostenlose App Adobe Digital Editions oder eine andere Lese-App für E-Books (siehe E-Book Hilfe).

E-Book-Reader: Bookeen, Kobo, Pocketbook, Sony, Tolino u.v.a.m. (nur bedingt: Kindle)

Das Dateiformat PDF zeigt auf jeder Hardware eine Buchseite stets identisch an. Daher ist eine PDF auch für ein komplexes Layout geeignet, wie es bei Lehr- und Fachbüchern verwendet wird (Bilder, Tabellen, Spalten, Fußnoten). Bei kleinen Displays von E-Readern oder Smartphones sind PDF leider eher nervig, weil zu viel Scrollen notwendig ist. Mit Wasserzeichen-DRM wird hier ein "weicher" Kopierschutz verwendet. Daher ist technisch zwar alles möglich - sogar eine unzulässige Weitergabe. Aber an sichtbaren und unsichtbaren Stellen wird der Käufer des E-Books als Wasserzeichen hinterlegt, sodass im Falle eines Missbrauchs die Spur zurückverfolgt werden kann.

Weitere Informationen finden Sie in unserer E-Book Hilfe.


Download (sofort verfügbar)

39,99 €
inkl. 7% MwSt.
Download / Einzel-Lizenz
PDF mit Wasserzeichen-DRM
siehe Systemvoraussetzungen
E-Book bestellen