Forschung mit modernem C++

Vorwort

Danksagungen

Über den Autor

Inhalt

1 Grundlagen

1.1 Unser erstes Programm

1.2 Variablen

1.2.1 Fundamentale Typen

1.2.2 Characters und Strings

1.2.3 Variablen deklarieren

1.2.4 Konstanten

1.2.5 Literale

1.2.6 Werterhaltende Initialisierung

1.2.7 Gültigkeitsbereiche

1.3 Operatoren

1.3.1 Arithmetische Operatoren

1.3.2 Boolesche Operatoren

1.3.3 Bitweise Operatoren

1.3.4 Zuweisung

1.3.5 Programmablauf

1.3.6 Speicherverwaltung

1.3.7 Zugriffsoperatoren

1.3.8 Typbehandlung

1.3.9 Fehlerbehandlung

1.3.10 Überladung

1.3.11 Operatorprioritäten

1.3.12 Vermeiden Sie Seiteneffekte!

1.4 Ausdrücke und Anweisungen

1.4.1 Ausdrücke

1.4.2 Anweisungen

1.4.3 Verzweigung

1.4.4 Schleifen

1.4.5 goto

1.5 Funktionen

1.5.1 Argumente

1.5.2 Rückgabe der Ergebnisse

1.5.3 Inlining

1.5.4 Überladen

1.5.5 Die main-Funktion

1.6 Fehlerbehandlung

1.6.1 Zusicherungen

1.6.2 Ausnahmen

1.6.3 Statische Zusicherungen

1.7 I/O

1.7.1 Standard-Ausgabe

1.7.2 Standard-Eingabe

1.7.3 Ein-/Ausgabe mit Dateien

1.7.4 Generisches Stream-Konzept

1.7.5 Formatierung

1.7.6 I/O-Fehler behandeln

1.7.7 File-System

1.8 Arrays, Zeiger und Referenzen

1.8.1 Arrays

1.8.2 Zeiger

1.8.3 Intelligente Zeiger

1.8.4 Referenzen

1.8.5 Vergleich zwischen Zeigern und Referenzen

1.8.6 Nicht auf abgelaufene Daten verweisen!

1.8.7 Containers for Arrays

1.9 Strukturierung von Software-Projekten

1.9.1 Kommentare

1.9.2 Präprozessor-Direktiven

1.10 Aufgaben

1.10.1 Verengung

1.10.2 Literale

1.10.3 Operatoren

1.10.4 Verzweigung

1.10.5 Schleifen

1.10.6 I/O

1.10.7 Arrays und Zeiger

1.10.8 Funktionen

2 Klassen

2.1 Universell programmieren,nicht detailversessen

2.2 Member

2.2.1 Mitgliedervariablen

2.2.2 Zugriffsrechte

2.2.3 Zugriffsoperatoren

2.2.4 Der static-Deklarator für Klassen

2.2.5 Member-Funktionen

2.3 Konstruktoren und Zuweisungen

2.3.1 Konstruktoren

2.3.2 Zuweisungen

2.3.3 Initialisierungslisten

2.3.4 Einheitliche Initialisierung

2.3.5 Move-Semantik

2.3.6 Objekte aus Literalen konstruieren

2.4 Destruktoren

2.4.1 Implementierungsregeln

2.4.2 Richtiger Umgang mit Ressourcen

2.5 Zusammenfassung der Methodengenerierung

2.6 Zugriff auf Mitgliedervariablen

2.6.1 Zugriffsfunktionen

2.6.2 Index-Operator

2.6.3 Konstante Mitgliederfunktionen

2.6.4 Referenz-qualifizierte Mitglieder

2.7 Design von Operatorüberladung

2.7.1 Seien Sie konsistent!

2.7.2 Die Priorität respektieren

2.7.3 Methoden oder freie Funktionen

2.8 Aufgaben

2.8.1 Polynomial

2.8.2 Rational

2.8.3 Move-Zuweisung

2.8.4 Initialisierungsliste

2.8.5 Ressourcenrettung

3 Generische Programmierung

3.1 Funktions-Templates

3.1.1 Parametertyp-Deduktion

3.1.2 Mit Fehlern in Templates klarkommen

3.1.3 Gemischte Typen

3.1.4 Einheitliche Initialisierung

3.1.5 Automatischer Rückgabetyp

3.2 Namensräume und Funktionssuche

3.2.1 Namensräume

3.2.2 Argumentabhängiges Nachschlagen

3.2.3 Namensraum-Qualifizierung oder ADL

3.3 Klassen-Templates

3.3.1 Ein Container-Beispiel

3.3.2 Einheitliche Klassen- und Funktionsschnittstellen entwerfen

3.4 Typ-Deduktion und -Definition

3.4.1 Automatische Variablentypen

3.4.2 Typ eines Ausdrucks

3.4.3 decltype(auto)

3.4.4 Deduzierte Klassen-Template-Parameter

3.4.5 Mehrere Typen deduzieren

3.4.6 Typen definieren

3.5 Etwas Theorie zu Templates: Konzepte

3.6 Template-Spezialisierung

3.6.1 Spezialisierung einer Klasse für einen Typ

3.6.2 Funktionen Spezialisieren und Überladen

3.6.3 Partielle Spezialisierung von Klassen

3.6.4 Partiell spezialisierte Funktionen

3.6.5 Strukturierte Bindung mit Nutzertypen

3.7 Nicht-Typ-Parameter für Templates

3.7.1 Container fester Größe

3.7.2 Nicht-Typ-Parameter deduzieren

3.8 Funktoren

3.8.1 Funktionsartige Parameter

3.8.2 Funktoren zusammensetzen

3.8.3 Rekursion

3.8.4 Generische Reduktion

3.9 Lambdas

3.9.1 Objekte erfassen

3.9.2 Generische Lambdas

3.10 Variablen-Templates

3.11 Variadische Templates

3.11.1 Rekursive Funktionen

3.11.2 Direkte Expansion

3.11.3 Indexsequenzen

3.11.4 Faltung

3.11.5 Typgeneratoren

3.11.6 Wachsende Tests

3.12 Übungen

3.12.1 String-Darstellung

3.12.2 String-Darstellung von Tupeln

3.12.3 Generischer Stack

3.12.4 Rationale Zahlen mit Typparameter

3.12.5 Iterator eines Vektors

3.12.6 Ungerader Iterator

3.12.7 Bereich von ungeraden Zahlen

3.12.8 Stack von bool

3.12.9 Stack mit nutzerdefinierter Größe

3.12.10 Deduktion von Nicht-Typ-Template-Argumenten

3.12.11 Trapez-Regel

3.12.12 Partielle Spezialisierung mit einer statischen Funktion

3.12.13 Funktor

3.12.14 Lambda

3.12.15 Implementieren Sie make_unique

4 Bibliotheken

4.1 Standard-Template-Library

4.1.1 Einführendes Beispiel

4.1.2 Iteratoren

4.1.3 Container

4.1.4 Algorithmen

4.1.5 Jenseits von Iteratoren

4.1.6 Parallele Berechnung

4.2 Numerik

4.2.1 Komplexe Zahlen

4.2.2 Zufallszahlengeneratoren

4.2.3 Mathematische Spezialfunktionen

4.3 Meta-Programmierung

4.3.1 Wertgrenzen

4.3.2 Typeigenschaften

4.4 Utilities

4.4.1 optional

4.4.2 Tupel

4.4.3 variant

4.4.4 any

4.4.5 string_view

4.4.6 function

4.4.7 Referenz-Wrapper

4.5 Die Zeit ist gekommen

4.6 Parallelität

4.6.1 Terminologie

4.6.2 Überblick

4.6.3 Threads

4.6.4 Rückmeldung an den Aufrufer

4.6.5 Asynchrone Aufrufe

4.6.6 Asynchroner Gleichungslöser

4.6.7 Variadische Mutex-Sperre

4.7 Wissenschaftliche Bibliotheken jenseits des Standards

4.7.1 Andere Arithmetiken

4.7.2 Intervallarithmetik

4.7.3 Lineare Algebra

4.7.4 Gewöhnliche Differentialgleichungen

4.7.5 Partielle Differentialgleichungen

4.7.6 Graphenalgorithmen

4.8 Übungen

4.8.1 Sortierung nach Betrag

4.8.2 Suche mit einem Lambda als Prädikat

4.8.3 STL-Container

4.8.4 Komplexe Zahlen

4.8.5 Parallele Vektoraddition

4.8.6 Refaktorisierung der parallelen Addition

5 Meta-Programmierung

5.1 Lassen Sie den Compiler rechnen

5.1.1 Kompilierzeitfunktionen

5.1.2 Erweiterte Kompilierzeitfunktionen

5.1.3 Primzahlen

5.1.4 Wie konstant sind unsere Konstanten?

5.1.5 Kompilierzeit-Lambdas

5.2 Typinformationen

5.2.1 Typabhängige Funktionsergebnisse

5.2.2 Bedingte Ausnahmebehandlung

5.2.3 Ein Beispiel für eine const-korrekte View

5.2.4 Standard-Typmerkmale

5.2.5 Domän-spezifische Type-Traits

5.2.6 Typeigenschaften mit Überladung

5.2.7 enable_if

5.2.8 Variadische Templates überarbeitet

5.3 Expression-Templates

5.3.1 Einfache Implementierung eines Additionsoperators

5.3.2 Eine Klasse für Expression-Templates

5.3.3 Generische Expression-Templates

5.4 Compiler-Optimierung mit Meta-Tuning

5.4.1 Klassisches Abrollen mit fester Größe

5.4.2 Geschachteltes Abrollen

5.4.3 Aufwärmung zum dynamischen Abrollen

5.4.4 Abrollen von Vektorausdrücken

5.4.5 Tuning von Expression-Templates

5.4.6 Tuning von Reduktionen

5.4.7 Tuning geschachtelter Schleifen

5.4.8 Resümee des Tunings

5.5 Turing-Vollständigkeit

5.6 Übungen

5.6.1 Type-Traits

5.6.2 Fibonacci-Sequenz

5.6.3 Meta-Programm für den größten gemeinsamen Divisor

5.6.4 Rationale Zahlen mit gemischten Typen

5.6.5 Vektor-Expression-Template

5.6.6 Meta-Liste

6 Objektorientierte Programmierung

6.1 Grundprinzipien

6.1.1 Basis- und abgeleitete Klassen

6.1.2 Konstruktoren erben

6.1.3 Virtuelle Funktionen

6.1.4 Funktoren über Vererbung

6.1.5 Abgeleitete Klassen für Ausnahmen

6.2 Redundanz entfernen

6.3 Mehrfachvererbung

6.3.1 Mehrere Eltern

6.3.2 Gemeinsame Großeltern

6.4 Dynamische Auswahl von Subtypen

6.5 Konvertierung

6.5.1 Umwandlungen zwischen abgeleiteten Klassen

6.5.2 const_cast

6.5.3 Umdeutung

6.5.4 Umwandlung im Funktionsstil

6.5.5 Implizite Umwandlungen

6.6 CRTP

6.6.1 Ein einfaches Beispiel

6.6.2 Ein wiederverwendbarer Indexoperator

6.7 Übungen

6.7.1 Nicht-redundante Raute

6.7.2 Vektorklasse mit Vererbung

6.7.3 Ausnahmen in Vektor refaktorisieren

6.7.4 Test auf geworfene Ausnahme

6.7.5 Klonfunktion

7 Wissenschaftliche Projekte

7.1 Implementierung von ODE-Lösern

7.1.1 Gewöhnliche Differentialgleichungen

7.1.2 Runge-Kutta-Algorithmen

7.1.3 Generische Implementierung

7.1.4 Ausblick

7.2 Projekte erstellen

7.2.1 Build-Prozess

7.2.2 Build-Tools

7.2.3 Separates Kompilieren

7.3 Einige abschließende Worte

A Weitschweifendes

A.1 Mehr über gute und schlechte Software

A.2 Grundlagen im Detail

A.2.1 Statische Variablen

A.2.2 Mehr über if

A.2.3 Duff’s Device

A.2.4 Programmaufrufe

A.2.5 Zusicherung oder Ausnahme?

A.2.6 Binäre I/O

A.2.7 I/O im Stile von C

A.2.8 Garbarge-Collection

A.2.9 Ärger mit Makros

A.3 Praxisbeispiel: Matrix-Invertierung

A.4 Klassendetails

A.4.1 Zeiger auf Mitglieder

A.4.2 Weitere Initialisierungsbeispiele

A.4.3 Zugriff auf mehrdimensionale Datenstrukturen

A.5 Methodengenerierung

A.5.1 Automatische Generierung

A.5.2 Steuerung der Generierung

A.5.3 Generierungsregeln

A.5.4 Fallstricke und Designrichtlinien

A.6 Template-Details

A.6.1 Einheitliche Initialisierung

A.6.2 Welche Funktion wird aufgerufen?

A.6.3 Spezialisierung auf spezifische Hardware

A.6.4 Variadisches binäres I/O

A.7 Mehr über Bibliotheken

A.7.1 std::vector in C++03 verwenden

A.7.2 variant mal nerdisch

A.8 Dynamische Auswahl im alten Stil

A.9 Mehr über Meta-Programmierung

A.9.1 Das erste Meta-Programm in der Geschichte

A.9.2 Meta-Funktionen

A.9.3 Rückwärtskompatible statische Zusicherung

A.9.4 Anonyme Typparameter

A.9.5 Benchmark-Quellen für dynamisches Abrollen

A.9.6 Benchmark für Matrixprodukt

B Werkzeuge

B.1 g++

B.2 Debugging

B.2.1 Textbasierte Debugger

B.2.2 Debugging mit graphischen Interface: DDD

B.3 Speicheranalyse

B.4 gnuplot

B.5 Unix, Linux und Mac OS

C Sprachdefinitionen

C.1 Wertkategorien

C.2 Konvertierungsregeln

C.2.1 Aufwertung

C.2.2 Andere Konvertierungen

C.2.3 Arithmetische Konvertierungen

C.2.4 Verengung

Literatur

Abbildungsverzeichnis

Tabellenverzeichnis

Index