C ++ Sprache. Programmierschule. Edition VI - Stephen Prata - Auslaufprodukt

Warnung!

Das Buch wurde durch eine Neuauflage ersetzt - check it out!

Inhalt

Danksagungen (19)

Einführung (21)

Kapitel 1. Erste Schritte (31)

• C++ lernen – was erwartet uns? (31)
• Der Ursprung von C++ – Eine kurze Geschichte (32)
  
  • C-Sprache (32)
  • Die C-Programmierphilosophie (33)
  • Eine Änderung in C ++ - Objektorientierte Programmierung
  • C++ und verallgemeinerte Programmierung (35)
  • Der Ursprung von C++
• Portabilität und Standards (37)
  
  • Sprachentwicklung in Zahlen (38)
  • Die C++-Standards in diesem Buch
• Programmiermechanik (39)
  
  • Quellcode schreiben (40)
  • Zusammenstellung und Konsolidierung (41)
• Zusammenfassung (45)

Kapitel 2. Ihr erstes C++-Programm 47

• C ++ - Der Anfang (47)
  
  • Merkmale der Hauptfunktion () Funktion 49
  • Kommentare in C++ 51
  • Der Präprozessor und die iostream-Datei 52
  • Header-Dateinamen (53)
  • Namensräume
  • Datenausgabe - cout (55)
  • C++-Quellcode formatieren 57
• C++-Anweisungen 59
  
  • Deklarationsanweisungen und Variablen
  • Abtretungserklärung (61)
  • Der neue Cout-Trick (62)
• Andere C++-Anweisungen
  
  • Verwendung von cin (63)
  • Beitritt zu cout
  • cin und cout - klassen zum ersten mal (64)
• Eigenschaften (66)
  
  • Verwenden einer Funktion, die einen Wert zurückgibt (66)
  • Funktionsvariationen (69)
  • Benutzerdefinierte Funktionen (70)
  • Benutzerfunktionen, die einen Wert zurückgeben
  • Die using-Direktive in Programmen mit mehreren Funktionen
• Zusammenfassung (76)
• Wiederholungsfragen 77
• Programmierübungen (77)

Kapitel 3. Daten

• Einfache Variablen
  
  • Variablennamen
  • Ganzzahltypen 81
  • Kurz, int, lang und lang lang
  • Unsignierte Typen
  • Auswahl des richtigen Typs (89)
  • Ganzzahlige Literale
  • Wie bestimmt C++ den Typ einer Konstante? (91)
  • Typ char - Zeichen und Kleinbuchstaben (92)
  • Der boolsche Datentyp (100)
• Const (100) Qualifizierer
• Fließkommazahlen 101
  
  • Fließkommazahlen schreiben 102
  • Fließkommadatentypen 103
  • Fließkommakonstanten 105
  • Die Vor- und Nachteile von Floating Point 105
• C++ Arithmetische Operatoren 106
  
  • Betriebsablauf – Bedienerprioritäten und Konnektivität 107
  • Variationen zu Abteilung 108
  • Der Modulo-Operator (110)
  • Typumwandlungen
  • Automatische Typdeklarationen in C ++ 11 116
• Zusammenfassung (117)
• Wiederholungsfragen 117
• Programmierübungen (118)

Kapitel 4. Komplexe Typen 121

• Übersichtstafeln (122)
  
  • Programmnotizen (124)
  • Arrays initialisieren 124
  • Initialisieren von Arrays in C ++ 11 125
• Ketten (126)
  
  • Kombinieren von Zeichenfolgenliteralen 127
  • Zeichenfolgen in einem Array
  • Probleme bei der Eingabe von Zeichenfolgen 129
  • Strings mit Linien lesen
  • Hashing von Strings und Zahlen in der Eingabe 134
• Die Saitenklasse - eine Einführung
  
  • String-Initialisierung in C++ 11 136
  • Zuweisung, Verkettung und Anhängen 136
  • Andere Zeichenfolgenklassenoperationen 138
  • Die String-Klasse und die Ein- und Ausgabe 139
  • Andere Variationen von String-Literalen 141
• Strukturen (142)
  
  • Verwenden einer Struktur in einem Programm
  • Initialisieren von Strukturen in C ++ 11 145
  • Kann ein String-Feld in einer Struktur verwendet werden? (146)
  • Andere Merkmale von Strukturen
  • Arrays von Strukturen
  • Bitfelder (149)
• Gewerkschaften (149)
• Aufzählungstypen
  
  • Enumeratorwerte setzen 153
  • Wertebereiche in Aufzählungstypen
• Zeiger und Sonstiges (154)
  
  • Zeiger deklarieren und initialisieren 156
  • Die Gefahren von Pointern 158
  • Zeiger und Zahlen (159)
  • Verwenden des New-Operators zum Zuweisen von Speicher
  • Speicher freigeben mit delete 161
  • Verwenden von new zum Erstellen dynamischer Arrays 162
• Zeiger, Arrays und Zeigerarithmetik 165
  
  • Zusammenfassung der Informationen zu den Indikatoren (168)
  • Lehren und Ketten (170)
  • Verwenden von new zum Erstellen dynamischer Strukturen 174
  • Speicherzuweisung: Automatisch, statisch und dynamisch
• Geben Sie Kombinationen ein
• Arrays anders (181)
  
  • Die Vektorvorlagenklasse 181
  • Das Template-Klassenarray (C++ 11) 182
  • Vergleich von Arrays mit Vector und Array 183
• Zusammenfassung (184)
• Wiederholungsfragen 185
• Programmierübungen (186)

Kapitel 5. Schleifen und relationale Ausdrücke 189

• Für Schleifen
  
  • Die Elemente einer for-Schleife 191
  • Wir gehen zurück zur for-Schleife (196)
  • Ändern der Schrittweite (198)
  • Die For-Schleife und Strings 198
  • Die Inkrement- (++) und Dekrement-Operatoren (-) 199
  • Nebenwirkungen und Benchmarks 200
  • Präfix- und Suffixformen 201
  • Die Inkrement- und Dekrementoperatoren und Zeiger 202
  • Zusammengesetzte Zuweisungsoperatoren 203
  • Zusammengesetzte Anweisungen oder Blöcke 203
  • Das Komma als Operator (und einige Syntaxtricks) 205
  • Beziehungsausdrücke 208
  • Zuschreibung, Vergleiche und Fehler
  • Vergleich von C-Style Saiten 210
  • String-Objekte vergleichen 213
• While-Schleife 213
  
  • Programmnotizen (215)
  • Die for-Schleife und die while-Schleife 216
  • Warten Sie eine Minute - wir erstellen eine Verzögerungsschleife (217)
• Führe While-Schleife 219 aus
• Bereich für Schleifen (C ++ 11) 221
• Schleifen und Texteingabe 221
  
  • Die einfachste Version von cin (222)
  • cin.get (char) um zu helfen (223)
  • Welche Version von cin.get() ist besser? (224)
  • Dateiende (224)
  • Noch eine andere Version von cin.get () 227
• Verschachtelte Schleifen und 2D-Arrays 230
  
  • Initialisieren von zweidimensionalen Arrays 232
  • Zweidimensionale Arrays verwenden 232
• Zusammenfassung (234)
• Wiederholungsfragen 234
• Programmierübungen (235)

Kapitel 6. Bedingte Anweisungen und logische Operatoren 237

• Die if-Anweisung 237
  
  • Sonst 239
  • Formatieren einer if else-Anweisung 241
  • Die if else if else Konstruktion (241)
• Logische Ausdrücke 243
  
  • Logischer alternativer Operator - || (243)
  • Logischer Konjunktionsoperator - && (245)
  • Gültigkeitsbereich mit dem Operator && 247
  • Logischer Negationsoperator -! (248)
  • Über logische Operatoren 250
  • Alternative Schreibweise 251
• Die cctype-Bibliothek
• Bediener?: (253)
• Die switch-Anweisung (255)
  
  • Verwendung von Enumeratoren als Labels 258
  • switch versus if else (259)
• Pause und weiter 250
  
  • Programmnotizen (261)
• Schleifen beim Lesen von Zahlen 262
  
  • Programmnotizen (264)
• Einfache Datei-I/O 265
  
  • Text-I/O und Textdateien 265
  • Schreiben in eine Textdatei 267
  • Lesen von Daten aus einer Textdatei 270
• Zusammenfassung (274)
• Wiederholungsfragen 275
• Programmierübungen (276)

Kapitel 7. Funktionen – C++-Programmkomponenten 279

• Funktionen auf einen Blick
  
  • Funktion definieren 281
  • Prototyping und Aufrufen von Funktionen 283
• Funktionsparameter und Wertübergabe
  
  • Mehrere Parameter
  • Noch eine Binärfunktion 289
• Funktionen und Arrays 291
  
  • Wie erstellen Zeiger Funktionen, die Arrays verarbeiten? (292)
  • Auswirkungen der Verwendung von Arrays als Parameter 293
  • Weitere Beispiele für Funktionen und Arrays
  • Funktionen, die Array-Bereiche verwenden 301
  • Konstante Zeiger und Modifikator 302
• Zweidimensionale Funktionen und Arrays 306
• Funktionen und Strings im C-Stil 307
  
  • Funktionen mit Zeichenfolgen im C-Stil als Parameter 307
  • Funktionen, die Strings als C zurückgeben
• Funktionen und Strukturen 310
  
  • Passing and Returning Structures 311
  • Ein weiteres Beispiel für die Verwendung von Funktionen und Strukturen 312
  • Übergabe der Strukturadresse 317
• Funktionen und Objekte der String-Klasse 318
  
  • Array-Funktionen und -Objekte 320
  • Programmnotizen (321)
• Rekursion (322)
  
  • Einzelaufrufrekursion 322
  • Rekursion über mehrere Aufrufe hinweg
• Zeiger auf Funktionen
  
  • Zeiger auf Funktionen - Grundlagen
  • Ein Beispiel für die Verwendung von Zeigern auf Funktionen
  • Variationen von Funktionszeigern 329
  • Vereinfachung über Typedef 333
• Zusammenfassung (333)
• Wiederholungsfragen 334
• Programmierübungen (336)

Kapitel 8. Funktionen, Fortgeschrittene Themen (339)

• Inline-Funktionen 339
• Referenzvariablen
  
  • Erstellen einer Referenzvariablen 342
  • Referenzen als Funktionsparameter 345
  • Referenzeigenschaften
  • Verwenden einer Strukturreferenz 352
  • Referenzen mit Objekten verwenden 358
  • Objekte zum zweiten Mal - Objekte, Vererbung und Referenzen 361
  • Wann sollten Referenzen als Parameter verwendet werden? (364)
• Standardparameter (365)
  
  • Programmnotizen (366)
• Funktionsüberladung 367
  
  • Ein Beispiel für das Überladen von Funktionen 370
  • Wann sollte Funktionsüberladung verwendet werden? (372)
• Funktionsvorlagen (372)
  
  • Überladene Vorlagen 375
  • Vorlageneinschränkungen
  • Öffentliche Fachrichtungen (377)
  • Konkretisierungen und Spezialisierungen (380)
  • Welche Version der Funktion wird der Compiler wählen? (382)
  • Die Evolution von Funktionsvorlagen
• Zusammenfassung (392)
• Wiederholungsfragen 392
• Programmierübungen (393)

Kapitel 9. Das Speichermodell und Namensräume 397

• Disjunkte Zusammenstellung (397)
• Lebensdauer, Reichweite und Verknüpfung (403)
  
  • Reichweite und Verknüpfung
  • Automatische Zuordnung (404)
  • Statische Variablen 409
  • Statische Zuordnung, Outer Join
  • Spezifizierer und Qualifizierer
  • Kombinieren und Funktionen 421
  • Sprachbindung (422)
  • Zuordnungskategorien und dynamische Zuordnung
• Namensräume 429
  
  • Traditionelle C++-Namespaces
  • Neue Namespace-Mechanismen 431
  • Namensräume Beispiel 438
  • Die Zukunft der Namespaces
• Zusammenfassung (442)
• Wiederholungsfragen 442
• Programmierübungen (445)

Kapitel 10. Objekte und Klassen 447

• Prozedurale Programmierung und objektorientierte Programmierung
• Klassen und Abstraktionen
  
  • Was ist Typ? (449)
  • C++-Klassen
  • Klassenmethoden implementieren 455
  • Klassen verwenden 459
  • Implementierungsänderungen
  • Zusammenfassung bekannter Nachrichten (462)
• Konstruktoren und Destruktoren 463
  
  • Konstruktoren deklarieren und definieren 464
  • Verwenden von Konstruktoren 465
  • Standardkonstruktoren 466
  • Destruktoren (467)
  • Verbesserungen der Aktienklassen 468
  • Konstruktoren und Destruktoren Zusammenfassung
• Objektidentität - Dieser Indikator
• Objekt-Arrays
• Klassenbereich (485)
  
  • Klassenbereichskonstanten (486)
  • Selbstbezogene Enumerationen (C++ 11) 487
• Abstrakte Datentypen 488
• Zusammenfassung 492
• Wiederholungsfragen 493
• Programmierübungen (493)

Kapitel 11. Klassen verwenden 497

• Überladen von Operatoren 498
• Eins, zwei, drei – Operatorüberlastungsversuch (499)
  
  • Zusätzlicher Additionsoperator (502)
  • Operator-Überladungsbeschränkungen
  • Mehr zum Überladen von Operatoren 506
• Freunde am wichtigsten (509)
  
  • Freundschaft erklären 510
  • Typische Freundschaft – Operatorüberladung << (512)
• Überladen von Operatoren - Methoden versus nicht konstituierende Funktionen 518
• Überlastungen fortgesetzt - Die Vector Class 519
  
  • Komponente, die den Zustand eines Objekts codiert (526)
  • Überladen von arithmetischen Operatoren für die Vektorklasse 528
  • Implementierungshinweis (530)
  • Vektor Random Walk 530
• Automatische Konvertierungen und Umwandlungen von Klassentypen 534
  
  • Über das Programm (539)
  • Konvertierungsfunktionen 539
  • Bekehrung und Freundschaft (544)
• Zusammenfassung (547)
• Wiederholungsfragen 549
• Programmierübungen (549)

Kapitel 12. Klassen und dynamische Speicherzuweisung 553

• Klassen und dynamischer Speicher
  
  • Dynamische Gedächtnisprüfung und statische Klassenmitglieder
  • Spezielle Klassenmethoden
  • Was ist das Problem mit dem Kopierkonstruktor in Stringbad? (565)
  • Andere Schwächen von Stringbad: Zuweisungsoperatoren
• Neue, verbesserte Klasse – Zeichenfolge 571
  
  • Neue Version des Standardkonstruktors 572
  • Saiten vergleichen 573
  • Indizierung der Zeichenfolge 574
  • Statische Klassenmethoden 575
  • Weiteres Überladen des Zuweisungsoperators 576
• Was sollten Sie bei der Verwendung von new in Konstruktoren beachten? (581)
  
  • Empfehlungen und Warnungen 582
  • Kopieren von Mitgliedsobjekten nach Mitglied 583
• Ein paar Worte zur Rückgabe von Objekten
  
  • Zurückgeben einer nicht modifizierbaren (konstanten) Objektreferenz 584
  • Zurückgeben einer änderbaren (nicht konstanten) Referenz auf ein Objekt
  • Zurückgeben eines Objekts nach Wert 585
  • Rückgabe eines unveränderlichen Objekts nach Wert (const) 586
• Objektzeiger 587
  
  • Mehr über neu und löschen (589)
  • Zusammenfassung der Objektzeiger 590
  • Mehr zur lokalen Version neu (592)
• Übersicht über bekannte Techniken (596)
  
  • Operatorüberladung << (596)
  • Konvertierungsfunktionen 597
  • Klassen, die New in Konstruktoren verwenden
• Warteschlangensimulation (598)
  
  • Warteschlangenklasse (598)
  • Client-Klasse (609)
  • ATM-Simulation (612)
• Zusammenfassung (616)
• Wiederholungsfragen 617
• Programmierübungen (619)

Kapitel 13. Klassen und Vererbung 623

• Die einfache Basisklasse 624
  
  • Erbschaft (626)
  • Konstruktoren - Zugriffsebenenprobleme 628
  • Verwenden einer abgeleiteten Klasse 631
  • Die Beziehung zwischen der abgeleiteten Klasse und der Basisklasse 633
• Vererbung - die Ist-etwas-Beziehung (635)
• Polymorphe öffentliche Vererbung (636)
  
  • Erstellen von Brass- und BrassPlus-Klassen (637)
• Statische und dynamische Einschränkung 648
  
  • Kompatibilität von Indikator- und Referenztypen 648
  • Virtuelle Methoden und dynamische Bindung 650
  • Was müssen Sie über virtuelle Methoden wissen? (653)
• Zugriffskontrolle - Geschützte Ebene (656)
• Abstrakte Basisklassen
  
  • Verwenden von abstrakten Basisklassen 659
  • Die Philosophie der abstrakten Basisklassen
• Vererbung und dynamische Speicherzuweisung 665
  
  • Fall Eins – Abgeleitete Klasse ohne dynamische Speicherzuordnung
  • Zweiter Fall – Die abgeleitete Klasse mit dynamischer Speicherzuweisung 666
  • Ein Beispiel für Vererbung mit dynamischer Speicherzuweisung und Friend-Funktionen (668)
• Überprüfung des Klassenzimmerdesigns (673)
  
  • Automatisch generierte Methoden durch den Compiler
  • Andere Methoden 675
  • Öffentliche Erbschaft (678)
  • Zusammenfassung der Klassenmethoden
• Zusammenfassung (683)
• Wiederholungsfragen 683
• Programmierübungen (684)

Kapitel 14. Wiederverwendung von Code in C++ 687

• Klassen mit Objektmitgliedern
  
  • Eine kurze Beschreibung der Valarray-Klasse
  • Schülerklassenprojekt (689)
  • Beispiel-Studentenklasse
• Private Erbschaft (697)
  
  • Neue Version der Student-Klasse (697)
• Mehrfachvererbung
  
  • Doppelte Arbeiter (711)
  • Duale Methoden 714
  • Überprüfung der Mehrfachvererbung 723
• Klassenvorlagen (724)
  
  • Definieren einer Klassenvorlage 724
  • Verwenden einer Klassenvorlage 727
  • Klassenvorlagenanalyse
  • Die Array-Vorlage und Vorlagenargumente 734
  • Vorlagenflexibilität
  • Template-Spezialisierung
  • Vorlagen als Komponenten (742)
  • Vorlagen als Parameter (744)
  • Klassen- und Freunde-Vorlagen (746)
  • Vorlagentyp-Aliase (C++ 11) 752
• Zusammenfassung (753)
• Wiederholungsfragen 755
• Programmierübungen (757)

Kapitel 15. Freundschaften, Ausnahmen und mehr (763)

• Freundschaft (763)
  
  • Freundliche Klassen (764)
  • Methoden der Friend-Klasse
  • Sonstige Freundschaftsbeziehungen (771)
• Verschachtelte Klassen
  
  • Zugreifen auf verschachtelte Klassen 774
  • Verschachtelung in einer Vorlage 776
• Ausnahmen (779)
  
  • Anruf abbrechen () 779
  • Rückgabe eines Fehlercodes (780)
  • Der Ausnahmemechanismus 782
  • Objektausnahmen 784
  • Ausnahmespezifikationen und C++ 11
  • Abwickeln des Stapels 789
  • Andere Ausnahmeeigenschaften
  • Die Ausnahmeklasse (796)
  • Ausnahmen, Klassen und Vererbung 799
  • Probleme mit Ausnahmen 804
  • Seien Sie vorsichtig mit Ausnahmen (807)
• RTTI (808)
  
  • Warum brauchen wir RTTI? (808)
  • Wie funktioniert RTTI? (809)
• Geben Sie Casting-Operatoren ein
• Zusammenfassung (820)
• Wiederholungsfragen 820
• Programmierübungen (822)

Kapitel 16 Die String-Klasse und STL-Bibliothek 823

• String-Klasse
  
  • Erstellen eines String-Objekts 824
  • Eingeben von Daten in String-Objekte 828
  • String-Objekte verwenden 830
  • Was bietet die Saitenklasse sonst noch? (835)
  • Varianten der Saitenklasse 837
• Smart-Pointer-Klassenvorlagen (837)
  
  • Intelligente Zeiger verwenden 838
  • Mehr zu Smart Indicators (841)
  • Überlegenheit von unique_ptr gegenüber auto_ptr (844)
  • Auswählen eines intelligenten Zeigers (845)
• STL-Bibliothek (847)
  
  • Die Vektorklassenvorlage 847
  • Vektormethoden
  • Weitere Möglichkeiten der Vector Class 853
  • Bereich für Schleifen (C ++ 11) 857
• Verallgemeinerte Programmierung 858
  
  • Wozu brauche ich Iteratoren? (858)
  • Arten von Iteratoren
  • Iterator-Hierarchie
  • Konzepte, Präzisionen und Modelle (866)
  • Behälterarten (872)
  • Assoziative Container (881)
  • Ungeordnete assoziative Container (C ++ 11) 887
• Funktionsobjekte (Funktoren)
  
  • Funktorkonzepte 888
  • Vordefinierte Funktoren 891
  • Anpassbare Funktoren und Funktionsadapter (892)
• Algorithmen (895)
  
  • Algorithmusgruppen 895
  • Allgemeine Eigenschaften von Algorithmen 896
  • STL-Bibliothek und die String-Klasse
  • Containerfunktionen und -methoden 898
  • Verwendung der STL-Bibliothek 899
• Andere Bibliotheken (903)
  
  • Die Vektor-, Valarray- und Array-Klassen (903)
  • Das initializer_list (C++ 11)-Template 908
  • Verwenden der Vorlage initializer_list
  • Programmnotizen (911)
• Zusammenfassung (911)
• Wiederholungsfragen 913
• Programmierübungen (914)

Kapitel 17. Umgang mit Eingabe, Ausgabe und Dateien (917)

• Allgemeine Merkmale der E / A-Behandlung in C ++ 918
  
  • Streams und Puffer
  • Streams und Puffer und die iostream-Datei 921
  • Umleitung (923)
• Exit mit dem cout-Objekt ausführen (924)
  
  • Überladener Operator << (924)
  • Andere Ostream-Methoden 927
  • Leeren des Ausgangspuffers (930)
  • Formatieren der Ausgabe mit cout 931
• Durchführen einer Eingabeoperation unter Verwendung eines Cin-Objekts (945)
  
  • Wie "sieht" der Operator >> von cin die Eingabe? (947)
  • Stream-Zustände (949)
  • Andere Istream-Methoden 953
  • Andere Istream-Methoden 960
• Datei I/O (964)
  
  • Einfache Datei-I/O
  • Stream Check und die is_open()-Methode 968
  • Mehrere Dateien öffnen (969)
  • Verarbeitung von Befehlszeilenargumenten 969
  • Modi zum Öffnen von Dateien
  • Direktzugriff (981)
• Interne Formatierung 988
• Zusammenfassung (991)
• Wiederholungsfragen 992
• Programmierübungen (993)

Kapitel 18. Der neue C++-Standard 997

• Zusammenfassung von C++ 11 Items 997
  
  • Neue Typen (997)
  • Einheitliche Initialisierung 998
  • Erklärungen (999)
  • nullptr (1001)
  • Intelligente Zeiger (1002)
  • Ausnahmespezifikationsänderungen (1002)
  • Explizite Reichweite von Aufzählungselementen
  • Klassenänderungen (1003)
  • Änderungen an Vorlagen und der STL-Bibliothek
  • R-Wert-Referenzen
• Übertragung von Semantik und R-Wert-Referenzen
  
  • Die Notwendigkeit der Übertragungssemantik (1007)
  • Übertragungsbeispiel 1008
  • Schlussfolgerungen des Übertragungskonstrukteurs 1013
  • Aufträge (1014)
  • Bewegung erzwingen (1015)
• Neue Klassengegenstände (1018)
  
  • Sonderklassenmethoden 1018
  • Standard- und entfernte Methoden 1019
  • Konstrukteure delegieren 1021
  • Konstruktorvererbung
  • Verwaltung virtueller Methoden: Überschreiben und endgültig (1023)
• Lambda-Funktionen
  
  • Funktionszeiger, Funktoren und Lambdas
  • Warum brauchen wir Lambdas? (1027)
• Adapter (1030)
  
  • Adapterfunktion und Template-Unwirksamkeit (1030)
  • Problem beheben (1032)
  • Weitere Optionen (1034)
• Variable Parametervorlagen (1035)
  
  • Vorlagenparameter- und Funktionspakete
  • Pakete auspacken (1036)
  • Rekursion in variablen Parametervorlagen
• Andere C ++ 11-Annehmlichkeiten (1040)
  
  • Gleichzeitige Programmierung 1040
  • Bibliothekszugänge (1040)
  • Low-Level-Programmierung (1041)
  • Andere (1042)
• Sprachänderungen (1042)
  
  • Boost-Projekt (1043)
  • TR1 (1043)
  • Verwenden von Boost-Bibliotheken 1043
• Was kommt als nächstes? (1044)
• Zusammenfassung (1045)
• Wiederholungsfragen 1046
• Programmierübungen (1049)

Anhang A Zahlensysteme

• Dezimalstellen (Basis 10) (1051)
• Oktale ganze Zahlen (Basis 8) (1051)
• Hexadezimalzahlen 1052
• Binärzahlen (Basis 2) 1052
• Binär vs. Hexadezimal (1053)

(1055) Anhang B C ++ Reservierte Wörter

• C ++ Schlüsselwörter 1055
• Alternative Lexeme
• Reservierte Namen von C++-Bibliotheken 1056
• Bezeichner mit besonderer Bedeutung (1057)

Anhang C ASCII-Zeichensatz (1059)

Anhang D Bedienerprioritäten

Anhang E Andere Operatoren

• Bitweise Operatoren 1067
  
  • Schichtführer 1067
  • Bitweise logische Operatoren 1069
  • Alternative Darstellungen von bitweisen Operatoren
  • Einige gängige Techniken mit bitweisen Operatoren 1072
• Element-Dereferenzierungsoperatoren
• Alignof (C ++ 11) (1077)
• neinaußer (C ++ 11) (1078)

Anhang F String-Template-Klasse

• Dreizehn Typen und eine Konstante (1080)
• Dateninformationen, Konstruktoren und Sonstiges (1080)
  
  • Standardkonstruktor (1083)
  • Konstrukteure, die an klassischen C-Saiten arbeiten
  • C-String-Konstruktoren
  • Konstrukteure, die mit der L-Wert-Referenz 1084 arbeiten
  • Konstruktoren, die auf der R-Wert-Referenz (C ++ 11) 1085 arbeiten
  • Konstruktoren mit n Kopien eines Zeichens (1086)
  • Konstruktoren, die den Bereich 1086 verwenden
  • Initialisierungslistenkonstruktor (C++ 11) 1086
  • Speicherverwaltungsmethoden 1087
• Kettenzugriff (1087)
• Einfache Zuordnung 1088
• Zeichenfolgen suchen (1089)
  
  • Die find()-Funktionsfamilie 1089
  • Die Familie rfind () 1089
  • Die find_first_of ()-Funktionsfamilie 1090
  • Die find_last_of ()-Funktionsfamilie 1090
  • Die Familie der Funktionen find_first_not_of () 1091
  • Find_last_not_of () Familie 1091
• Vergleichsmethoden und -funktionen 1091
• Kettenmodifikatoren (1093)
  
  • Die Anbringungs- und Additionsmethoden 1093
  • Andere Zuordnungsmethoden 1094
  • Einfügemethoden 1094
  • Entfernungsmethoden (1095)
  • Ersatzmethoden 1095
  • Andere Modifikatormethoden: copy () und swap () 1096
• Ein- und Ausfahrt (1096)

Anhang G Methoden und Funktionen aus der STL-Bibliothek 1099

• STL vs. C++ 11 (1099)
  
  • Neue Behälter (1099)
  • Änderungen an C++ 98-Containern (1100)
• Komponenten, die allen (oder den meisten) Containern gemeinsam sind (1101)
• Zusätzliche Mitglieder für sequentielle Container (1104)
• Zusätzliche Ernte- und Kartenoperationen (1107)
• Assoziative Container aufheben (C++ 11) 1109
• STL-Funktionen
  
  • Nicht modifizierende sequentielle Operationen 1111
  • Mutierte sequentielle Operationen 1116
  • Sortieren und verwandte Operationen 1125
  • Zahlenoperationen 1139

Anhang H Ausgewählte Bücher und Online-Ressourcen (1141)

• Ausgewählte Bücher (1141)
• Internetquellen (1142)

Anhang I Anpassung an ANSI/ISO C++ (1145)

• Vermeidung des Missbrauchs bestimmter Präprozessordirektiven
  
  • Verwenden Sie besser const modifier als #define (1145) Direktiven, um Konstanten zu definieren.
  • Es ist besser, den Inline-Bezeichner zu verwenden, um kleine Funktionen zu definieren, als die Makros #define (1147).
• Verwenden von Funktionsprototypen 1148
• Mit einem Typ Cast 1148
• Erlernen und Verwenden der Mechanismen der Sprache C++ 1149
• Verwenden der neuen Organisation für Header-Dateien 1149
• Namensräume verwenden
• Intelligente Zeiger verwenden (1150)
• Verwenden der Zeichenfolgenklasse 1151
• Verwenden der STL (1151)

Anhang J. Antworten auf Selbsttestfragen 1153