C++ by Will, Torsten T. -- Read -- Imperial Library of Trantor

Index

Aus dem Lektorat Inhaltsverzeichnis Vorwort

Vorwort zur 1. Auflage

Teil I Grundlagen 1 Das C++-Handbuch

1.1 Neu und modern 1.2 »Dan«-Kapitel 1.3 Darstellung in diesem Buch 1.4 Verwendete Formatierungen 1.5 Sorry for my Denglish

2 Programmieren in C++

2.1 Übersetzen 2.2 Übersetzungsphasen 2.3 Aktuelle Compiler

2.3.1 Gnu C++ 2.3.2 Clang++ von LLVM 2.3.3 Microsoft Visual C++ 2.3.4 Compiler im Container

2.4 Entwicklungsumgebungen 2.5 Die Kommandozeile unter Ubuntu

2.5.1 Ein Programm erstellen 2.5.2 Automatisieren mit Makefile

2.6 Die IDE »Visual Studio Code« unter Windows 2.7 Das Beispielprogramm beschleunigen

3 C++ für Umsteiger 4 Die Grundbausteine von C++

4.1 Ein schneller Überblick

4.1.1 Kommentare 4.1.2 Die »include«-Direktive 4.1.3 Die Standardbibliothek 4.1.4 Die Funktion »main()« 4.1.5 Typen 4.1.6 Variablen 4.1.7 Initialisierung 4.1.8 Ausgabe auf der Konsole 4.1.9 Anweisungen

4.2 Ohne Eile erklärt

4.2.1 Leerräume, Bezeichner und Token 4.2.2 Kommentare 4.2.3 Funktionen und Argumente 4.2.4 Seiteneffekt-Operatoren 4.2.5 Die »main«-Funktion 4.2.6 Anweisungen 4.2.7 Ausdrücke 4.2.8 Zuweisungen 4.2.9 Typen 4.2.10 Variablen – Deklaration, Definition und Initialisierung 4.2.11 Initialisieren mit »auto« 4.2.12 Details zur »include«-Direktive und »include« direkt 4.2.13 Module 4.2.14 Eingabe und Ausgabe 4.2.15 Der Namensraum »std«

4.3 Operatoren

4.3.1 Operatoren und Operanden 4.3.2 Überblick über Operatoren 4.3.3 Arithmetische Operatoren 4.3.4 Bitweise Arithmetik 4.3.5 Zusammengesetzte Zuweisung 4.3.6 Post- und Präinkrement sowie Post- und Prädekrement 4.3.7 Relationale Operatoren 4.3.8 Logische Operatoren 4.3.9 Pointer- und Dereferenzierungsoperatoren 4.3.10 Besondere Operatoren 4.3.11 Funktionsähnliche Operatoren 4.3.12 Operatorreihenfolge

4.4 Eingebaute Datentypen

4.4.1 Übersicht 4.4.2 Eingebaute Datentypen initialisieren 4.4.3 Ganzzahlen 4.4.4 Fließkommazahlen 4.4.5 Wahrheitswerte 4.4.6 Zeichentypen 4.4.7 Komplexe Zahlen

4.5 Undefiniertes und unspezifiziertes Verhalten

5 Guter Code, 1. Dan: Lesbar programmieren

5.1 Kommentare 5.2 Dokumentation 5.3 Einrückungen und Zeilenlänge 5.4 Zeilen pro Funktion und Datei 5.5 Klammern und Leerzeichen 5.6 Namen

6 Höhere Datentypen

6.1 Der Zeichenkettentyp »string«

6.1.1 Initialisierung 6.1.2 Funktionen und Methoden 6.1.3 Andere Stringtypen 6.1.4 Nur zur Ansicht: »string_view«

6.2 Streams

6.2.1 Eingabe- und Ausgabeoperatoren 6.2.2 »getline« 6.2.3 Dateien für die Ein- und Ausgabe 6.2.4 Manipulatoren 6.2.5 Der Manipulator »endl«

6.3 Behälter und Zeiger

6.3.1 Container 6.3.2 Parametrisierte Typen

6.4 Die einfachen Sequenzcontainer

6.4.1 »array« 6.4.2 »vector«

6.5 Algorithmen 6.6 Zeiger und C-Arrays

6.6.1 Zeigertypen 6.6.2 C-Arrays

7 Funktionen

7.1 Deklaration und Definition einer Funktion 7.2 Funktionstyp 7.3 Funktionen verwenden 7.4 Eine Funktion definieren 7.5 Mehr zu Parametern

7.5.1 Call-by-Value 7.5.2 Call-by-Reference 7.5.3 Konstante Referenzen 7.5.4 Aufruf als Wert, Referenz oder konstante Referenz?

7.6 Funktionskörper 7.7 Parameter umwandeln 7.8 Funktionen überladen 7.9 Defaultparameter 7.10 Beliebig viele Argumente 7.11 Alternative Schreibweise zur Funktionsdeklaration 7.12 Spezialitäten

7.12.1 »noexcept« 7.12.2 Inline-Funktionen 7.12.3 »constexpr« 7.12.4 Gelöschte Funktionen 7.12.5 Spezialitäten bei Klassenmethoden

8 Anweisungen im Detail

8.1 Der Anweisungsblock 8.2 Die leere Anweisung 8.3 Deklarationsanweisung 8.4 Die Ausdrucksanweisung 8.5 Die »if«-Anweisung 8.6 Die »while«-Schleife 8.7 Die »do-while«-Schleife 8.8 Die »for«-Schleife 8.9 Die bereichsbasierte »for«-Schleife 8.10 Die »switch«-Verzweigung 8.11 Die »break«-Anweisung 8.12 Die »continue«-Anweisung 8.13 Die »return«-Anweisung 8.14 Die »goto«-Anweisung 8.15 Der »try-catch«-Block und »throw« 8.16 Zusammenfassung

9 Ausdrücke im Detail

9.1 Berechnungen und Seiteneffekte 9.2 Arten von Ausdrücken 9.3 Literale 9.4 Bezeichner 9.5 Klammern 9.6 Funktionsaufruf und Indexzugriff 9.7 Zuweisung 9.8 Typumwandlung

10 Fehlerbehandlung

10.1 Fehlerbehandlung mit Fehlercodes 10.2 Was ist eine Ausnahme?

10.2.1 Ausnahmen auslösen und behandeln 10.2.2 Aufrufstapel abwickeln

10.3 Kleinere Fehlerbehandlungen 10.4 Weiterwerfen – »rethrow« 10.5 Die Reihenfolge im »catch«

10.5.1 Kein »finally« 10.5.2 Exceptions der Standardbibliothek

10.6 Typen für Exceptions 10.7 Wenn eine Exception aus »main« herausfällt

11 Guter Code, 2. Dan: Modularisierung

11.1 Programm, Bibliothek, Objektdatei 11.2 Bausteine 11.3 Trennen der Funktionalitäten 11.4 Ein modulares Beispielprojekt

11.4.1 Namensräume 11.4.2 Implementierung 11.4.3 Die Bibliothek nutzen

Teil II Objektorientierte Programmierung und mehr 12 Von der Struktur zur Klasse

12.1 Initialisierung 12.2 Rückgabe eigener Typen 12.3 Methoden statt Funktionen 12.4 Das bessere »drucke« 12.5 Eine Ausgabe wie jede andere 12.6 Methoden inline definieren 12.7 Implementierung und Definition trennen 12.8 Initialisierung per Konstruktor

12.8.1 Member-Defaultwerte in der Deklaration 12.8.2 Konstruktor-Delegation 12.8.3 Defaultwerte für die Konstruktorparameter 12.8.4 »init«-Methode nicht im Konstruktor aufrufen 12.8.5 Exceptions im Konstruktor

12.9 Struktur oder Klasse?

12.9.1 Kapselung 12.9.2 »public« und »private«, Struktur und Klasse 12.9.3 Daten mit »struct«, Verhalten mit »class« 12.9.4 Initialisierung von Typen mit privaten Daten

12.10 Zwischenergebnis 12.11 Eigene Datentypen verwenden

12.11.1 Klassen als Werte verwenden 12.11.2 Konstruktoren nutzen 12.11.3 Typumwandlungen 12.11.4 Kapseln und entkapseln 12.11.5 Typen lokal einen Namen geben

12.12 Typinferenz mit »auto« 12.13 Eigene Klassen in Standardcontainern

13 Namensräume und Qualifizierer

13.1 Der Namensraum »std« 13.2 Anonymer Namensraum 13.3 »static« macht lokal 13.4 »static« teilt gern 13.5 Ferne Initialisierung oder »static inline«-Datenfelder 13.6 Garantiert zur Compilezeit initialisiert mit »constinit« 13.7 »static« macht dauerhaft 13.8 »inline namespace« 13.9 Zusammenfassung 13.10 »const«

13.10.1 Const-Parameter 13.10.2 Const-Methoden 13.10.3 Const-Variablen 13.10.4 Const-Rückgaben 13.10.5 »const« zusammen mit »static« 13.10.6 Noch konstanter mit »constexpr« 13.10.7 »if constexpr« für Übersetzungszeit-Entscheidungen 13.10.8 C++20: »consteval« 13.10.9 »if consteval« 13.10.10 Un-Const mit »mutable« 13.10.11 Const-Korrektheit 13.10.12 Zusammenfassung

13.11 Flüchtig mit »volatile«

14 Guter Code, 3. Dan: Testen

14.1 Arten des Tests

14.1.1 Refactoring 14.1.2 Unittests 14.1.3 Sozial oder solitär 14.1.4 Doppelgänger 14.1.5 Suites

14.2 Frameworks

14.2.1 Arrange, Act, Assert 14.2.2 Frameworks zur Auswahl

14.3 Boost.Test 14.4 Hilfsmakros für Assertions 14.5 Ein Beispielprojekt mit Unittests

14.5.1 Privates und öffentliches Testen 14.5.2 Ein automatisches Testmodul 14.5.3 Test kompilieren 14.5.4 Die Testsuite selbst zusammenbauen 14.5.5 Testen von Privatem 14.5.6 Parametrisierte Tests

15 Vererbung

15.1 Beziehungen

15.1.1 Hat-ein-Komposition 15.1.2 Hat-ein-Aggregation 15.1.3 Ist-ein-Vererbung 15.1.4 Ist-Instanz-von versus Ist-ein-Beziehung

15.2 Vererbung in C++ 15.3 Hat-ein versus ist-ein 15.4 Gemeinsamkeiten finden 15.5 Abgeleitete Typen erweitern 15.6 Methoden überschreiben 15.7 Wie Methoden funktionieren 15.8 Virtuelle Methoden 15.9 Konstruktoren in Klassenhierarchien 15.10 Typumwandlung in Klassenhierarchien

15.10.1 Die Vererbungshierarchie aufwärts umwandeln 15.10.2 Die Vererbungshierarchie abwärts umwandeln 15.10.3 Referenzen behalten auch die Typinformation

15.11 Wann virtuell? 15.12 Andere Designs zur Erweiterbarkeit

16 Der Lebenszyklus von Klassen

16.1 Erzeugung und Zerstörung 16.2 Temporary: kurzlebige Werte 16.3 Der Destruktor zum Konstruktor

16.3.1 Kein Destruktor nötig 16.3.2 Ressourcen im Destruktor

16.4 Yoda-Bedingung 16.5 Konstruktion, Destruktion und Exceptions 16.6 Kopieren 16.7 Zuweisungsoperator 16.8 Streichen von Methoden 16.9 Verschiebeoperationen

16.9.1 Was der Compiler generiert

16.10 Operatoren 16.11 Eigene Operatoren in einem Datentyp 16.12 Besondere Klassenformen

16.12.1 Abstrakte Klassen und Methoden 16.12.2 Aufzählungsklassen

17 Guter Code, 4. Dan: Sicherheit, Qualität und Nachhaltigkeit

17.1 Die Nullerregel

17.1.1 Die großen Fünf 17.1.2 Hilfskonstrukt per Verbot 17.1.3 Die Nullerregel und ihr Einsatz 17.1.4 Ausnahmen von der Nullerregel 17.1.5 Nullerregel, Dreierregel, Fünferregel, Viereinhalberregel

17.2 RAII – Resource Acquisition Is Initialization

17.2.1 Ein Beispiel mit C 17.2.2 Besitzende Raw-Pointer 17.2.3 Von C nach C++ 17.2.4 Es muss nicht immer eine Exception sein 17.2.5 Mehrere Konstruktoren 17.2.6 Mehrphasige Initialisierung 17.2.7 Definieren, wo es gebraucht wird 17.2.8 Nothrow-new

18 Spezielles für Klassen

18.1 Dürfen alles sehen – »friend«-Klassen 18.2 Non-public-Vererbung

18.2.1 Auswirkungen auf die Außenwelt 18.2.2 Nicht öffentliche Vererbung in der Praxis

18.3 Signaturklassen als Interfaces 18.4 Multiple Vererbung

18.4.1 Multiple Vererbung in der Praxis 18.4.2 Achtung bei Typumwandlungen von Zeigern 18.4.3 Das Beobachter-Muster als praktisches Beispiel

18.5 Rautenförmige multiple Vererbung – »virtual« für Klassenhierarchien 18.6 Literale Datentypen – »constexpr« für Konstruktoren

19 Guter Code, 5. Dan: Klassisches objektorientiertes Design

19.1 Objekte in C++ 19.2 Objektorientiert designen

19.2.1 SOLID 19.2.2 Seien Sie nicht STUPID

Teil III Fortgeschrittene Themen 20 Zeiger

20.1 Adressen 20.2 Zeiger 20.3 Gefahren von Aliasing 20.4 Heapspeicher und Stapelspeicher

20.4.1 Der Stapel 20.4.2 Der Heap

20.5 Smarte Pointer

20.5.1 »unique_ptr« 20.5.2 »shared_ptr«

20.6 Rohe Zeiger 20.7 C-Arrays

20.7.1 Rechnen mit Zeigern 20.7.2 Verfall von C-Arrays 20.7.3 Dynamische C-Arrays 20.7.4 Zeichenkettenliterale

20.8 Iteratoren 20.9 Zeiger als Iteratoren 20.10 Zeiger im Container 20.11 Die Ausnahme: wann das Wegräumen nicht nötig ist

21 Makros

21.1 Der Präprozessor 21.2 Vorsicht vor fehlenden Klammern 21.3 Featuremakros 21.4 Information über den Quelltext 21.5 Warnung vor Mehrfachausführung 21.6 Typvariabilität von Makros 21.7 Zusammenfassung

22 Schnittstelle zu C

22.1 Mit Bibliotheken arbeiten 22.2 C-Header 22.3 C-Ressourcen 22.4 »void«-Pointer 22.5 Daten lesen 22.6 Das Hauptprogramm 22.7 Zusammenfassung

23 Templates

23.1 Funktionstemplates

23.1.1 Überladung 23.1.2 Ein Typ als Parameter 23.1.3 Funktionskörper eines Funktionstemplates 23.1.4 Werte als Templateparameter 23.1.5 Viele Funktionen 23.1.6 Parameter mit Extras 23.1.7 Methodentemplates sind auch nur Funktionstemplates

23.2 Funktionstemplates in der Standardbibliothek

23.2.1 Ranges statt Container als Templateparameter 23.2.2 Beispiel: Informationen über Zahlen

23.3 Eine Klasse als Funktion

23.3.1 Werte für einen »function«-Parameter 23.3.2 C-Funktionspointer 23.3.3 Die etwas andere Funktion 23.3.4 Praktische Funktoren 23.3.5 Algorithmen mit Funktoren 23.3.6 Anonyme Funktionen alias Lambda-Ausdrücke 23.3.7 Templatefunktionen ohne »template«, aber mit »auto«

23.4 C++ Concepts

23.4.1 Wie Sie Concepts lesen 23.4.2 Wie Sie Concepts anwenden 23.4.3 Wie Sie Concepts schreiben 23.4.4 Semantische Einschränkungen 23.4.5 Zusammenfassung

23.5 Templateklassen

23.5.1 Klassentemplates implementieren 23.5.2 Methoden von Klassentemplates implementieren 23.5.3 Objekte aus Klassentemplates erzeugen 23.5.4 Klassentemplates mit mehreren formalen Datentypen 23.5.5 Klassentemplates mit Non-Type-Parameter 23.5.6 Klassentemplates mit Default 23.5.7 Klassentemplates spezialisieren

23.6 Templates mit variabler Argumentanzahl 23.7 Eigene Literale

23.7.1 Was sind Literale? 23.7.2 Namensregeln 23.7.3 Phasenweise 23.7.4 Überladungsvarianten 23.7.5 Benutzerdefiniertes Literal mittels Template 23.7.6 Roh oder gekocht 23.7.7 Automatisch zusammengefügt 23.7.8 Unicodeliterale

Teil IV Die Standardbibliothek 24 Container

24.1 Grundlagen

24.1.1 Wiederkehrend 24.1.2 Abstrakt 24.1.3 Operationen 24.1.4 Komplexität 24.1.5 Container und ihre Iteratoren 24.1.6 Ranges vereinfachen Iteratoren 24.1.7 Ranges, Views, Concepts, Adapter, Generatoren und Algorithmen 24.1.8 Algorithmen

24.2 Iteratoren-Grundlagen

24.2.1 Iteratoren aus Containern 24.2.2 Mehr Funktionalität mit Iteratoren

24.3 Allokatoren: Speicherfragen 24.4 Containergemeinsamkeiten 24.5 Ein Überblick über die Standardcontainerklassen

24.5.1 Typaliase der Container

24.6 Die sequenziellen Containerklassen

24.6.1 Gemeinsamkeiten und Unterschiede 24.6.2 Methoden von Sequenzcontainern 24.6.3 »vector« 24.6.4 »array« 24.6.5 »deque« 24.6.6 »list« 24.6.7 »forward_list«

24.7 Assoziativ und geordnet

24.7.1 Gemeinsamkeiten und Unterschiede 24.7.2 Methoden der geordneten assoziativen Container 24.7.3 »set« 24.7.4 »map« 24.7.5 »multiset« 24.7.6 »multimap«

24.8 Nur assoziativ und nicht garantiert

24.8.1 Gemeinsamkeiten und Unterschiede 24.8.2 Methoden der ungeordneten assoziativen Container 24.8.3 »unordered_set« 24.8.4 »unordered_map« 24.8.5 »unordered_multiset« 24.8.6 »unordered_multimap«

24.9 Containeradapter 24.10 Sonderfälle: »string«, »basic_string« und »vector<char>« 24.11 Sonderfälle: »vector<bool>«, »array<bool,n>« und »bitset<n>«

24.11.1 Dynamisch und kompakt: »vector<bool>« 24.11.2 Statisch: »array<bool,n>« und »bitset<n>«

24.12 Sonderfall: Value-Array mit »valarray<>«

25 Containerunterstützung

25.1 Algorithmen 25.2 Iteratoren und Ranges 25.3 Iteratoradapter 25.4 Algorithmen der Standardbibliothek 25.5 Parallele Ausführung 25.6 Liste der Algorithmusfunktionen und Range-Adapter 25.7 Elemente verknüpfende Algorithmen aus »<numeric>« und »<ranges>« 25.8 Kopie statt Zuweisung – Werte in uninitialisierten Speicherbereichen 25.9 Eigene Algorithmen 25.10 Eigene Views und Range-Adapter schreiben

26 Guter Code, 6. Dan: Für jede Aufgabe der richtige Container

26.1 Alle Container nach Aspekten sortiert

26.1.1 Wann ist ein »vector« nicht die beste Wahl? 26.1.2 Immer sortiert: »set«, »map«, »multiset« und »multimap« 26.1.3 Im Speicher hintereinander: »vector«, »array« 26.1.4 Einfügung billig: »list« 26.1.5 Wenig Speicheroverhead: »vector«, »array« 26.1.6 Größe dynamisch: alle außer »array«

26.2 Rezepte für Container

26.2.1 Zwei Phasen? »vector« als guter »set«-Ersatz 26.2.2 Den Inhalt eines Containers auf einem Stream ausgeben 26.2.3 So statisch ist »array« gar nicht

26.3 Algorithmen je nach Container unterschiedlich implementieren

27 Streams, Dateien und Formatierung

27.1 Ein- und Ausgabekonzept mit Streams 27.2 Globale, vordefinierte Standardstreams 27.3 Methoden für die Aus- und Eingabe von Streams

27.3.1 Methoden für die unformatierte Ausgabe 27.3.2 Methoden für die (unformatierte) Eingabe

27.4 Fehlerbehandlung und Zustand von Streams

27.4.1 Methoden für die Behandlung von Fehlern bei Streams

27.5 Streams manipulieren und formatieren

27.5.1 Manipulatoren 27.5.2 Eigene Manipulatoren ohne Argumente erstellen 27.5.3 Eigene Manipulatoren mit Argumenten erstellen 27.5.4 Format-Flags direkt ändern

27.6 Streams für die Dateiein- und Dateiausgabe

27.6.1 Die Streams »ifstream«, »ofstream« und »fstream« 27.6.2 Verbindung zu einer Datei herstellen 27.6.3 Lesen und Schreiben 27.6.4 Wahlfreier Zugriff 27.6.5 Synchronisierte Streams für Threads

27.7 Streams für Strings 27.8 Streampuffer 27.9 »filesystem« 27.10 Formatieren

27.10.1 Einfache Formatierung 27.10.2 Eigene Typen formatieren

28 Standardbibliothek – Extras

28.1 »pair« und »tuple«

28.1.1 Mehrere Werte zurückgeben

28.2 Reguläre Ausdrücke

28.2.1 Matchen und Suchen 28.2.2 Ergebnis und Teile davon 28.2.3 Gefundenes Ersetzen 28.2.4 Reich an Varianten 28.2.5 Iteratoren 28.2.6 Matches 28.2.7 Optionen 28.2.8 Geschwindigkeit 28.2.9 Standardsyntax leicht gekürzt 28.2.10 Anmerkungen zu regulären Ausdrücken in C++

28.3 Zufall

28.3.1 Einen Würfel werfen 28.3.2 Echter Zufall 28.3.3 Andere Generatoren 28.3.4 Verteilungen

28.4 Mathematisches

28.4.1 Brüche und Zeiten – »<ratio>« und »<chrono>« 28.4.2 Vordefinierte Suffixe für benutzerdefinierte Literale

28.5 Systemfehlerbehandlung mit »system_error«

28.5.1 »error_code« und »error_condition« 28.5.2 Fehlerkategorien 28.5.3 Eigene Fehlercodes 28.5.4 »system_error«-Exception

28.6 Laufzeittypinformationen – »<typeinfo>« und »<typeindex>« 28.7 Hilfsklassen rund um Funktoren – »<functional>«

28.7.1 Funktionsobjekte 28.7.2 Funktionsgeneratoren

28.8 »optional« für einen oder keinen Wert 28.9 »variant« für einen von mehreren Typen 28.10 »any« hält jeden Typ 28.11 Spezielle mathematische Funktionen 28.12 Schnelle Umwandlung mit »<charconv>«

29 Threads – Programmieren mit Mehrläufigkeit

29.1 C++-Threading-Grundlagen

29.1.1 Einer Threadfunktion Parameter übergeben 29.1.2 Einen Thread verschieben 29.1.3 Wie viele Threads starten? 29.1.4 Welcher Thread bin ich?

29.2 Gemeinsame Daten

29.2.1 Data Races 29.2.2 Riegel 29.2.3 Barrieren 29.2.4 Mutexe 29.2.5 Interface-Design für Multithreading 29.2.6 Sperren können zum Patt führen 29.2.7 Flexibleres Sperren mit »unique_lock«

29.3 Andere Möglichkeiten zur Synchronisation

29.3.1 Nur einmal aufrufen mit »once_flag« und »call_once« 29.3.2 Sperren zählen mit »recursive_mutex«

29.4 Im eigenen Speicher mit »thread_local« 29.5 Mit »condition_variable« auf Ereignisse warten 29.6 Einmal warten mit »future«

29.6.1 Ausnahmebehandlung bei »future« 29.6.2 »promise«

29.7 Atomics 29.8 Koroutinen

29.8.1 Koroutinen im Compiler 29.8.2 Generator 29.8.3 Koroutinen mit »promise_type«

29.9 Zusammenfassung

A Guter Code, 7. Dan: Richtlinien

A.1 Guideline Support Library A.2 C++ Core Guidelines

A.2.1 Motivation A.2.2 Typsicherheit A.2.3 Nutzen Sie RAII A.2.4 Klassenhierarchien A.2.5 Generische Programmierung A.2.6 Lassen Sie sich nicht von Anachronismen verwirren

B Cheat Sheet Stichwortverzeichnis Rechtliche Hinweise Über den Autor

← Prev
Back
Next →

← Prev
Back
Next →