C++ programmieren: C++ lernen – professionell anwenden – Lösungen nutzen

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