C++ programmieren E-Book

Ulrich Breymann

• Herausgeber: Carl Hanser Verlag GmbH & Co. KG
• Kategorie: Wissenschaft und neue Technologien
• Sprache: Deutsch
• Veröffentlichungsjahr: 2023

Seitenzahl: 1326

Beschreibung

ALLES ÜBER C++ - UND NOCH VIEL MEHR//
- Topaktuell: entspricht dem neuen ISO-C++23-Standard
- Ein Praxisbuch für alle Ansprüche – mehr brauchen Einsteiger und Fortgeschrittene nicht
- Stellt Grundlagen und fortgeschrittene Themen der C++-Programmierung vor und zeigt sie an praktischen Beispielen
- Enthält über 150 praktische Lösungen für typische Aufgabenstellungen und 99 Übungsaufgaben – natürlich mit Musterlösungen
- Im Internet unter www.cppbuch.de: Entwicklungsumgebung, Compiler, weitere Open-Source-Software, alle Beispiele und Musterlösungen
- Ihr exklusiver Vorteil: E-Book inside beim Kauf des gedruckten Buches

C++ PROGRAMMIEREN//
Egal, ob Sie C++ lernen wollen oder Ihre Kenntnisse in der Softwareentwicklung mit C++ vertiefen – in diesem Buch finden Sie, was Sie brauchen. C++-Neulinge erhalten eine motivierende Einführung in die Sprache C++.
Die vielen Beispiele sind leicht nachzuvollziehen, Klassen und Objekte, Templates, STL und Exceptions sind bald keine Fremdwörter mehr für Sie. Fortgeschrittene finden in diesem Buch kurze Einführungen zu Themen wie Thread-Programmierung, Netzwerk-Programmierung, grafische Benutzungsoberflächen und Zugriff auf die KI ChatGPT per Programm.
Weil Softwareentwicklung nicht nur Schreiben von Programmcode ist, finden Sie hier auch diese Themen: guter Programmierstil, Testen von Programmen und automatisierte Übersetzung von Programmen. Das integrierte »C++-Rezeptbuch« mit mehr als 150 praktischen Lösungen, das detaillierte Inhaltsverzeichnis und ein sehr umfangreiches Register machen das Buch zum unverzichtbaren Nachschlagewerk für alle, die sich im Studium oder professionell mit der Softwareentwicklung in C++ beschäftigen.

AUS DEM INHALT//
- Datentypen und Kontrollstrukturen: strukturierte und selbstdefinierte Datentypen, Ein- und Ausgabe von Daten
- Programme strukturieren, einfache Funktionen schreiben, Templates kennenlernen
- Objektorientierung: Klassen und Objekte, Konzepte zum Klassenentwurf, generische Klassen
- Vererbung: Beziehung zwischen Ober- und Unterklassen, Überschreiben von Funktionen, Mehrfachvererbung
- Fehlerbehandlung, Überladen von Operatoren, sicheres Speichermanagement, Lambda-Funktionen, Template-Metaprogrammierung
- Optimierung der Performance mit R-Wert-Referenzen

Leseprobe

Ulrich Breymann

C++ programmieren

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

7., überarbeitete Auflage

Prof. Dr. Ulrich Breymann lehrte Informatik an der Fakultät Elektrotechnik und Informatik der Hochschule Bremen.Kontakt: [email protected]

Alle in diesem Werk enthaltenen Informationen, Verfahren und Darstellungen wurden nach bestem Wissen zusammengestellt und mit Sorgfalt getestet. Dennoch sind Fehler nicht ganz auszuschließen. Aus diesem Grund sind die im vorliegenden Werk enthaltenen Informationen mit keiner Verpflichtung oder Garantie irgendeiner Art verbunden. Autor und Verlag übernehmen infolgedessen keine juristische Verantwortung und werden keine daraus folgende oder sonstige Haftung übernehmen, die auf irgendeine Art aus der Benutzung dieser Informationen – oder Teilen davon – entsteht. Ebenso wenig übernehmen Autor und Verlag die Gewähr dafür, dass beschriebene Verfahren usw. frei von Schutzrechten Dritter sind. Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk berechtigt also auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürften.Die endgültige Entscheidung über die Eignung der Informationen für die vorgesehene Verwendung in einer bestimmten Anwendung liegt in der alleinigen Verantwortung des Nutzers.

Bibliografische Information der Deutschen Nationalbibliothek:Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.

Dieses Werk ist urheberrechtlich geschützt.Alle Rechte, auch die der Übersetzung, des Nachdruckes und der Vervielfältigung des Buches, oder Teilen daraus, vorbehalten. Kein Teil des Werkes darf ohne schriftliche Genehmigung des Verlages in irgendeiner Form (Fotokopie, Mikrofilm oder ein anderes Verfahren) – auch nicht für Zwecke der Unterrichtsgestaltung – mit Ausnahme der in den §§ 53, 54 URG genannten Sonderfälle –, reproduziert oder unter Verwendung elektronischer Systeme verarbeitet, vervielfältigt oder verbreitet werden.

© 2023 Carl Hanser Verlag München, www.hanser-fachbuch.deLektorat: Brigitte Bauer-SchiewekCopy editing: Petra Kienle, FürstenfeldbruckUmschlagdesign: Marc Müller-Bremer, www.rebranding.de, MünchenUmschlagrealisation: Max KostopoulosTitelmotiv: © stock.adobe.com/michels

Print-ISBN:        978-3-446-47689-9E-Book-ISBN:   978-3-446-47846-6E-Pub-ISBN:     978-3-446-47964-7

Inhalt

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.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<bool>

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 <cassert>

33.2 <cctype>

33.3 <cmath>

33.4 <cstddef>

33.5 <cstdlib>

33.6 <cstring>

33.7 <ctime>

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

Vorwort

Diese Auflage unterscheidet sich von der vorherigen durch eine gründliche Überarbeitung und die Umstellung auf den 2023 von der zuständigen ISO/IEC-Arbeitsgruppe verabschiedeten C++-Standard. Abschnitt A.7 bietet eine Übersicht der in diesem Buch berücksichtigten Änderungen. Das Buch ist konform zum C++23-Standard, ohne den Anspruch auf Vollständigkeit zu erheben – das Standarddokument [ISOC++] umfasst mehr als 2100 Seiten. Sie finden in diesem Buch eine verständliche und mit vielen Beispielen angereicherte Einführung in die Sprache, unabhängig vom Betriebssystem.

Für wen ist dieses Buch geschrieben?

Es ist für alle geschrieben, die einen kompakten und gleichzeitig in die Tiefe gehenden Einstieg in die Programmierung mit C++ suchen. Es ist für Interessierte ohne Programmiererfahrung gedacht und für andere, die diese Programmiersprache kennenlernen möchten. Beiden Gruppen dient das Buch als Lehrbuch und Nachschlagewerk.

Ein umfassendes Handbuch

Die ersten zehn Kapitel führen in die Sprache ein, die folgenden behandeln fortgeschrittene Themen. Die sofortige praktische Umsetzung des Gelernten anhand von leicht nachvollziehbaren Beispielen steht im Vordergrund. Klassen und Objekte, Templates und Exceptions sind Ihnen bald keine Fremdworte mehr. Es gibt 99 Übungsaufgaben – mit Musterlösungen im Anhang und zum Download. Durch das Studium dieser Kapitel werden aus Neulingen bald Fortgeschrittene – und mithilfe der weiteren Kapitel Experten.

C++ in praktischen Anwendungen

Sie finden kurze Einführungen in die Themen Programmierung paralleler Abläufe, Netzwerk-Programmierung einschließlich eines kleinen Webservers, Datenbankanbindung, grafische Benutzungsoberflächen und Zugriff auf die KIs ChatGPT und DALL·E 2. Durch den Einsatz der Boost-Library und des Qt-Frameworks wird größtmögliche Portabilität erreicht.

Softwareentwicklung ist nicht nur Programmierung

Sie lernen die Automatisierung der Programmerzeugung mit Make kennen. Das Programmdesign wird durch konkrete Umsetzungen von Design-Mustern nach C++ unterstützt. Das Kapitel über Unit-Tests zeigt, wie Programme getestet werden können. Das integrierte »C++-Rezeptbuch« mit mehr als 150 praktischen Lösungen, der Teil über die C++-Standardbibliothek, das umfangreiche Register und das detaillierte Inhaltsverzeichnis machen das Buch zu einem praktischen Nachschlagewerk für alle, die sich mit der Softwareentwicklung in C++ beschäftigen.

Moderne Programmiermethodik

Sie möchten Programme schreiben, die hohen Qualitätsansprüchen gerecht werden. Dazu gehört das Know-how, C++ richtig einzusetzen. Dass ein Programm läuft, reicht nicht. Es soll auch gut entworfen sein, möglichst wenige Fehler enthalten, selbst mit Fehlern in Daten umgehen können, verständlich geschrieben und schnell in der Ausführung sein. Deshalb liegt ein Schwerpunkt des Buchs auf guter Codierpraxis entsprechend den »C++ Core Guidelines«. Die Umsetzung wird an vielen Beispielen gezeigt.

Wie benutzen Sie dieses Buch am besten?

Es eignet sich zum Selbststudium oder als Begleitbuch zu einem Kurs oder einer Vorlesung. Man lernt am besten durch eigenes Tun! Dabei hilft es, die Beispiele herunterzuladen, sie zu studieren und zu modifizieren (http://www.cppbuch.de/). Auch wird empfohlen, die Übungsaufgaben zu lösen. Um sowohl Anfängern als auch Fortgeschrittenen gerecht zu werden, gibt es einfache, aber auch schwerere Aufgaben. Wenn Ihnen eine Lösung nicht gelingt – einfach bei den Lösungen im Anhang nachsehen bzw. im Verzeichnis cppbuch/loesungen der downloadbaren Beispiele. Und dann versuchen, die Lösungen nachzuvollziehen.

Wo finden Sie was?

Bei der Programmentwicklung wird häufig das Problem auftauchen, etwas nachschlagen zu müssen. Es gibt die folgenden Hilfen: Erklärungen zu Begriffen sind im Glossar aufgeführt. Es gibt ein umfangreiches Stichwortverzeichnis und ein detailliertes Inhaltsverzeichnis. Der Anhang enthält unter anderem verschiedene hilfreiche Tabellen und die Lösungen der Übungsaufgaben. Auf der Webseite http://www.cppbuch.de/ finden Sie die Software zu diesem Buch. Sie enthält alle Programmbeispiele und die Lösungen zu den Aufgaben. Sie finden dort auch weitere Hinweise, Errata und nützliche Internet-Links.

Zu guter Letzt

Allen Menschen, die dieses Buch durch Hinweise und Anregungen verbessern halfen, sei an dieser Stelle herzlich gedankt. Insbesondere Prof.Dr .Ulrich Eisenecker danke ich für seine hilfreichen Kommentare. Frau Irene Weilhart vom Hanser Verlag und dem Lektorat danke ich für die gute Zusammenarbeit.

Bremen, im Juni 2023

Ulrich Breymann

Teil I:Einführung in C++

1Es geht los!