Die C++-Programmiersprache

Inhalt

Vorwort

Teil I Einführung

1 Vorbemerkungen

1.1?Zum Aufbau dieses Buchs

1.1.1?Einführung

1.1.2?Grundlegende Sprachmittel

1.1.3?Abstraktionsmechanismen

1.1.4?Die Standardbibliothek

1.1.5?Beispiele und Referenzen

1.2?Der Entwurf von C++

1.2.1?Programmierstile

1.2.2?Typprüfung

1.2.3?C-Kompatibilität

1.2.4?Sprache, Bibliotheken und Systeme

1.3?C++ lernen

1.3.1?In C++ programmieren

1.3.2?Ratschläge für C++-Programmierer

1.3.3?Ratschläge für C-Programmierer

1.3.4?Ratschläge für Java-Programmierer

1.4?Historische Anmerkungen

1.4.1?Chronik

1.4.2?Die frühen Jahre

1.4.2.1?Sprachfeatures und Bibliotheksinstrumente

1.4.3?Der 1998-Standard

1.4.3.1?Sprachfeatures

1.4.3.2?Die Standardbibliothek

1.4.4?Der 2011-Standard

1.4.4.1?Sprachfeatures

1.4.4.2?Standardbibliothek

1.4.5?Wofür wird C++ verwendet?

1.5?Ratschläge

1.6?Literaturhinweise

2 Ein Rundreise durch C++: Die Grundlagen

2.1?Einführung

2.2?Die Grundlagen

2.2.1?Hello, World!

2.2.2?Typen, Variablen und Arithmetik

2.2.3?Konstanten

2.2.4?Tests und Schleifen

2.2.5?Zeiger, Arrays und Schleifen

2.3?Benutzerdefinierte Typen

2.3.1?Strukturen

2.3.2?Klassen

2.3.3?Aufzählungen

2.4?Modularität

2.4.1?Separate Kompilierung

2.4.2?Namespaces

2.4.3?Fehlerbehandlung

2.4.3.1?Ausnahmen

2.4.3.2?Invarianten

2.4.3.3?Statische Assertionen

2.5?Nachbemerkung

2.6?Ratschläge

3 Eine Rundreise durch C++: Abstraktionsmechanismen

3.1?Einführung

3.2?Klassen

3.2.1?Konkrete Typen

3.2.1.1?Ein arithmetischer Typ

3.2.1.2?Ein Container

3.2.1.3?Container initialisieren

3.2.2?Abstrakte Typen

3.2.3?Virtuelle Funktionen

3.2.4?Klassenhierarchien

3.3?Kopieren und verschieben

3.3.1?Container kopieren

3.3.2?Container verschieben

3.3.3?Ressourcenverwaltung

3.3.4?Operationen unterdrücken

3.4?Templates

3.4.1?Parametrisierte Typen

3.4.2?Funktions-Templates

3.4.3?Funktionsobjekte

3.4.4?Variadische Templates

3.4.5?Alias

3.5?Ratschläge

4 Eine Rundreise durch C++: Container und Algorithmen

4.1?Bibliotheken

4.1.1?Überblick über die Standardbibliothek

4.1.2?Header und Namespace der Standardbibliothek

4.2?Strings

4.3?Stream-Ein-/Ausgabe

4.3.1?Ausgabe

4.3.2?Eingabe

4.3.3?Ein-/Ausgabe von benutzerdefinierten Typen

4.4?Container

4.4.1?vector

4.4.1.1?Elemente

4.4.1.2?Bereichsüberprüfung

4.4.2?list

4.4.3?map

4.4.4?unordered_map

4.4.5?Überblick über Container

4.5?Algorithmen

4.5.1?Iteratoren verwenden

4.5.2?Iteratortypen

4.5.3?Stream-Iteratoren

4.5.4?Prädikate

4.5.5?Überblick über Algorithmen

4.5.6?Containeralgorithmen

4.6?Ratschläge

5 Eine Rundreise durch C++: Nebenläufigkeit und Dienstprogramme

5.1?Einführung

5.2?Ressourcenverwaltung

5.2.1?unique_ptr und shared_ptr

5.3?Nebenläufigkeit

5.3.1?Tasks und Threads

5.3.2?Argumente übergeben

5.3.3?Ergebnisse zurückgeben

5.3.4?Daten gemeinsam nutzen

5.3.4.1?Warten auf Ereignisse

5.3.5?Kommunizierende Tasks

5.3.5.1?future und promise

5.3.5.2?packaged_task

5.3.5.3?async()

5.4?Kleine Hilfskomponenten

5.4.1?Zeit

5.4.2?Typfunktionen

5.4.2.1?iterator_traits

5.4.2.2?Typprädikate

5.4.3?pair und tuple

5.5?Reguläre Ausdrücke

5.6?Mathematik

5.6.1?Mathematische Funktionen und Algorithmen

5.6.2?Komplexe Zahlen

5.6.3?Zufallszahlen

5.6.4?Vektorarithmetik

5.6.5?Numerische Grenzen

5.7?Ratschläge

Teil II Grundlegende Sprachelemente

6 Typen und Deklarationen

6.1?Der ISO-C++-Standard

6.1.1?Implementierungen

6.1.2?Der grundlegende Quellzeichensatz

6.2?Typen

6.2.1?Fundamentale Typen

6.2.2?Boolesche Typen

6.2.3?Zeichentypen

6.2.3.1?Vorzeichenbehaftete und vorzeichenlose Zeichen

6.2.3.2?Zeichenliterale

6.2.4?Ganzzahltypen

6.2.4.1?Ganzzahlliterale

6.2.4.2?Typen von Ganzzahlliteralen

6.2.5?Gleitkommatypen

6.2.5.1?Gleitkommaliterale

6.2.6?Präfixe und Suffixe

6.2.7?void

6.2.8?Größen

6.2.9?Ausrichtung

6.3?Deklarationen

6.3.1?Die Struktur von Deklarationen

6.3.2?Mehrere Namen deklarieren

6.3.3?Namen

6.3.3.1?Schlüsselwörter

6.3.4?Gültigkeitsbereiche

6.3.5?Initialisierung

6.3.5.1?Fehlende Initialisierer

6.3.5.2?Initialisierungslisten

6.3.6?Einen Typ herleiten: auto und decltype()

6.3.6.1?Der Typspezifizierer auto

6.3.6.2?auto und {}-Listen

6.3.6.3?Der Spezifizierer decltype()

6.4?Objekte und Werte

6.4.1?L-Werte und R-Werte

6.4.2?Lebensdauer von Objekten

6.5?Typalias

6.6?Ratschläge

7 Zeiger, Arrays und Referenzen

7.1?Einführung

7.2?Zeiger

7.2.1?void*

7.2.2?nullptr

7.3?Arrays

7.3.1?Array-Initialisierer

7.3.2?Stringliterale

7.3.2.1?Rohe Zeichen-Strings

7.3.2.2?Größere Zeichensätze

7.4?Zeiger auf Arrays

7.4.1?Navigieren in Arrays

7.4.2?Mehrdimensionale Arrays

7.4.3?Arrays übergeben

7.5?Zeiger und const

7.6?Zeiger und Besitz

7.7?Referenzen

7.7.1?L-Wert-Referenzen

7.7.2?R-Wert-Referenzen

7.7.3?Referenzen auf Referenzen

7.7.4?Zeiger und Referenzen

7.8?Ratschläge

8 Strukturen, Unions und Aufzählungen

8.1?Einführung

8.2?Strukturen

8.2.1?Layout einer Struktur

8.2.2?Namen von Strukturen

8.2.3?Strukturen und Klassen

8.2.4?Strukturen und Arrays

8.2.5?Typäquivalenz

8.2.6?Plain Old Data

8.2.7?Felder

8.3?Unions

8.3.1?Unions und Klassen

8.3.2?Anonyme Unions

8.4?Aufzählungen

8.4.1?Aufzählungsklassen

8.4.2?Einfache Aufzählungen

8.4.3?Unbenannte Aufzählungen

8.5?Ratschläge

9 Anweisungen

9.1?Einführung

9.2?Zusammenfassung der Anweisungen

9.3?Deklarationen als Anweisungen

9.4?Auswahlanweisungen

9.4.1?if-Anweisungen

9.4.2?switch-Anweisungen

9.4.2.1?Deklarationen in case-Zweigen

9.4.3?Deklarationen in Bedingungen

9.5?Schleifenanweisungen

9.5.1?Bereichsbasierte for-Anweisungen

9.5.2?for-Anweisungen

9.5.3?while-Anweisungen

9.5.4?do-Anweisungen

9.5.5?Schleifen verlassen

9.6?goto-Anweisungen

9.7?Kommentare und Einrückungen

9.8?Ratschläge

10 Ausdrücke

10.1?Einführung

10.2?Ein Taschenrechner

10.2.1?Der Parser

10.2.2?Eingabe

10.2.3?Low-level-Eingabe

10.2.4?Fehlerbehandlung

10.2.5?Das Rahmenprogramm

10.2.6?Header

10.2.7?Befehlszeilenargumente

10.2.8?Eine Anmerkung zum Stil

10.3?Zusammenfassung der Operatoren

10.3.1?Ergebnisse

10.3.2?Reihenfolge der Auswertung

10.3.3?Operatorrangfolge

10.3.4?Temporäre Objekte

10.4?Konstante Ausdrücke

10.4.1?Symbolische Konstanten

10.4.2?const-Typen in konstanten Ausdrücken

10.4.3?Literale Typen

10.4.4?Referenzargumente

10.4.5?Adresse konstanter Ausdrücke

10.5?Implizite Typkonvertierung

10.5.1?Heraufstufungen

10.5.2?Konvertierungen

10.5.2.1?Integrale Konvertierungen

10.5.2.2?Gleitkommakonvertierungen

10.5.2.3?Zeiger- und Referenzkonvertierungen

10.5.2.4?Zeiger-auf-Member-Konvertierungen

10.5.2.5?Boolesche Konvertierungen

10.5.2.6?Gleitkomma-Ganzzahl-Konvertierungen

10.5.3?Übliche arithmetische Konvertierungen

10.6?Ratschläge

11 Auswahloperationen

11.1?Diverse Operatoren

11.1.1?Logische Operatoren

11.1.2?Bitweise logische Operatoren

11.1.3?Bedingte Ausdrücke

11.1.4?Inkrementieren und Dekrementieren

11.2?Freispeicher

11.2.1?Speicherverwaltung

11.2.2?Arrays

11.2.3?Speicherplatz beschaffen

11.2.4?Überladen von new

11.2.4.1?nothrow new

11.3?Listen

11.3.1?Implementierungsmodell

11.3.2?Qualifizierte Listen

11.3.3?Unqualifizierte Listen

11.4?Lambda-Ausdrücke

11.4.1?Implementierungsmodelle

11.4.2?Alternativen für Lambda-Ausdrücke

11.4.3?Erfassung

11.4.3.1?Lambda und Lebensdauer

11.4.3.2?Namen von Namespaces

11.4.3.3?Lambda und this

11.4.3.4?Veränderbare Lambda-Ausdrücke

11.4.4?Aufruf und Rückgabe

11.4.5?Der Typ eines Lambda-Ausdrucks

11.5?Explizite Typumwandlung

11.5.1?Konstruktion

11.5.2?Benannte Typumwandlungen

11.5.3?C-Typumwandlungen

11.5.4?Funktionale Typumwandlung

11.6?Ratschläge

12 Funktionen

12.1?Funktionsdeklarationen

12.1.1?Warum Funktionen?

12.1.2?Bestandteile einer Funktionsdeklaration

12.1.3?Funktionsdefinitionen

12.1.4?Werte zurückgeben

12.1.5?Inline-Funktionen

12.1.6?constexpr-Funktionen

12.1.6.1?constexpr und Referenzen

12.1.6.2?Bedingte Auswertung

12.1.7?[[noreturn]]-Funktionen

12.1.8?Lokale Variablen

12.2?Argumentübergabe

12.2.1?Referenzargumente

12.2.2?Array-Argumente

12.2.3?Listenargumente

12.2.4?Nicht angegebene Anzahl von Argumenten

12.2.5?Standardargumente

12.3?Überladene Funktionen

12.3.1?Automatische Auflösung von Überladungen

12.3.2?Überladen und Rückgabetyp

12.3.3?Überladen und Gültigkeitsbereiche

12.3.4?Auflösung für mehrere Argumente

12.3.5?Manuelle Auflösung von Überladungen

12.4?Vor- und Nachbedingungen

12.5?Zeiger auf Funktion

12.6?Makros

12.6.1?Bedingte Übersetzung

12.6.2?Vordefinierte Makros

12.6.3?Pragmas

12.7?Ratschläge

13 Ausnahmenbehandlung

13.1?Fehlerbehandlung

13.1.1?Ausnahmen

13.1.2?Herkömmliche Fehlerbehandlung

13.1.3?Durchhangeln

13.1.4?Alternative Ansichten von Ausnahmen

13.1.4.1?Asynchrone Ereignisse

13.1.4.2?Ausnahmen, die keine Fehler sind

13.1.5?Wann Sie keine Ausnahmen verwenden können

13.1.6?Hierarchische Fehlerbehandlung

13.1.7?Ausnahmen und Effizienz

13.2?Ausnahmegarantien

13.3?Ressourcenverwaltung

13.3.1?finally

13.4?Invarianten erzwingen

13.5?Ausnahmen auslösen und abfangen

13.5.1?Ausnahmen auslösen

13.5.1.1?noexcept-Funktionen

13.5.1.2?Der Operator noexcept

13.5.1.3?Ausnahmespezifikationen

13.5.2?Ausnahmen abfangen

13.5.2.1?Ausnahmen erneut auslösen

13.5.2.2?Jede Ausnahme abfangen

13.5.2.3?Mehrere Handler

13.5.2.4?try-Blöcke in Funktionen

13.5.2.5?Beendigung

13.5.3?Ausnahmen und Threads

13.6?Eine vector-Implementierung

13.6.1?Ein einfacher vector

13.6.2?Speicher explizit darstellen

13.6.3?Zuweisung

13.6.4?Größe ändern

13.6.4.1?reserve()

13.6.4.2?resize()

13.6.4.3?push_back()

13.6.4.4?Abschließende Gedanken

13.7?Ratschläge

14 Namespaces

14.1?Kompositionsprobleme

14.2?Namespaces

14.2.1?Explizite Qualifizierung

14.2.2?using-Deklarationen

14.2.3?using-Direktiven

14.2.4?Argumentabhängige Namensauflösung

14.2.5?Namespaces sind offen

14.3?Modularisierung und Schnittstellen

14.3.1?Namespaces als Module

14.3.2?Implementierungen

14.3.3?Schnittstellen und Implementierungen

14.4?Komposition mit Namespaces

14.4.1?Komfort vs. Sicherheit

14.4.2?Namespace-Alias

14.4.3?Namespaces zusammensetzen

14.4.4?Komposition und Auswahl

14.4.5?Namespaces und Überladen

14.4.6?Versionsverwaltung

14.4.7?Verschachtelte Namespaces

14.4.8?Unbenannte Namespaces

14.4.9?C-Header

14.5?Ratschläge

15 Quelldateien und Programme

15.1?Separate Übersetzung

15.2?Binden

15.2.1?Dateilokale Namen

15.2.2?Header-Dateien

15.2.3?Die Eine-Definition-Regel

15.2.4?Header der Standardbibliothek

15.2.5?Binden mit Nicht-C++-Code

15.2.6?Binden und Zeiger auf Funktionen

15.3?Header-Dateien verwenden

15.3.1?Organisation mit einzelnem Header

15.3.2?Organisation mit mehreren Header-Dateien

15.3.2.1?Andere Taschenrechnermodule

15.3.2.2?Header verwenden

15.3.3?Include-Wächter

15.4?Programme

15.4.1?Initialisierung von nichtlokalen Variablen

15.4.2?Initialisierung und Nebenläufigkeit

15.4.3?Programmbeendigung

15.5?Ratschläge

Teil III Abstraktions­mechanismen

16 Klassen

16.1?Einführung

16.2?Grundlagen von Klassen

16.2.1?Member-Funktionen

16.2.2?Standardmäßiges Kopieren

16.2.3?Zugriffskontrolle

16.2.4?class und struct

16.2.5?Konstruktoren

16.2.6?Explizite Konstruktoren

16.2.7?Klasseninterne Initialisierer

16.2.8?Klasseninterne Funktionsdefinitionen

16.2.9?Veränderlichkeit

16.2.9.1?Konstante Member-Funktionen

16.2.9.2?Physische und logische Konstanz

16.2.9.3?mutable

16.2.9.4?Veränderlichkeit über Indirektion

16.2.10?Selbstreferenz

16.2.11?Member-Zugriff

16.2.12?Statische Member

16.2.13?Member-Typen

16.3?Konkrete Klassen

16.3.1?Member-Funktionen

16.3.2?Hilfsfunktionen

16.3.3?Überladene Operatoren

16.3.4?Der Stellenwert von konkreten Klassen

16.4?Ratschläge

17 Konstruieren, Aufräumen, Kopieren und Verschieben

17.1?Einführung

17.2?Konstruktoren und Destruktoren

17.2.1?Konstruktoren und Invarianten

17.2.2?Destruktoren und Ressourcen

17.2.3?Basis- und Member-Destruktoren

17.2.4?Konstruktoren und Destruktoren aufrufen

17.2.5?Virtuelle Destruktoren

17.3?Initialisierung von Klassenobjekten

17.3.1?Initialisierung ohne Konstruktoren

17.3.2?Initialisierung mithilfe von Konstruktoren

17.3.2.1?Initialisierung durch Konstruktoren

17.3.3?Standardkonstruktoren

17.3.4?Initialisierungslisten-Konstruktoren

17.3.4.1?Mehrdeutigkeiten bei Initialisierungslisten-Konstruktoren auflösen

17.3.4.2?Initialisierungslisten verwenden

17.3.4.3?Direkte und Kopierinitialisierung

17.4 Initialisierung von Membern und Basisklassen

17.4.1?Member-Initialisierung

17.4.1.1?Member-Initialisierung und -Zuweisung

17.4.2?Basisklassen-Initialisierer

17.4.3?Konstruktoren delegieren

17.4.4?Klasseninterne Initialisierer

17.4.5?Initialisierer statischer Member

17.5?Kopieren und verschieben

17.5.1?Kopieren

17.5.1.1?Vorsicht vor Standardkonstruktoren

17.5.1.2?Kopieren von Basisklassen

17.5.1.3?Was Kopieren bedeutet

17.5.1.4?Slicing

17.5.2?Verschieben

17.6?Standardoperationen generieren

17.6.1?Explizite Standardoperationen

17.6.2?Standardoperationen

17.6.3?Standardoperationen verwenden

17.6.3.1?Standardkonstruktoren

17.6.3.2?Invarianten bewahren

17.6.3.3?Ressourceninvarianten

17.6.3.4?Partiell spezifizierte Invarianten

17.6.4?Gelöschte Funktionen

17.7?Ratschläge

18 Überladen von Operatoren

18.1?Einführung

18.2?Operatorfunktionen

18.2.1?Binäre und unäre Operatoren

18.2.2?Vordefinierte Bedeutungen für Operatoren

18.2.3?Operatoren und benutzerdefinierte Typen

18.2.4?Objekte übergeben

18.2.5?Operatoren in Namespaces

18.3?Ein Typ für komplexe Zahlen

18.3.1?Member- und Nicht-Member-Operatoren

18.3.2?Arithmetik mit gemischten Datentypen

18.3.3?Konvertierungen

18.3.3.1?Konvertierung von Operanden

18.3.4?Literale

18.3.5?Zugriffsfunktionen

18.3.6?Hilfsfunktionen

18.4?Typumwandlung

18.4.1?Konvertierungsoperatoren

18.4.2?Explizite Konvertierungsoperatoren

18.4.3?Mehrdeutigkeiten

18.5?Ratschläge

19 Spezielle Operatoren

19.1?Einführung

19.2?Spezielle Operatoren

19.2.1?Indizierung

19.2.2?Funktionsaufruf

19.2.3?Dereferenzieren

19.2.4?Inkrementieren und Dekrementieren

19.2.5?Allokation und Deallokation

19.2.6?Benutzerdefinierte Literale

19.3?Eine String-Klasse

19.3.1?Wesentliche Operationen

19.3.2?Zugriff auf Zeichen

19.3.3?Darstellung

19.3.3.1?Ergänzende Funktionen

19.3.4?Member-Funktionen

19.3.5?Hilfsfunktionen

19.3.6?Unsere String-Klasse verwenden

19.4?Friends

19.4.1?Friends finden

19.4.2?Friends und Member

19.5?Ratschläge

20 Abgeleitete Klassen

20.1?Einführung

20.2?Abgeleitete Klassen

20.2.1?Member-Funktionen

20.2.2?Konstruktoren und Destruktoren

20.3?Klassenhierarchien

20.3.1?Typfelder

20.3.2?Virtuelle Funktionen

20.3.3?Explizite Qualifizierung

20.3.4?Überschreiben steuern

20.3.4.1?override

20.3.4.2?final

20.3.5?Member der Basisklasse verwenden

20.3.5.1?Konstruktoren vererben

20.3.6?Lockerung bei Rückgabetypen

20.4?Abstrakte Klassen

20.5?Zugriffskontrolle

20.5.1?Geschützte Member

20.5.1.1?Geschützte Member verwenden

20.5.2?Zugriff auf Basisklassen

20.5.2.1?Mehrfachvererbung und Zugriffskontrolle

20.5.3?using-Deklarationen und Zugriffskontrolle

20.6?Zeiger auf Member

20.6.1?Zeiger auf Funktions-Member

20.6.2?Zeiger auf Daten-Member

20.6.3?Basis- und abgeleitete Member

20.7?Ratschläge

21 Klassenhierarchien

21.1?Einführung

21.2?Klassenhierarchien entwerfen

21.2.1?Implementierungsvererbung

21.2.1.1?Kritische Betrachtungen

21.2.2?Schnittstellenvererbung

21.2.3?Alternative Implementierungen

21.2.3.1?Kritische Betrachtungen

21.2.4?Objekterstellung örtlich begrenzen

21.3?Mehrfachvererbung

21.3.1?Mehrfachschnittstellen

21.3.2?Mehrere Implementierungsklassen

21.3.3?Auflösung von Mehrdeutigkeiten

21.3.4?Eine Basisklasse wiederholt verwenden

21.3.5?Virtuelle Basisklassen

21.3.5.1?Virtuelle Basisklassen konstruieren

21.3.5.2?Member einer virtuellen Klasse nur einmal aufrufen

21.3.6?Replizierte und virtuelle Basisklassen

21.3.6.1?Funktionen virtueller Basisklassen überschreiben

21.4?Ratschläge

22 Laufzeit-Typinformationen

22.1?Einführung

22.2?Navigation in der Klassenhierarchie

22.2.1?dynamic_cast

22.2.1.1?dynamic_cast in Referenz

22.2.2?Mehrfachvererbung

22.2.3?static_cast und dynamic_cast

22.2.4?Eine Schnittstelle zurückgewinnen

22.3?Doppelte Bindung und Besucher

22.3.1?Doppelte Bindung

22.3.2?Besucher

22.4?Konstruktion und Destruktion

22.5?Typidentifizierung

22.5.1?Erweiterte Typinformationen

22.6?RTTI – richtig und falsch eingesetzt

22.7?Ratschläge

23 Templates

23.1?Einführung und Überblick

23.2?Ein einfaches String-Template

23.2.1?Ein Template definieren

23.2.2?Template-Instanziierung

23.3?Typprüfung

23.3.1?Typäquivalenz

23.3.2?Fehlererkennung

23.4?Member von Klassen-Templates

23.4.1?Daten-Member

23.4.2?Member-Funktionen

23.4.3?Member-Typalias

23.4.4?Statische Member

23.4.5?Member-Typen

23.4.6?Member-Templates

23.4.6.1?Templates und Konstruktoren

23.4.6.2?Templates und virtual

23.4.6.3?Verschachtelungen

23.4.7?Friends

23.5?Funktions-Templates

23.5.1?Argumente von Funktions-Templates

23.5.2?Funktions-Template-Argumente herleiten

23.5.2.1?Referenzherleitung

23.5.3?Überladen von Funktions-Templates

23.5.3.1?Mehrdeutigkeiten auflösen

23.5.3.2?Fehler bei Argumentersetzung

23.5.3.3?Überladen und Ableitung

23.5.3.4?Überladen und nicht hergeleitete Parameter

23.6?Template-Alias

23.7?Quellcodeorganisation

23.7.1?Binden

23.8?Ratschläge

24 Generische Programmierung

24.1?Einführung

24.2?Algorithmen und Lifting

24.3?Konzepte

24.3.1?Ein Konzept erkennen

24.3.2?Konzepte und Einschränkungen

24.4?Konzepte konkret machen

24.4.1?Axiome

24.4.2?Konzepte mit mehreren Argumenten

24.4.3?Wertkonzepte

24.4.4?Einschränkungsüberprüfungen

24.4.5?Überprüfung von Template-Definitionen

24.5?Ratschläge

25 Spezialisierung

25.1?Einführung

25.2?Template-Parameter und -Argumente

25.2.1?Typen als Argumente

25.2.2?Werte als Argumente

25.2.3?Operationen als Argumente

25.2.4?Templates als Argumente

25.2.5?Template-Standardargumente

25.2.5.1?Standardargumente bei Funktions-Templates

25.3?Spezialisierung

25.3.1?Schnittstellenspezialisierung

25.3.1.1?Implementierungsspezialisierung

25.3.2?Das primäre Template

25.3.3?Reihenfolge der Spezialisierung

25.3.4?Funktions-Template-Spezialisierung

25.3.4.1?Spezialisierung und Überladen

25.3.4.2?Spezialisierung, die kein Überladen ist

25.4?Ratschläge

26 Instanziierung

26.1?Einführung

26.2?Template-Instanziierung

26.2.1?Wann wird Instanziierung gebraucht?

26.2.2?Manuelle Kontrolle der Instanziierung

26.3?Namensbindung

26.3.1?Abhängige Namen

26.3.2?Bindung am Punkt der Definition

26.3.3?Bindung am Punkt der Instanziierung

26.3.4?Mehrere Punkte der Instanziierung

26.3.5?Templates und Namespaces

26.3.6?Zu aggressive ADL

26.3.7?Namen aus Basisklassen

26.4?Ratschläge

27 Templates und Hierarchien

27.1?Einführung

27.2?Parametrisierung und Hierarchie

27.2.1?Generierte Typen

27.2.2?Template-Konvertierungen

27.3?Hierarchien von Klassen-Templates

27.3.1?Templates als Schnittstellen

27.4?Template-Parameter als Basisklassen

27.4.1?Datenstrukturen zusammensetzen

27.4.2?Klassenhierarchien linearisieren

27.5?Ratschläge

28 Metaprogrammierung

28.1?Einführung

28.2?Typfunktionen

28.2.1?Typalias

28.2.1.1?Wann man keinen Alias verwendet

28.2.2?Typprädikate

28.2.3?Eine Funktion auswählen

28.2.4?Traits

28.3?Steuerungsstrukturen

28.3.1?Auswahl

28.3.1.1?Zwischen zwei Typen auswählen

28.3.1.2?Übersetzungszeit versus Laufzeit

28.3.1.3?Zwischen mehreren Typen auswählen

28.3.2?Iteration und Rekursion

28.3.2.1?Rekursion mit Klassen

28.3.3?Wann man Metaprogrammierung verwendet

28.4?Bedingte Definition: Enable_if

28.4.1?Enable_if verwenden

28.4.2?Enable_if implementieren

28.4.3?Enable_if und Konzepte

28.4.4?Weitere Beispiele mit Enable_if

28.5?Eine Liste zur Übersetzungszeit: Tuple

28.5.1?Eine einfache Ausgabefunktion

28.5.2?Elementzugriff

28.5.2.1?Konstante Tupel

28.5.3?make_tuple

28.6?Variadische Templates

28.6.1?Eine typsichere printf()-Funktion

28.6.2?Technische Details

28.6.3?Weiterleitung

28.6.4?Der Typ tuple der Standardbibliothek

28.7?Beispiel: SI-Einheiten

28.7.1?Einheiten

28.7.2?Größen

28.7.3?Literale für Einheiten

28.7.4?Hilfsfunktionen

28.8?Ratschläge

29 Ein Matrix-Design

29.1?Einführung

29.1.1?Einfache Anwendungen von Matrix

29.1.2?Anforderungen an Matrix

29.2?Ein Matrix-Template

29.2.1?Konstruktion und Zuweisung

29.2.2?Indizierung und Slicing

29.3?Arithmetische Matrix-Operationen

29.3.1?Skalaroperationen

29.3.2?Addition

29.3.3?Multiplikation

29.4?Matrix-Implementierung

29.4.1?slice()

29.4.2?Matrix-Slices

29.4.3?Matrix_ref

29.4.4?Matrix-Listeninitialisierung

29.4.5?Matrix-Zugriff

29.4.6?Nulldimensionale Matrix

29.5?Lineare Gleichungen lösen

29.5.1?Das klassische gaußsche Eliminationsverfahren

29.5.2?Pivotisierung

29.5.3?Testen

29.5.4?Verschmolzene Operationen

29.6?Ratschläge

Teil IVDie Standardbibliothek

30 Überblick über die Standardbibliothek

30.1?Einführung

30.1.1?Komponenten der Standardbibliothek

30.1.2?Designeinschränkungen

30.1.3?Beschreibungsstil

30.2?Header

30.3?Sprachunterstützung

30.3.1?Unterstützung für Initialisierungslisten

30.3.2?Unterstützung für bereichsbasierte for-Anweisung

30.4?Fehlerbehandlung

30.4.1?Ausnahmen

30.4.1.1?Die Hierarchie der Standardausnahmen

30.4.1.2?Weiterleitung von Ausnahmen

30.4.1.3?terminate()

30.4.2?Assertionen

30.4.3?system_error

30.4.3.1?Fehlercodes

30.4.3.2?Fehlerkategorien

30.4.3.3?system_error-Ausnahme

30.4.3.4?Potenziell portable Fehlerbedingungen

30.4.3.5?Fehlercodes zuordnen

30.4.3.6?errc-Fehlercodes

30.4.3.7?future_errc-Fehlercodes

30.4.3.8?io_errc-Fehlercodes

30.5?Ratschläge

31 STL-Container

31.1?Einführung

31.2?Überblick über Container

31.2.1?Containerdarstellung

31.2.2?Anforderungen an die Elemente

31.2.2.1?Vergleiche

31.2.2.2?Andere relationale Operatoren

31.3?Operatoren im Überblick

31.3.1?Member-Typen

31.3.2?Konstruktoren, Destruktor und Zuweisungen

31.3.3?Größe und Kapazität

31.3.4?Iteratoren

31.3.5?Elementzugriff

31.3.6?Stack-Operationen

31.3.7?Listenoperationen

31.3.8?Andere Operationen

31.4?Container

31.4.1?vector

31.4.1.1?vector und Wachstum

31.4.1.2?vector und Verschachtelung

31.4.1.3?vector und Arrays

31.4.1.4?vector und string

31.4.2?Listen

31.4.3?Assoziative Container

31.4.3.1?Geordnete assoziative Container

31.4.3.2?Ungeordnete assoziative Container

31.4.3.3?Ungeordnete Maps konstruieren

31.4.3.4?Hash- und Gleichheitsfunktionen

31.4.3.5?Lastfaktor und Buckets

31.5?Containeradapter

31.5.1?stack

31.5.2?queue

31.5.3?priority_queue

31.6?Ratschläge

32 STL-Algorithmen

32.1?Einführung

32.2?Algorithmen

32.2.1?Sequenzen

32.3?Richtlinienargumente

32.3.1?Komplexität

32.4 Nichtmodifizierende Sequenz­algorithmen

32.4.1?for_each()

32.4.2?Sequenzprädikate

32.4.3?count()

32.4.4?find()

32.4.5?equal() und mismatch()

32.4.6?search()

32.5?Modifizierende Sequenzalgorithmen

32.5.1?copy()

32.5.2?unique()

32.5.3?remove(), reverse() und replace()

32.5.4?rotate(), random_shuffle() und partition()

32.5.5?Permutationen

32.5.6?fill()

32.5.7?swap()

32.6?Sortieren und Suchen

32.6.1?Binäre Suche

32.6.2?merge()

32.6.3?Mengenalgorithmen

32.6.4?Heaps

32.6.5?lexicographical_compare()

32.7?Minimum und Maximum

32.8?Ratschläge

33 STL-Iteratoren

33.1?Einführung

33.1.1?Iteratormodell

33.1.2?Iteratorkategorien

33.1.3?Iterator-Traits

33.1.4?Iteratoroperationen

33.2?Iteratoradapter

33.2.1?Reverse-Iteratoren

33.2.2?Einfügeiteratoren

33.2.3?Verschiebeiteratoren

33.3?Bereichszugriffsfunktionen

33.4?Funktionsobjekte

33.5?Funktionsadapter

33.5.1?bind()

33.5.2?mem_fn()

33.5.3?function

33.6?Ratschläge

34 Speicher und Ressourcen

34.1?Einführung

34.2?„Beinahe-Container“

34.2.1?array

34.2.2?bitset

34.2.2.1?Konstruktoren

34.2.2.2?bitset-Operationen

34.2.3?vector

34.2.4?Tupel

34.2.4.1?pair

34.2.4.2?tuple

34.3?Ressourcenverwaltungszeiger

34.3.1?unique_ptr

34.3.2?shared_ptr

34.3.3?weak_ptr

34.4?Allokatoren

34.4.1?Der Standard-Allokator

34.4.2?Allokator-Traits

34.4.3?Zeiger-Traits

34.4.4?Allokatoren mit eigenem Gültigkeitsbereich

34.5?Die Schnittstelle zur Garbage Collection

34.6?Nichtinitialisierter Speicher

34.6.1?Temporäre Puffer

34.6.2?raw_storage_iterator

34.7?Ratschläge

35 Utilities

35.1?Einführung

35.2?Zeit

35.2.1?duration

35.2.2?time_point

35.2.3?Zeitgeber

35.2.4?Zeit-Traits

35.3 Rationale Arithmetik zur ­Übersetzungszeit

35.4?Typfunktionen

35.4.1?Typ-Traits

35.4.2?Typgeneratoren

35.5?Kleinere Utilities

35.5.1?move() and forward()

35.5.2?swap()

35.5.3?Relationale Operatoren

35.5.4?Vergleichen und Hashing von type_info

35.6?Ratschläge

36 Strings

36.1?Einführung

36.2?Zeichenklassifizierung

36.2.1?Klassifizierungsfunktionen

36.2.2?Zeichen-Traits

36.3?Strings

36.3.1?string im Vergleich zu C-Strings

36.3.2?Konstruktoren

36.3.3?Fundamentale Operationen

36.3.4?String-Ein-/Ausgabe

36.3.5?Numerische Konvertierungen

36.3.6?STL-ähnliche Operationen

36.3.7?Die find-Familie

36.3.8?Teilstrings

36.4?Ratschläge

37 Reguläre Ausdrücke

37.1?Reguläre Ausdrücke

37.1.1?Notation regulärer Ausdrücke

37.2?regex

37.2.1?Übereinstimmungsergebnisse

37.2.2?Formatierung

37.3?Funktionen für reguläre Ausdrücke

37.3.1?regex_match()

37.3.2?regex_search()

37.3.3?regex_replace()

37.4?Iteratoren für reguläre Ausdrücke

37.4.1?regex_iterator

37.4.2?regex_token_iterator

37.5?regex_traits

37.6?Ratschläge

38 E/A-Streams

38.1?Einführung

38.2?Die E/A-Stream-Hierarchie

38.2.1?Datei-Streams

38.2.2?String-Streams

38.3?Fehlerbehandlung

38.4?Ein-/Ausgabeoperationen

38.4.1?Eingabeoperationen

38.4.1.1?Formatierte Eingabe

38.4.1.2?Unformatierte Eingabe

38.4.2?Ausgabeoperationen

38.4.2.1?Virtuelle Ausgabefunktionen

38.4.3?Manipulatoren

38.4.4?Stream-Status

38.4.5?Formatierung

38.4.5.1?Formatierungsstatus

38.4.5.2?Standardmanipulatoren

38.4.5.3?Benutzerdefinierte Manipulatoren

38.5?Stream-Iteratoren

38.6?Puffer

38.6.1?Ausgabe-Streams und -puffer

38.6.2?Eingabe-Streams und -puffer

38.6.3?Pufferiteratoren

38.6.3.1?istreambuf_iterator

38.6.3.2?ostreambuf_iterator

38.7?Ratschläge

39 Locales

39.1?Kulturelle Unterschiede behandeln

39.2?Die Klasse locale

39.2.1?Benannte Locales

39.2.1.1?Neue Locales konstruieren

39.2.2?Strings vergleichen

39.3?Die Klasse facet

39.3.1?Auf Facetten in einem Locale zugreifen

39.3.2?Eine einfache benutzerdefinierte Facette

39.3.3?Locales und Facetten verwenden

39.4?Standardfacetten

39.4.1?String-Vergleich

39.4.1.1?Benannte collate-Facetten

39.4.2?Numerische Formatierung

39.4.2.1?Numerische Interpunktion

39.4.2.2?Numerische Ausgabe

39.4.2.3?Numerische Eingabe

39.4.3?Formatierung von Geldbeträgen

39.4.3.1?Interpunktion bei Geldbeträgen

39.4.3.2?Ausgabe von Geldbeträgen

39.4.3.3?Eingabe von Geldbeträgen

39.4.4?Datum und Uhrzeit formatieren

39.4.4.1?time_put

39.4.4.2?time_get

39.4.5?Zeichenklassifizierung

39.4.6?Zeichencodes konvertieren

39.4.7?Meldungen

39.4.7.1?Meldungen von anderen Facetten verwenden

39.5?Komfortschnittstellen

39.5.1?Zeichenklassifizierung

39.5.2?Zeichenkonvertierungen

39.5.3?String-Konvertierungen

39.5.4?Pufferkonvertierungen

39.6?Ratschläge

40 Numerische Berechnungen

40.1?Einführung

40.2?Numerische Grenzen

40.2.1?Makros für Grenzwerte

40.3?Mathematische Standardfunktionen

40.4?Komplexe Zahlen

40.5?Ein numerisches Array: valarray

40.5.1?Konstruktoren und Zuweisungen

40.5.2?Indizierung

40.5.3?Operationen

40.5.4?Slices

40.5.5?slice_array

40.5.6?Verallgemeinerte Slices

40.6 Verallgemeinerte numerische ­Algorithmen

40.6.1?accumulate()

40.6.2?inner_product()

40.6.3?partial_sum() und adjacent_difference()

40.6.4?iota()

40.7?Zufallszahlen

40.7.1?Zufallszahlenmodule

40.7.2?Zufallsgerät

40.7.3?Verteilungen

40.7.4?Zufallszahlen im Stil von C

40.8?Ratschläge

41 Nebenläufigkeit

41.1?Einführung

41.2?Speichermodelle

41.2.1?Speicherstellen

41.2.2?Umordnung von Befehlen

41.2.3?Speicherordnung

41.2.4?Data Races

41.3?Atomare Datentypen

41.3.1?Atomare Typen

41.3.2?Flags und Fences

41.3.3?Atomare Flags

41.3.3.1?Fences

41.4?volatile

41.5?Ratschläge

42 Threads und Tasks

42.1?Einführung

42.2?Threads

42.2.1?Identität

42.2.2?Konstruktion

42.2.3?Zerstörung

42.2.4?join()

42.2.5?detach()

42.2.6?Namespace this_thread

42.2.7?Einen Thread vorzeitig beenden

42.2.8?thread_local-Daten

42.3?Data Races vermeiden

42.3.1?Mutexe

42.3.1.1?mutex und recursive_mutex

42.3.1.2?mutex-Fehler

42.3.1.3?timed_mutex und recursive_timed_mutex

42.3.1.4?lock_guard und unique_lock

42.3.2?Mehrere Sperren

42.3.3?call_once()

42.3.4?Bedingungsvariablen

42.3.4.1?condition_variable_any

42.4?Task-basierte Nebenläufigkeit

42.4.1?future und promise

42.4.2?promise

42.4.3?packaged_task

42.4.4?future

42.4.5?shared_future

42.4.6?async()

42.4.7?Ein paralleles find()-Beispiel

42.5?Ratschläge

43 Die C-Standard­bibliothek

43.1?Einführung

43.2?Dateien

43.3?Die printf()-Familie

43.4?C-Strings

43.5?Speicher

43.6?Datum und Uhrzeit

43.7?Diverses

43.8?Ratschläge

44 Kompatibilität

44.1?Einführung

44.2?C++11-Erweiterungen

44.2.1?Sprachfeatures

44.2.2?Komponenten der Standardbibliothek

44.2.3?Veraltete Features

44.2.4?Umgang mit älteren C++-Implementierungen

44.3?C/C++-Kompatibilität

44.3.1?C und C++ sind Geschwister

44.3.2?„Stillschweigende“ Unterschiede

44.3.3?C-Code, der kein C++ ist

44.3.3.1?Probleme mit „klassischem C“

44.3.3.2?C-Features, die von C++ nicht übernommen wurden

44.3.4?C++-Code, der kein C ist

44.4?Ratschläge

Index