Der C++-Programmierer

Inhaltsverzeichnis

Vorwort

Teil I: Einführung in C++

1 Es geht los!

1.1 Historisches

1.2 Objektorientierte Programmierung

1.3 Compiler

1.4 Das erste Programm

1.4.1 Namenskonventionen

1.5 Integrierte Entwicklungsumgebung

1.6 Einfache Datentypen und Operatoren

1.6.1 Ausdruck

1.6.2 Ganze Zahlen

1.6.3 Reelle Zahlen

1.6.4 Konstante

1.6.5 Zeichen

1.6.6 Logischer Datentyp bool

1.6.7 Referenzen

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.9 Benutzerdefinierte und zusammengesetzte Datentypen

1.9.1 Aufzählungstypen

1.9.2 Strukturen

1.9.3 Der C++-Standardtyp vector

1.9.4 Zeichenketten: Der C++-Standardtyp string

1.9.5 Container und Schleifen

1.9.6 Typermittlung mit auto

1.9.7 Unions und Bitfelder

1.10 Einfache Ein- und Ausgabe

1.10.1 Standardein- und -ausgabe

1.10.2 Ein- und Ausgabe mit Dateien

2 Programmstrukturierung

2.1 Funktionen

2.1.1 Aufbau und Prototypen

2.1.2 Gültigkeitsbereiche und Sichtbarkeit in Funktionen

2.1.3 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 Alternative Funktions-Syntax

2.3 Modulare Programmgestaltung

2.3.1 Steuerung der Übersetzung nur mit #include

2.3.2 Einbinden vorübersetzter Programmteile

2.3.3 Dateiübergreifende Gültigkeit und Sichtbarkeit

2.3.4 Übersetzungseinheit, Deklaration, Definition

2.3.5 Präprozessordirektiven und Makros

2.4 Funktions-Templates

2.4.1 Spezialisierung von Templates

2.4.2 Einbinden von Templates

2.5 inline-Funktionen

2.6 constexpr-Funktionen

2.7 Namensräume

2.8 C++-Header

2.8.1 Einbinden von C-Funktionen

3 Objektorientierung 1

3.1 Abstrakte Datentypen

3.2 Klassen und Objekte

3.2.1 const-Objekte und Methoden

3.2.2 inline-Elementfunktionen

3.3 Initialisierung und Konstruktoren

3.3.1 Standardkonstruktor

3.3.2 Direkte Initialisierung der Attribute

3.3.3 Allgemeine Konstruktoren

3.3.4 Kopierkonstruktor

3.3.5 Typumwandlungskonstruktor

3.3.6 Konstruktor und mehr vorgeben oder verbieten

3.3.7 Einheitliche Initialisierung und Sequenzkonstruktor

3.3.8 Delegierender Konstruktor

3.3.9 constexpr-Konstruktor und -Methoden

3.4 Beispiel: Rationale Zahlen

3.4.1 Aufgabenstellung

3.4.2 Entwurf

3.4.3 Implementation

3.5 Destruktoren

3.6 Wie kommt man zu Klassen und Objekten? Ein Beispiel

3.7 Gegenseitige Abhängigkeit von Klassen

4 Intermezzo: Zeiger

4.1 Zeiger und Adressen

4.2 C-Arrays

4.2.1 C-Array 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 mit begin() und end() durchlaufen

4.3 C-Zeichenketten

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 Parameter des main-Programms

4.5.3 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 Array als Funktionsparameter

4.7.3 Dynamisch erzeugte mehrdimensionale Arrays

4.7.4 Klasse für dynamisches zweidimensionales Array

4.8 Binäre Ein-/Ausgabe

4.9 Zeiger auf Funktionen

4.10 Standard-Typumwandlungen für Zeiger

4.11 Zeiger auf Elementfunktionen und -daten

4.11.1 Zeiger auf Elementfunktionen

4.11.2 Zeiger auf Elementdaten

4.12 Komplexe Deklarationen lesen

4.12.1 Lesbarkeit mit typedef und using verbessern

5 Objektorientierung 2

5.1 Eine String-Klasse

5.1.1 friend-Funktionen

5.2 Klassenspezifische Daten und Funktionen

5.2.1 Klassenspezifische Konstante

5.3 Klassen-Templates

5.3.1 Ein Stack-Template

5.3.2 Stack mit statisch festgelegter Größe

5.4 Template-Metaprogrammierung

5.5 Variadic Templates: Templates mit variabler Parameterzahl

5.5.1 Klassen-Templates mit variabler Stelligkeit

5.6 Typbestimmung mit decltype

5.6.1 declval

6 Vererbung

6.1 Vererbung und Initialisierung

6.2 Zugriffsschutz

6.3 Typbeziehung zwischen Ober- und Unterklasse

6.4 Code-Wiederverwendung

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 Private virtuelle Funktionen

6.6 Probleme der Modellierung mit Vererbung

6.7 Mehrfachvererbung

6.7.1 Namenskonflikte

6.7.2 Virtuelle Basisklassen

6.8 Standard-Typumwandlungsoperatoren

6.9 Typinformationen zur Laufzeit

6.10 Using-Deklaration für protected-Funktionen

6.11 Private- und Protected-Vererbung

7 Fehlerbehandlung

7.1 Ausnahmebehandlung

7.1.1 Exception-Spezifikation in Deklarationen

7.1.2 Exception-Hierarchie in C++

7.1.3 Besondere Fehlerbehandlungsfunktionen

7.1.4 Erkennen logischer Fehler

7.1.5 Arithmetische Fehler / Division durch 0

7.2 Speicherbeschaffung mit new

7.3 Exception-Sicherheit

8 Überladen von Operatoren

8.1 Rationale Zahlen — noch einmal

8.1.1 Arithmetische Operatoren

8.1.2 Ausgabeoperator <<

8.2 Eine Klasse für Vektoren

8.2.1 Index-Operator [ ]

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 new und delete überladen

8.7.1 Speichermanagement mit malloc und free

8.7.2 Unterscheidung zwischen Heap- und Stack-Objekten

8.7.3 Fehlende delete-Anweisung entdecken

8.7.4 Eigene Speicherverwaltung für einen bestimmten Typ

8.7.5 Empfehlungen im Umgang mit new und delete

8.8 Operatoren für Literale

8.8.1 Stringliterale

8.8.2 Benutzerdefinierte Literale

8.9 Mehrdimensionale Matrizen

8.9.1 Zweidimensionale Matrix als Vektor von Vektoren

8.9.2 Dreidimensionale Matrix

8.10 Zuweisung bei Vererbung

9 Dateien und Ströme

9.1 Ausgabe

9.1.1 Formatierung der Ausgabe

9.2 Eingabe

9.3 Manipulatoren

9.3.1 Eigene Manipulatoren

9.4 Fehlerbehandlung

9.5 Typumwandlung von Dateiobjekten nach bool

9.6 Arbeit mit Dateien

9.6.1 Positionierung in Dateien

9.6.2 Lesen und Schreiben in derselben Datei

9.7 Umleitung auf Strings

9.8 Tabelle formatiert ausgeben

9.9 Formatierte Daten lesen

9.9.1 Eingabe benutzerdefinierter Typen

9.10 Blockweise lesen oder schreiben

9.11 Ergänzungen

10 Einführung in die Standard Template Library (STL)

10.1 Container, Iteratoren, Algorithmen

10.2 Iteratoren im Detail

10.3 Beispiel verkettete Liste

Teil II: Fortgeschrittene Themen

11 Lambda-Funktionen

11.1 Eigenschaften

11.1.1 Äquivalenz zum Funktionszeiger

11.1.2 Lambda-Funktion und Klasse

11.2 Generische Lambda-Funktionen

11.3 Parametererfassung mit []

12 Performance, Wert- und Referenzsemantik

12.1 Performanceproblem Wertsemantik

12.1.1 Auslassen der Kopie

12.1.2 Temporäre Objekte bei der Zuweisung

12.2 Referenzsemantik für R-Werte

12.3 Optimierung durch Referenzsemantik für R-Werte

12.3.1 Bewegender Konstruktor

12.3.2 Bewegender Zuweisungsoperator

12.4 Die move()-Funktion

12.4.1 Regel zur Template-Auswertung von &&-Parametern

12.5 Ein effizienter binärer Plusoperator

12.5.1 Return Value Optimization (RVO)

12.5.2 Kopien temporärer Objekte eliminieren

12.5.3 Verbesserung durch verzögerte Auswertung

13 Reguläre Ausdrücke

13.1 Elemente regulärer Ausdrücke

13.1.1 Greedy oder lazy?

13.2 Interaktive Auswertung

13.3 Auszug des regex-APIs

13.4 Anwendungen

14 Threads

14.1 Zeit und Dauer

14.2 Threads

14.3 Die Klasse thread

14.3.1 Thread-Group

14.4 Synchronisation

14.5 Thread-Steuerung: pausieren, fortsetzen, beenden

14.5.1 Data Race

14.6 Interrupt

14.7 Warten auf Ereignisse

14.8 Reader/Writer-Problem

14.8.1 Wenn Threads verhungern

14.8.2 Reader/Writer-Varianten

14.9 Thread-Sicherheit

15 Grafische Benutzungsschnittstellen

15.1 Ereignisgesteuerte Programmierung

15.2 GUI-Programmierung mit Qt

15.2.1 Installation und Einsatz

15.2.2 Meta-Objektsystem

15.2.3 Der Programmablauf

15.2.4 Ereignis abfragen

15.3 Signale, Slots und Widgets

15.4 Dialog

15.5 Qt oder Boost?

15.5.1 Threads

15.5.2 Verzeichnisbaum durchwandern

16 Internet-Anbindung

16.1 Protokolle

16.2 Adressen

16.3 Socket

16.3.1 Bidirektionale Kommunikation

16.3.2 UDP-Sockets

16.3.3 Atomuhr mit UDP abfragen

16.4 HTTP

16.4.1 Verbindung mit GET

16.4.2 Verbindung mit POST

16.5 Mini-Webserver

17 Datenbankanbindung

17.1 C++-Interface

17.2 Anwendungsbeispiel

Teil III: Praktische Methoden und Werkzeuge der Softwareentwicklung

18 Effiziente Programmerzeugung mit make

18.1 Quellen

18.2 Wirkungsweise

18.3 Variablen und Muster

18.4 Universelles Makefile für einfache Projekte

18.5 Automatische Ermittlung von Abhängigkeiten

18.5.1 Getrennte Verzeichnisse: src, obj, bin

18.6 Makefile für Verzeichnisbäume

18.6.1 Rekursive Make-Aufrufe

18.6.2 Ein Makefile für alles

18.7 Automatische Erzeugung von Makefiles

18.7.1 Makefile für rekursive Aufrufe erzeugen

18.8 Erzeugen von Bibliotheken

18.8.1 Statische Bibliotheksmodule

18.8.2 Dynamische Bibliotheksmodule

18.9 GNU Autotools

18.10 CMake

18.11 Code Bloat bei der Instanziierung von Templates vermeiden

18.11.1 extern-Template

18.11.2 Aufspaltung in Schnittstelle und Implementation

19 Unit-Test

19.1 Werkzeuge

19.2 Test Driven Development

19.3 Boost Unit Test Framework

19.3.1 Beispiel: Testgetriebene Entwicklung einer Operatorfunktion

19.3.2 Fixture

19.3.3 Testprotokoll und Log-Level

19.3.4 Prüf-Makros

19.3.5 Kommandozeilen-Optionen

20 Werkzeuge zur Verwaltung von Projekten

20.1 Dokumentation und Strukturanalyse mit doxygen

20.1.1 Strukturanalyse

20.2 Versionskontrolle

20.2.1 Subversion

20.2.2 Git

20.3 Projektverwaltung

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 The Big Three – oder Big Five?

21.2.16 One Definition Rule

21.2.17 Defensiv Objekte löschen

21.2.18 Speicherbeschaffung und -freigabe kapseln

21.2.19 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 So vermeiden Sie new[] und delete[]!

21.3.4 shared_ptr für Arrays korrekt verwenden

21.3.5 unique_ptr für Arrays korrekt verwenden

21.3.6 Exception-sichere Funktion

21.3.7 Exception-sicherer Konstruktor

21.3.8 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 Code-Formatierer

23.2.4 Lines of Code (LOC) ermitteln

23.2.5 Zeilen, Wörter und Zeichen einer Datei zählen

23.2.6 CSV-Datei lesen

23.2.7 Kreuzreferenzliste

23.3 Operationen auf Folgen

23.3.1 Container anzeigen

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 Anzahl der Elemente, die einer Bedingung genügen

23.3.16 Gilt X für alle, keins oder wenigstens ein Element einer Folge?

23.3.17 Permutationen

23.3.18 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 Bestimmte benachbarte Elemente finden

23.5.5 Bestimmte aufeinanderfolgende Werte finden

23.5.6 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.7.1 pop_heap

23.7.2 push_heap

23.7.3 make_heap

23.7.4 sort_heap

23.7.5 is_heap

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 Schnelle zweidimensionale Matrix

23.10.1 Optimierung mathematischer Array-Operationen

23.11 Singleton

23.11.1 Implementierung mit einem Zeiger

23.11.2 Implementierung mit einer Referenz

23.11.3 Meyers' Singleton

23.12 Vermischtes

23.12.1 Erkennung eines Datums

23.12.2 Erkennung einer IP4-Adresse

23.12.3 Erzeugen von Zufallszahlen

23.12.4 for_each — Auf jedem Element eine Funktion ausführen

23.12.5 Verschiedene Möglichkeiten, Container-Bereiche zu kopieren

23.12.6 Vertauschen von Elementen, Bereichen und Containern

23.12.7 Elemente transformieren

23.12.8 Ersetzen und Varianten

23.12.9 Elemente herausfiltern

23.12.10 Grenzwerte von Zahltypen

23.12.11 Minimum und Maximum

24 Datei- und Verzeichnisoperationen

24.1 Datei oder Verzeichnis löschen

24.2 Datei oder Verzeichnis umbenennen

24.3 Verzeichnis anlegen

24.4 Verzeichnis anzeigen

24.5 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 Relationale Operatoren

26.2 Unterstützung der Referenzsemantik für R-Werte

26.2.1 move()

26.2.2 forward()

26.3 Paare

26.4 Tupel

26.5 Indexfolgen

26.6 Funktionsobjekte

26.6.1 Arithmetische, vergleichende und logische Operationen

26.6.2 Funktionsobjekte zum Negieren logischer Prädikate

26.6.3 Binden von Argumentwerten

26.6.4 Funktionen in Objekte umwandeln

26.7 Templates für rationale Zahlen

26.8 Hüllklasse für Referenzen

26.9 Type Traits

26.9.1 Wie funktionieren Type Traits? — ein Beispiel

26.9.2 Abfrage von Eigenschaften

26.9.3 Abfrage numerischer Eigenschaften

26.9.4 Typbeziehungen

26.9.5 Typumwandlungen

26.9.6 Auswahl weiterer Transformationen

27 Container

27.1 Gemeinsame Eigenschaften

27.1.1 Initialisierungslisten

27.1.2 Konstruktion an Ort und Stelle

27.1.3 Reversible Container

27.2 Sequenzen

27.2.1 vector

27.2.2 vector

27.2.3 list

27.2.4 deque

27.2.5 stack

27.2.6 queue

27.2.7 priority_queue

27.2.8 array

27.3 Sortierte assoziative Container

27.3.1 map

27.3.2 multimap

27.3.3 set

27.3.4 multiset

27.4 Hash-Container

27.4.1 unordered_map

27.4.2 unordered_multimap

27.4.3 unordered_set

27.4.4 unordered_multiset

27.5 bitset

28 Iteratoren

28.1 Iterator-Kategorien

28.1.1 Anwendung von Traits

28.2 distance() und advance()

28.3 Bereichszugriff

28.3.1 Reverse-Iteratoren

28.4 Insert-Iteratoren

28.5 Stream-Iteratoren

29 Algorithmen

29.1 Algorithmen mit Prädikat

29.1.1 Algorithmen mit binärem Prädikat

29.2 Übersicht

30 Nationale Besonderheiten

30.1 Sprachumgebungen 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 time

30.4.6 messages

30.5 Konstruktion eigener Facetten

31 String

32 Speichermanagement

32.1 unique_ptr

32.1.1 make_unique

32.2 shared_ptr

32.2.1 make_shared

32.2.2 Typumwandlung in einen Oberklassentyp

32.3 weak_ptr

32.4 new mit Speicherortangabe

33 Numerische Arrays (valarray)

33.1 Konstruktoren

33.2 Elementfunktionen

33.3 Binäre Valarray-Operatoren

33.4 Mathematische Funktionen

33.5 slice und slice_array

33.6 gslice und gslice_array

33.7 mask_array

33.8 indirect_array

34 Ausgewählte C-Header

34.1

34.2

34.3

34.4

34.5

34.6

34.7

34.8

34.9

34.10

A Anhang

A.1 ASCII-Tabelle

A.2 C++-Schlüsselwörter

A.3 Compilerbefehle

A.4 Rangfolge der Operatoren

A.5 Lösungen zu den Übungsaufgaben

A.6 Installation der Software für Windows

A.6.1 Installation des Compilers und der Entwicklungsumgebung

A.6.2 Integrierte Entwicklungsumgebung einrichten

A.6.3 De-Installation

A.7 Installation der Software für Linux

A.7.1 Installation des Compilers

A.7.2 Installation von Boost

A.7.3 Installation und Einrichtung von Code::Blocks

A.7.4 Beispieldateien entpacken

Glossar

Literaturverzeichnis

Register