C++ programmieren
ALLES ÜBER C++ - UND NOCH VIEL MEHR//
- Topaktuell: entspricht dem neuen ISO-C++23-Standard
- Ein Praxisbuch für alle Ansprüche – mehr brauchen Einsteiger und Fortgeschrittene nicht
- Stellt Grundlagen und fortgeschrittene Themen der C++-Programmierung vor und zeigt sie an praktischen Beispielen
- Enthält über 150 praktische Lösungen für typische Aufgabenstellungen und 99 Übungsaufgaben – natürlich mit Musterlösungen
- Im Internet unter www.cppbuch.de: Entwicklungsumgebung, Compiler, weitere Open-Source-Software, alle Beispiele und Musterlösungen
- Ihr exklusiver Vorteil: E-Book inside beim Kauf des gedruckten Buches
C++ PROGRAMMIEREN//
Egal, ob Sie C++ lernen wollen oder Ihre Kenntnisse in der Softwareentwicklung mit C++ vertiefen – in diesem Buch finden Sie, was Sie brauchen. C++-Neulinge erhalten eine motivierende Einführung in die Sprache C++.
Die vielen Beispiele sind leicht nachzuvollziehen, Klassen und Objekte, Templates, STL und Exceptions sind bald keine Fremdwörter mehr für Sie. Fortgeschrittene finden in diesem Buch kurze Einführungen zu Themen wie Thread-Programmierung, Netzwerk-Programmierung, grafische Benutzungsoberflächen und Zugriff auf die KI ChatGPT per Programm.
Weil Softwareentwicklung nicht nur Schreiben von Programmcode ist, finden Sie hier auch diese Themen: guter Programmierstil, Testen von Programmen und automatisierte Übersetzung von Programmen. Das integrierte »C++-Rezeptbuch« mit mehr als 150 praktischen Lösungen, das detaillierte Inhaltsverzeichnis und ein sehr umfangreiches Register machen das Buch zum unverzichtbaren Nachschlagewerk für alle, die sich im Studium oder professionell mit der Softwareentwicklung in C++ beschäftigen.
AUS DEM INHALT//
- Datentypen und Kontrollstrukturen: strukturierte und selbstdefinierte Datentypen, Ein- und Ausgabe von Daten
- Programme strukturieren, einfache Funktionen schreiben, Templates kennenlernen
- Objektorientierung: Klassen und Objekte, Konzepte zum Klassenentwurf, generische Klassen
- Vererbung: Beziehung zwischen Ober- und Unterklassen, Überschreiben von Funktionen, Mehrfachvererbung
- Fehlerbehandlung, Überladen von Operatoren, sicheres Speichermanagement, Lambda-Funktionen, Template-Metaprogrammierung
- Optimierung der Performance mit R-Wert-Referenzen
Autor:
Professor Dr. Ulrich Breymann war in der Industrie und in der Raumfahrttechnik tätig und lehrte Informatik an der Hochschule Bremen. Er arbeitete an dem ersten C++-Standard mit und ist ein bekannter Autor zu den Themen C++, STL und Java ME. Aus seiner Tätigkeit in Industrie und Hochschule weiß er genau, worauf es bei der Softwareentwicklung ankommt. Er stellt komplexe Sachverhalte verständlich dar und legt Wert auf eine Programmiermethodik, die den Ansprüchen an hochqualitative Software gerecht wird. Die Internetseite zu seinem C++-Buch ist cppbuch.de.
Author(s): Ulrich Breymann
Edition: 7
Publisher: Carl Hanser
Year: 2023
Language: German
Commentary: Publisher ePUB
Pages: 1016
City: München
Tags: C++; C++23; C++ Programming Language; Modern C++; Object-Oriented Programming
Titelei
Impressum
Inhalt
Vorwort
Teil I: Einführung in C++
1 Es geht los!
1.1 Historisches
1.2 Arten der Programmierung
1.3 Werkzeuge zum Programmieren
1.4 Das erste Programm
1.5 Integrierte Entwicklungsumgebung
1.6 Einfache Datentypen und Operatoren
1.6.1 Ausdruck
1.6.2 Regeln für Namen
1.6.3 Ganze Zahlen
1.6.4 Reelle Zahlen
1.6.5 Konstanten
1.6.6 Zeichen
1.6.7 Logischer Datentyp bool
1.6.8 Regeln zum Bilden von Ausdrücken
1.6.9 Standard-Typumwandlungen
1.7 Gültigkeitsbereich und Sichtbarkeit
1.7.1 Namespace std
1.8 Kontrollstrukturen
1.8.1 Anweisungen
1.8.2 Sequenz (Reihung)
1.8.3 Auswahl (Selektion, Verzweigung)
1.8.4 Fallunterscheidungen mit switch
1.8.5 Wiederholungen
1.8.6 Kontrolle mit break und continue
1.8.7 goto
1.9 Selbst definierte und zusammengesetzte Datentypen
1.9.1 Aufzählungstypen
1.9.2 Strukturen
1.9.3 Der C++-Standardtyp vector
1.9.4 Der C++-Standardtyp array
1.9.5 Zeichenketten: der C++-Standardtyp string
1.9.6 Container und Schleifen
1.9.7 Typermittlung mit auto
1.9.8 Deklaration einer strukturierten Bindung mit auto
1.9.9 Bitfeld und Union
1.10 Einfache Ein- und Ausgabe
1.10.1 Standardein- und -ausgabe
1.10.2 Ein- und Ausgabe mit Dateien
1.11 Guter Programmierstil
2 Programmstrukturierung
2.1 Funktionen
2.1.1 Aufbau und Prototypen
2.1.2 nodiscard
2.1.3 Gültigkeitsbereiche und Sichtbarkeit in Funktionen
2.1.4 Lokale static-Variable: Funktion mit Gedächtnis
2.2 Schnittstellen zum Datentransfer
2.2.1 Übergabe per Wert
2.2.2 Übergabe per Referenz
2.2.3 Gefahren bei der Rückgabe von Referenzen
2.2.4 Vorgegebene Parameterwerte und unterschiedliche Parameterzahl
2.2.5 Überladen von Funktionen
2.2.6 Funktion main()
2.2.7 Beispiel Taschenrechnersimulation
2.2.8 Spezifikation von Funktionen
2.2.9 Reihenfolge der Auswertung von Argumenten
2.3 Präprozessordirektiven
2.3.1 #include
2.3.2 #define, #if, #ifdef, #ifndef, #elif, #else, #endif, #elifdef, #elifndef
2.3.3 Vermeiden mehrfacher Inkludierung
2.3.4 __has_include
2.3.5 Textersetzung mit #define
2.3.6 Umwandlung von Parametern in Zeichenketten
2.3.7 Verifizieren logischer Annahmen zur Laufzeit
2.3.8 Verifizieren logischer Annahmen zur Compilationszeit
2.3.9 Fehler- und Warnmeldungen
2.3.10 Fehler ohne Programmabbruch lokalisieren
2.4 Modulare Programmgestaltung
2.4.1 Projekt: Mehrere cpp-Dateien bilden ein Programm
2.4.2 Projekt in der IDE anlegen
2.4.3 Übersetzungseinheit, Deklaration, Definition
2.4.4 Dateiübergreifende Gültigkeit und Sichtbarkeit
2.5 Namensräume
2.5.1 Gültigkeitsbereich auf Datei beschränken
2.6 inline-Funktionen und -Variablen
2.7 constexpr-Funktionen
2.7.1 Berechnung zur Compilationszeit mit consteval
2.8 Rückgabetyp auto
2.9 Funktions-Templates
2.9.1 Spezialisierung von Templates
2.9.2 Einbinden von Templates
2.10 C++-Header
2.11 Module
3 Objektorientierung 1
3.1 Datentyp und Objekt
3.2 Abstrakter Datentyp
3.3 Klassen
3.3.1 const-Objekte und Methoden
3.3.2 inline-Elementfunktionen
3.4 Initialisierung und Konstruktoren
3.4.1 Standardkonstruktor
3.4.2 Direkte Initialisierung der Attribute
3.4.3 Allgemeine Konstruktoren
3.4.4 Kopierkonstruktor
3.4.5 Typumwandlungskonstruktor
3.4.6 Konstruktor und mehr vorgeben oder verbieten
3.4.7 Einheitliche Initialisierung und Sequenzkonstruktor
3.4.8 Delegierender Konstruktor
3.4.9 constexpr-Konstruktor und -Methoden
3.5 Beispiel Rationale Zahlen
3.5.1 Aufgabenstellung
3.5.2 Entwurf
3.5.3 Implementation
3.6 Destruktoren
3.7 Wie kommt man zu Klassen und Objekten? Ein Beispiel
3.8 Gegenseitige Abhängigkeit von Klassen
4 Zeiger
4.1 Zeiger und Adressen
4.2 C-Arrays
4.2.1 C-Array, std::size() und sizeof
4.2.2 Initialisierung von C-Arrays
4.2.3 Zeigerarithmetik
4.2.4 Indexoperator bei C-Arrays
4.2.5 C-Array durchlaufen
4.3 C-Zeichenketten
4.3.1 Schleifen und C-Strings
4.4 Dynamische Datenobjekte
4.4.1 Freigeben dynamischer Objekte
4.5 Zeiger und Funktionen
4.5.1 Parameterübergabe mit Zeigern
4.5.2 C-Array als Funktionsparameter
4.5.3 const und Zeiger-Parameter
4.5.4 Parameter des main-Programms
4.5.5 Gefahren bei der Rückgabe von Zeigern
4.6 this-Zeiger
4.7 Mehrdimensionale C-Arrays
4.7.1 Statische mehrdimensionale C-Arrays
4.7.2 Mehrdimensionales C-Array als Funktionsparameter
4.8 Dynamisches 2D-Array
4.9 Binäre Ein-/Ausgabe
4.10 Zeiger auf Funktionen
4.11 Typumwandlungen für Zeiger
4.12 Zeiger auf Elementfunktionen und -daten
4.13 Komplexe Deklarationen lesen
4.13.1 Lesbarkeit mit typedef und using verbessern
4.14 Alternative zu rohen Zeigern, new und delete
5 Objektorientierung 2
5.1 Eine String-Klasse
5.1.1 friend-Funktionen
5.2 String-Ansicht (View)
5.3 Typbestimmung mit decltype und declval
5.4 Klassenspezifische Daten und Funktionen
5.4.1 Klassenspezifische Konstante
5.5 Klassen-Templates
5.5.1 Ein Stack-Template
5.5.2 Stack mit statisch festgelegter Größe
5.5.3 Stack auf Basis verschiedener Container
5.6 Code Bloat bei der Instanziierung von Templates vermeiden
5.6.1 extern-Template
6 Vererbung
6.1 Vererbung und Initialisierung
6.2 Zugriffsschutz
6.3 Typbeziehung zwischen Ober- und Unterklasse
6.4 Oberklassen-Schnittstelle verwenden
6.4.1 Konstruktor erben
6.5 Überschreiben von Funktionen in abgeleiteten Klassen
6.5.1 Virtuelle Funktionen
6.5.2 Abstrakte Klassen
6.5.3 Virtueller Destruktor
6.5.4 Vererbung verbieten
6.5.5 Private virtuelle Funktionen
6.6 Probleme der Modellierung mit Vererbung
6.7 Mehrfachvererbung
6.8 Typumwandlung bei Vererbung
6.9 Typinformationen zur Laufzeit
6.10 Private-/Protected-Vererbung
7 Fehlerbehandlung
7.1 Ausnahmebehandlung
7.1.1 Exception-Spezifikation in Deklarationen
7.1.2 Exception-Hierarchie
7.1.3 Besondere Fehlerbehandlungsfunktionen
7.1.4 Arithmetische Fehler/Division durch 0
7.2 Speicherbeschaffung mit new
7.3 Exception-Sicherheit
7.4 Fehlerbehandlung mit optional und expected
7.4.1 Fehlerbehandlung mit optional
7.4.2 Fehlerbehandlung mit expected
7.4.3 Monadische Operationen
8 Überladen von Operatoren
8.1 Rationale Zahlen — noch einmal
8.1.1 Arithmetische Operatoren
8.1.2 Ausgabeoperator <<
8.1.3 Gleichheitsoperator
8.2 Eine Klasse für Vektoren
8.2.1 Indexoperator [ ]
8.2.2 Zuweisungsoperator =
8.2.3 Mathematische Vektoren
8.2.4 Multiplikationsoperator
8.3 Inkrement-Operator ++
8.4 Typumwandlungsoperator
8.5 Smart Pointer: Operatoren -> und *
8.5.1 Smart Pointer und die C++-Standardbibliothek
8.6 Objekt als Funktion
8.7 Spaceship-Operator <=>
8.7.1 Ordnungen in C++
8.7.2 Automatische Erzeugung der Vergleichsoperatoren
8.7.3 Klassenspezifische Sortierung
8.7.4 Freie Funktionen statt Elementfunktionen
8.8 new und delete überladen
8.8.1 Unterscheidung zwischen Heap- und Stack-Objekten
8.8.2 Empfehlungen im Umgang mit new und delete
8.9 Operatoren für Literale
8.9.1 Stringliterale
8.9.2 Benutzerdefinierte Literale
8.10 Indexoperator für Matrizen
8.10.1 Zweidimensionale Matrix als Vektor von Vektoren
8.10.2 Zweidimensionale Matrix mit zusammenhängendem Speicher
8.11 Zuweisung, Kopie und Vergleich bei Vererbung
8.11.1 Polymorpher Vergleich
8.11.2 Kopie mit clone()-Methode erzeugen
9 Dateien und Ströme
9.1 Eingabe
9.2 Ausgabe
9.3 Formatierung mit std::format
9.3.1 Syntax für Platzhalter
9.3.2 Formatierung eigener Datentypen
9.4 Formatierung mit Flags
9.5 Formatierung mit Manipulatoren
9.6 Fehlerbehandlung
9.7 Typumwandlung von Dateiobjekten nach bool
9.8 Arbeit mit Dateien
9.8.1 Positionierung in Dateien
9.8.2 Lesen und Schreiben in derselben Datei
9.9 Umleitung auf Strings
9.10 Formatierte Daten lesen
9.10.1 Eingabe benutzerdefinierter Typen
9.11 Blockweise lesen und schreiben
9.11.1 vector-Objekt binär lesen und schreiben
9.11.2 array-Objekt binär lesen und schreiben
9.11.3 Matrix binär lesen und schreiben
10 Die Standard Template Library (STL)
10.1 Container, Iteratoren, Algorithmen
10.2 Iteratoren im Detail
10.3 Beispiel verkettete Liste
10.4 Ranges und Views
Teil II: Fortgeschrittene Themen
11 Performance, Wert- und Referenzsemantik
11.1 Performanceproblem Wertsemantik
11.1.1 Auslassen der Kopie
11.1.2 Temporäre Objekte bei der Zuweisung
11.2 Referenzsemantik für R-Werte
11.2.1 Kategorien von Ausdrücken
11.2.2 Referenzen auf R- und L-Werte
11.2.3 Auswertung von Referenzen auf R-Werte
11.2.4 Referenz-Qualifizierer
11.3 Optimierung durch Referenzsemantik für R-Werte
11.3.1 Bewegungskonstruktor
11.3.2 Bewegender Zuweisungsoperator
11.4 Die move()-Funktion
11.4.1 move() und Initialisierung der Attribute
11.5 Referenzen auf R-Werte und Template-Parameter
11.5.1 Auswertung von Template-Parametern — ein Überblick
11.6 Ein effizienter Plusoperator
11.6.1 Eliminieren auch des Bewegungskonstruktors
11.6.2 Kopien temporärer Objekte eliminieren
11.7 Rule of three/five/zero
12 Lambda-Funktionen
12.1 Eigenschaften
12.1.1 Äquivalenz zum Funktionszeiger
12.1.2 Lambda-Funktion und Klasse
12.2 Generische Lambda-Funktionen
12.3 Parametererfassung mit []
13 Metaprogrammierung mit Templates
13.1 Grundlagen
13.2 Variadic Templates: Templates mit variabler Parameterzahl
13.2.1 Ablauf der Auswertung durch den Compiler
13.2.2 Anzahl der Parameter
13.2.3 Parameterexpansion
13.3 Fold-Expressions
13.3.1 Weitere Varianten
13.3.2 Fold-Expression mit Kommaoperator
13.4 Klassen-Template mit variabler Stelligkeit
13.5 Type Traits
13.5.1 Wie funktionieren Type Traits? — ein Beispiel
13.5.2 Abfrage von Eigenschaften
13.5.3 Abfrage numerischer Eigenschaften
13.5.4 Typumwandlungen
13.5.5 Auswahl weiterer Traits
13.6 Concepts
14 Reguläre Ausdrücke
14.1 Elemente regulärer Ausdrücke
14.1.1 Greedy oder lazy?
14.2 Interaktive Auswertung
14.3 Auszug der regex-Schnittstelle
14.4 Verarbeitung von \n
14.5 Anwendungen
15 Threads und Coroutinen
15.1 Zeit und Dauer
15.2 Threads
15.2.1 Automatisch join()
15.3 Die Klasse jthread
15.3.1 Übergabe eines Funktors
15.3.2 Thread-Group
15.4 Synchronisation kritischer Abschnitte
15.4.1 Data Race erkennen
15.5 Thread-Steuerung: Pausieren, Fortsetzen, Beenden
15.6 Warten auf Ereignisse
15.7 Atomare Veränderung von Variablen
15.8 Asynchrone verteilte Bearbeitung einer Aufgabe
15.9 Thread-Sicherheit
15.10 Coroutinen
16 Grafische Benutzungsschnittstellen
16.1 Ereignisgesteuerte Programmierung
16.2 GUI-Programmierung mit Qt
16.2.1 Meta-Objektsystem
16.2.2 Der Programmablauf
16.2.3 Ereignis abfragen
16.3 Signale, Slots und Widgets
16.4 Dialog
16.5 Qt oder Standard-C++?
16.5.1 Threads
16.5.2 Verzeichnisbaum durchwandern
17 Internet-Anbindung
17.1 Protokolle
17.2 Adressen
17.3 Socket
17.3.1 Bidirektionale Kommunikation
17.3.2 UDP-Sockets
17.3.3 Atomuhr mit UDP abfragen
17.4 HTTP
17.4.1 Verbindung mit GET
17.4.2 Verbindung mit POST
17.5 Mini-Webserver
17.6 OpenAI-Schnittstellen zu ChatGPT und DALL·E 2
17.6.1 ChatGPT
17.6.2 DALL·E 2
18 Datenbankanbindung
18.1 C++-Interface
18.2 Anwendungsbeispiel
Teil III: Ausgewählte Methoden und Werkzeuge der Softwareentwicklung
19 Effiziente Programmerzeugung mit make
19.1 Wirkungsweise
19.2 Variablen und Muster
19.3 Universelles Makefile für einfache Projekte
19.4 Automatische Ermittlung von Abhängigkeiten
19.4.1 Makefiles für verschiedene Betriebssysteme und Compiler
19.4.2 Getrennte Verzeichnisse: src, obj, bin
19.5 Makefile für Verzeichnisbäume
19.5.1 Nur ein Makefile auf Projektebene
19.5.2 Rekursive Make-Aufrufe
19.6 Erzeugen von Bibliotheken
19.6.1 Statische Bibliotheksmodule
19.6.2 Dynamische Bibliotheksmodule
19.7 Weitere Build-Tools
20 Unit-Test
20.1 Werkzeuge
20.2 Boost Unit Test Framework
20.2.1 Fixture
20.2.2 Testprotokoll und Log-Level
20.2.3 Prüf-Makros
20.2.4 Kommandozeilen-Optionen
20.3 Test Driven Development
Teil IV: Das C++-Rezeptbuch: Tipps und Lösungen für typische Aufgaben
21 Sichere Programmentwicklung
21.1 Regeln zum Design von Methoden
21.2 Defensive Programmierung
21.2.1 double- und float-Werte richtig vergleichen
21.2.2 const und constexpr verwenden
21.2.3 Anweisungen nach for/if/while einklammern
21.2.4 int und unsigned/size_t nicht mischen
21.2.5 size_t oder auto statt unsigned int verwenden
21.2.6 Postfix++ mit Präfix++ implementieren
21.2.7 Ein Destruktor darf keine Exception werfen
21.2.8 explicit-Typumwandlungsoperator bevorzugen
21.2.9 explicit-Konstruktor für eine Typumwandlung bevorzugen
21.2.10 Leere Standardkonstruktoren vermeiden
21.2.11 Mit override Schreibfehler reduzieren
21.2.12 Kopieren und Zuweisung verbieten
21.2.13 Vererbung verbieten
21.2.14 Überschreiben einer virtuellen Methode verhindern
21.2.15 »Rule of zero« beachten
21.2.16 One Definition Rule
21.2.17 Defensiv Objekte löschen
21.2.18 Hängende Referenzen vermeiden
21.2.19 Speicherbeschaffung und -freigabe kapseln
21.2.20 Programmierrichtlinien einhalten
21.3 Exception-sichere Beschaffung von Ressourcen
21.3.1 Sichere Verwendung von unique_ptr und shared_ptr
21.3.2 So vermeiden Sie new und delete!
21.3.3 shared_ptr für C-Arrays korrekt verwenden
21.3.4 unique_ptr für C-Arrays korrekt verwenden
21.3.5 Exception-sichere Funktion
21.3.6 Exception-sicherer Konstruktor
21.3.7 Exception-sichere Zuweisung
21.4 Empfehlungen zur Thread-Programmierung
21.4.1 Warten auf die Freigabe von Ressourcen
21.4.2 Deadlock-Vermeidung
21.4.3 notify_all oder notify_one?
21.4.4 Performance mit Threads verbessern?
22 Von der UML nach C++
22.1 Vererbung
22.2 Interface anbieten und nutzen
22.3 Assoziation
22.3.1 Aggregation
22.3.2 Komposition
23 Algorithmen für verschiedene Aufgaben
23.1 Algorithmen mit Strings
23.1.1 String splitten
23.1.2 String in Zahl umwandeln
23.1.3 Zahl in String umwandeln
23.1.4 Strings sprachlich richtig sortieren
23.1.5 Umwandlung in Klein- bzw. Großschreibung
23.1.6 Strings sprachlich richtig vergleichen
23.1.7 Von der Groß-/Kleinschreibung unabhängiger Zeichenvergleich
23.1.8 Von der Groß-/Kleinschreibung unabhängige Suche
23.2 Textverarbeitung
23.2.1 Datei durchsuchen
23.2.2 Ersetzungen in einer Datei
23.2.3 Lines of Code (LOC) ermitteln
23.2.4 Zeilen, Wörter und Zeichen einer Datei zählen
23.2.5 CSV-Datei lesen
23.2.6 Kreuzreferenzliste
23.3 Operationen auf Folgen
23.3.1 Vereinfachungen
23.3.2 Folge mit gleichen Werten initialisieren
23.3.3 Folge mit Werten eines Generators initialisieren
23.3.4 Folge mit fortlaufenden Werten initialisieren
23.3.5 Summe und Produkt
23.3.6 Mittelwert und Standardabweichung
23.3.7 Skalarprodukt
23.3.8 Folge der Teilsummen oder -produkte
23.3.9 Folge der Differenzen
23.3.10 Kleinstes und größtes Element finden
23.3.11 Elemente rotieren
23.3.12 Elemente verwürfeln
23.3.13 Dubletten entfernen
23.3.14 Reihenfolge umdrehen
23.3.15 Stichprobe
23.3.16 Anzahl der Elemente, die einer Bedingung genügen
23.3.17 Gilt ein Prädikat für alle, kein oder wenigstens ein Element einer Folge?
23.3.18 Permutationen
23.3.19 Lexikografischer Vergleich
23.4 Sortieren und Verwandtes
23.4.1 Partitionieren
23.4.2 Sortieren
23.4.3 Stabiles Sortieren
23.4.4 Partielles Sortieren
23.4.5 Das n.-größte oder n.-kleinste Element finden
23.4.6 Verschmelzen (merge)
23.5 Suchen und Finden
23.5.1 Element finden
23.5.2 Element einer Menge in der Folge finden
23.5.3 Teilfolge finden
23.5.4 Teilfolge mit speziellem Algorithmus finden
23.5.5 Bestimmte benachbarte Elemente finden
23.5.6 Bestimmte aufeinanderfolgende Werte finden
23.5.7 Binäre Suche
23.6 Mengenoperationen auf sortierten Strukturen
23.6.1 Teilmengenrelation
23.6.2 Vereinigung
23.6.3 Schnittmenge
23.6.4 Differenz
23.6.5 Symmetrische Differenz
23.7 Heap-Algorithmen
23.8 Vergleich von Containern auch ungleichen Typs
23.8.1 Unterschiedliche Elemente finden
23.8.2 Prüfung auf gleiche Inhalte
23.9 Rechnen mit komplexen Zahlen: Der C++-Standardtyp complex
23.10 Vermischtes
23.10.1 Erkennung eines Datums
23.10.2 Erkennung einer IPv4-Adresse
23.10.3 Erzeugen von Zufallszahlen
23.10.4 for_each — auf jedem Element eine Funktion ausführen
23.10.5 Verschiedene Möglichkeiten, Container-Bereiche zu kopieren
23.10.6 Vertauschen von Elementen, Bereichen und Containern
23.10.7 Elemente transformieren
23.10.8 Ersetzen und Varianten
23.10.9 Elemente herausfiltern
23.10.10 Grenzwerte von Zahltypen
23.10.11 Minimum und Maximum
23.10.12 Wert begrenzen
23.10.13 ggT, kgV und Mitte
23.11 Parallelisierbare Algorithmen
24 Datei- und Verzeichnisoperationen
24.1 Übersicht
24.2 Pfadoperationen
24.3 Datei oder Verzeichnis löschen
24.4 Datei oder Verzeichnis kopieren
24.5 Verzeichnis anlegen
24.6 Datei oder Verzeichnis umbenennen
24.7 Verzeichnis anzeigen
24.8 Verzeichnisbaum anzeigen
Teil V: Die C++-Standardbibliothek
25 Aufbau und Übersicht
25.1 Auslassungen
25.2 Beispiele des Buchs und die C++-Standardbibliothek
26 Hilfsfunktionen und -klassen
26.1 Unterstützung der Referenzsemantik für R-Werte
26.2 Paare
26.3 Tupel
26.4 bitset
26.5 Indexfolgen
26.6 variant statt union
26.7 Funktionsobjekte
26.7.1 Arithmetische, vergleichende und logische Operationen
26.7.2 Binden von Argumentwerten
26.7.3 Funktionen in Objekte umwandeln
26.8 Templates für rationale Zahlen
26.9 Hüllklasse für Referenzen
27 Container
27.1 Gemeinsame Eigenschaften
27.1.1 Reversible Container
27.1.2 Initialisierungsliste (initializer_list)
27.1.3 Konstruktion an Ort und Stelle
27.2 Sequenzen
27.2.1 vector
27.2.2 vector
27.2.3 array
27.2.4 list
27.2.5 deque
27.3 Container-Adapter
27.3.1 stack
27.3.2 queue
27.3.3 priority_queue
27.4 Assoziative Container
27.4.1 Sortierte assoziative Container
27.4.2 Hash-Container
27.5 Sicht auf Container (span)
28 Iteratoren
28.1 Iterator-Kategorien
28.1.1 Anwendung von Traits
28.2 Abstand und Bewegen
28.3 Zugriff auf Anfang und Ende
28.3.1 Reverse-Iteratoren
28.4 Insert-Iteratoren
28.5 Stream-Iteratoren
29 Algorithmen
29.1 Algorithmen mit Prädikat
29.2 Übersicht
30 Nationale Besonderheiten
30.1 Sprachumgebung festlegen und ändern
30.1.1 Die locale-Funktionen
30.2 Zeichensätze und -codierung
30.3 Zeichenklassifizierung und -umwandlung
30.4 Kategorien
30.4.1 collate
30.4.2 ctype
30.4.3 numeric
30.4.4 monetary
30.4.5 messages
30.5 Konstruktion eigener Facetten
31 String
31.1 string_view für String-Literale
32 Speichermanagement
32.1 unique_ptr
32.2 shared_ptr
32.3 weak_ptr
32.4 new mit Speicherortangabe
33 Ausgewählte C-Header
33.1
33.2
33.3
33.4
33.5
33.6
33.7
A Anhang
A.1 ASCII-Tabelle
A.2 C++-Schlüsselwörter
A.3 Compilerbefehle
A.3.1 Optimierung
A.4 Rangfolge der Operatoren
A.5 C++-Attribute für den Compiler
A.6 Lösungen zu den Übungsaufgaben
A.7 Änderungen in der 7. Auflage
Glossar
Literaturverzeichnis
