Kirch / Prinz C++ Lernen und professionell anwenden

Für Studium, Ausbildung und Beruf
1. Auflage 2022
ISBN: 978-3-7475-0501-4
Verlag: mitp Verlags GmbH & Co.KG
Format: PDF
Kopierschutz: 1 - PDF Watermark

E-Book, Deutsch, 1086 Seiten

Reihe: mitp Professional

Alle wichtigen Grundlagen der C++-ProgrammierungFür alle Studiengänge geeignet, keine Vorkenntnisse notwendigMit Übungsaufgaben und leicht verständlichen Beispielen aus zahlreichen AnwendungsgebietenInklusive umfangreichem E-Book mit über 1000 Seiten zum kostenlosen DownloadSie möchten die Programmiersprache C++ erlernen und sind Einsteiger? Dann ist dieses Buch richtig für Sie! Es richtet sich besonders an alle, die C++ in Studium, Ausbildung oder Beruf lernen und keine Vorkenntnisse in der Programmierung mit C++ haben.Die Ausrichtung des Studiengangs spielt dabei keine Rolle. Alle Themen werden fachunabhängig erläutert. Die Übungen und praktischen Beispiele decken viele unterschiedliche Anwendungsbereiche ab, so dass Sie auf die verschiedensten Aufgaben optimal vorbereitet sind.Sie lernen die elementaren Sprachkonzepte von C++ und werden schrittweise bis zur Entwicklung professioneller C++-Programme geführt. In den Beispielen zeigen die Autoren die ganze Breite des Anwendungsspektrums auf. Dabei basiert die Sprachbeschreibung auf dem ISO-Standard, den alle gängigen Compiler unterstützen (Visual C++, GNU C++ etc.). Neue Sprachelemente sind mit C++20 gekennzeichnet.Für den professionellen Einsatz sind in den hinteren Kapiteln Themen wie Lambdas, Smart Pointer, Multithreading und Algorithmen der Standard-Template-Library beschrieben.Die Übungen zu jedem Kapitel helfen Ihnen, Ihr Wissen zu festigen und sich auf Prüfungen vorzubereiten.Zusätzlich zum Buch erhalten Sie kostenlos ein E-Book mit insgesamt über 1000 Seiten, das nicht nur die Inhalte des Buches enthält, sondern darüber hinaus über 500 Seiten mit den fortgeschrittenen Themen sowie Übungen mit Lösungen.Aus dem Inhalt:Datentypen, Kontrollstrukturen, Operatoren, Makros, FunktionenVektoren, Strings, Matrizen, Referenzen und ZeigerSpeicherreservierung zur Laufzeit, dynamische Arrays und Move-SemantikKlassen, Vererbung und PolymorphieException-Handling Dateiverarbeitung und portabler Zugriff auf das DateisystemTemplates und ContainerSmart PointerMultithreadingAlgorithmen der StandardbibliothekNumerische BibliothekUmfassendes Glossar

Zielgruppe

Studenten und Einsteiger in C++

Autoren/Hrsg.

Kirch, Ulla

Prinz, Peter

Inhaltsverzeichnis

1;Cover;1
2;Titel;3
3;Inhaltsverzeichnis;7
4;Einleitung;21
5;Kapitel 1: Grundlagen;23
5.1;Entwicklung und Eigenschaften von C++;24
5.2;Objektorientierte Programmierung;26
5.3;Erstellen eines C++-Programms;28
5.4;Ein erstes C++-Programm;30
5.5;Struktur einfacher C++-Programme;32
6;Kapitel 2: Elementare Datentypen, Konstanten und Variablen;35
6.1;Elementare Datentypen;36
6.2;Konstanten;42
6.3;Escape-Sequenzen;46
6.4;Namen;48
6.5;Variablen;50
6.6;Die Schlüsselworte const und volatile;52
7;Kapitel 3: Verwenden von Funktionen und Klassen;55
7.1;Deklaration von Funktionen;56
7.2;Aufruf von Funktionen;58
7.3;Der Typ void für Funktionen;60
7.4;Header-Dateien;62
7.5;Standard-Header-Dateien;64
7.6;Verwenden von Standardklassen;66
8;Kapitel 4: Ein- und Ausgaben mit Streams;69
8.1;Streams;70
8.2;Formatierung und Manipulatoren;72
8.3;Formatierte Ausgabe von Ganzzahlen;74
8.4;Formatierte Ausgabe von Gleitpunktzahlen;76
8.5;Ausgabe in Felder;78
8.6;Ausgabe von Zeichen, Strings und booleschen Werten;80
8.7;Formatierte Eingabe;82
8.8;Formatierte Eingabe von Zahlen;84
8.9;Unformatierte Ein-/Ausgabe;86
9;Kapitel 5: Operatoren für elementare Datentypen;89
9.1;Binäre arithmetische Operatoren;90
9.2;Unäre arithmetische Operatoren;92
9.3;Zuweisungen;94
9.4;Vergleichsoperatoren;96
9.5;Logische Operatoren;98
9.6;Implizite Typumwandlungen;100
9.7;Implizite Typumwandlungen bei Zuweisungen;102
9.8;Weitere Typumwandlungen;104
10;Kapitel 6: Kontrollstrukturen;107
10.1;Die while-Schleife;108
10.2;Die for-Schleife;110
10.3;Die do-while-Schleife;114
10.4;Verzweigungen mit if-else;116
10.5;else-if-Ketten;118
10.6;Bedingte Bewertung;120
10.7;Auswahl mit switch;122
10.8;Sprünge mit break, continue und goto;124
11;Kapitel 7: Symbolische Konstanten und Makros;127
11.1;Makros;128
11.2;Makros mit Parametern;130
11.3;Bedingte Kompilierung;132
11.4;Standardmakros zur Behandlung von Zeichen;134
11.5;Umlenken von Standardeingabe und -ausgabe;136
12;Kapitel 8: Die Standardklasse string;139
12.1;Definition und Zuweisung von Strings;140
12.2;Verketten von Strings;142
12.3;Strings vergleichen;144
12.4;Einfügen und Löschen in Strings;146
12.5;Suchen und Ersetzen in Strings;148
12.6;Zugriff auf Zeichen in Strings;150
13;Kapitel 9: Funktionen;153
13.1;Bedeutung von Funktionen in C++;154
13.2;Erstellen eigener Funktionen;156
13.3;Return-Wert von Funktionen;158
13.4;Übergabe von Argumenten;160
13.5;inline-Funktionen;162
13.6;Default-Argumente;164
13.7;Überladen von Funktionen;166
13.8;Rekursive Funktionen;168
13.9;Platzhalter auto für Return-Typen;170
14;Kapitel 10: Speicherklassen und Namensbereiche;173
14.1;Speicherklasse von Objekten;174
14.2;Der Speicherklassen-Spezifizierer extern;176
14.3;Der Speicherklassen-Spezifizierer static;178
14.4;Speicherklassen-Spezifizierer von Funktionen;180
14.5;Namensbereiche;182
14.6;Das Schlüsselwort using;184
15;Kapitel 11: Referenzen und Zeiger;187
15.1;Definition von Referenzen;188
15.2;Referenzen als Parameter;190
15.3;Referenzen als Return-Wert;192
15.4;Ausdrücke mit Referenztyp;194
15.5;Definition von Zeigern;196
15.6;Der Verweisoperator;198
15.7;Zeiger als Parameter;200
16;Kapitel 12: Definition von Klassen;203
16.1;Klassen-Konzept;204
16.2;Definition von Klassen;206
16.3;Definition von Methoden;208
16.4;Definition von Objekten;210
16.5;Verwendung von Objekten;212
16.6;Zeiger auf Objekte;214
16.7;Structs;216
16.8;Structured Bindings;218
16.9;Unions;220
17;Kapitel 13: Methoden;223
17.1;Konstruktoren;224
17.2;Aufruf von Konstruktoren;226
17.3;Mehr Initialisierungsmöglichkeiten;228
17.4;Destruktoren;230
17.5;Inline-Methoden;232
17.6;Zugriffsmethoden;234
17.7;const-Objekte und -Methoden;236
17.8;Standardmethoden;238
17.9;Standardmethoden kontrollieren;240
17.10;Der this-Zeiger;242
17.11;Übergabe von Objekten;244
17.12;Objekte als Return-Wert;246
18;Kapitel 14: Teilobjekte und statische Elemente;249
18.1;Klassen mit Teilobjekten;250
18.2;Elementinitialisierer;252
18.3;Konstante Teilobjekte;254
18.4;Statische Datenelemente;256
18.5;Zugriff auf statische Datenelemente;258
18.6;Aufzählungen;260
19;Kapitel 15: Vektoren;263
19.1;Vektoren definieren;264
19.2;Initialisierung von Vektoren;266
19.3;C-Strings;268
19.4;Die Standardklasse string_view;270
19.5;Klassen-Arrays;272
19.6;Mehrdimensionale Vektoren;274
19.7;Vektoren als Datenelemente;276
20;Kapitel 16: Zeiger und Vektoren;279
20.1;Vektoren und Zeiger (1);280
20.2;Vektoren und Zeiger (2);282
20.3;Zeigerarithmetik;284
20.4;Vektoren als Argumente von Funktionen;286
20.5;Zeigerversion von Funktionen;288
20.6;Read-only-Zeiger;290
20.7;Zeiger als Return-Wert;292
20.8;Zeigervektoren;294
20.9;Argumente aus der Kommandozeile;296
21;Kapitel 17: Grundlagen der Dateiverarbeitung;299
21.1;Dateien;300
21.2;File-Stream-Klassen;302
21.3;File-Streams anlegen;304
21.4;Eröffnungsmodus;306
21.5;Schließen von Dateien;308
21.6;Blockweises Schreiben und Lesen;310
21.7;Persistenz von Objekten;312
22;Kapitel 18: Operatoren überladen;315
22.1;Allgemeines;316
22.2;Operatorfunktionen (1);318
22.3;Operatorfunktionen (2);320
22.4;Überladene Operatoren verwenden;322
22.5;Globale Operatorfunktionen;324
22.6;friend-Funktionen;326
22.7;friend-Klassen;328
22.8;Index-Operator überladen;330
22.9;Shift-Operatoren für die Ein-/Ausgabe überladen;332
23;Kapitel 19: Typumwandlungen für Klassen;335
23.1;Konvertierungskonstruktoren;336
23.2;Konvertierungsfunktionen;338
23.3;Mehrdeutigkeit bei Typumwandlungen;340
24;Kapitel 20: Speicherreservierung zur Laufzeit;343
24.1;Der Operator new;344
24.2;Der Operator delete;346
24.3;Dynamischer Speicher für Klassen;348
24.4;Dynamischer Speicher für Vektoren;350
24.5;Anwendung: Einfach verkettete Listen;352
24.6;Darstellung einer einfach verketteten Liste;354
25;Kapitel 21: Dynamische Elemente;357
25.1;Datenfelder variabler Länge;358
25.2;Eine Klasse mit dynamischem Element;360
25.3;Auf- und Abbau eines Objekts;362
25.4;Die Implementierung der Methoden;364
25.5;Kopierkonstruktor;366
25.6;Zuweisung;368
25.7;Verschieben von R-Werten;370
25.8;Move-Konstruktor;372
25.9;Move-Zuweisung;374
26;Kapitel 22: Vererbung;377
26.1;Konzept der Vererbung;378
26.2;Abgeleitete Klassen;380
26.3;Elemente abgeleiteter Klassen;382
26.4;Elementzugriff;384
26.5;Redefinition von Elementen;386
26.6;Auf- und Abbau abgeleiteter Klassen;388
26.7;Objekte abgeleiteter Klassen;390
26.8;protected-Deklarationen;392
26.9;Weitere Zugriffseinschränkungen;394
27;Kapitel 23: Typumwandlung in Klassenhierarchien;397
27.1;Konvertierung in Basisklassen;398
27.2;Typumwandlung bei Zuweisungen;400
27.3;Konvertierung von Referenzen und Zeigern;402
27.4;Explizite Typumwandlungen;404
28;Kapitel 24: Polymorphe Klassen;407
28.1;Polymorphie;408
28.2;Virtuelle Methoden;410
28.3;Abbau dynamischer Objekte;412
28.4;Virtuelle Methodentabelle;414
28.5;Dynamische Casts;416
29;Kapitel 25: Abstrakte Klassen;419
29.1;Rein virtuelle Methoden;420
29.2;Abstrakte und konkrete Klassen;422
29.3;Zeiger und Referenzen auf abstrakte Klassen;424
29.4;Virtuelle Zuweisungen;426
29.5;Anwendung: Inhomogene Listen;428
29.6;Implementierung einer inhomogenen Liste;430
30;Kapitel 26: Ausnahmebehandlung;433
30.1;Traditionelle Fehlerbehandlung;434
30.2;Exception-Handling;436
30.3;Exception-Handler;438
30.4;Auslösen und Auffangen von Exceptions;440
30.5;Schachteln von Ausnahmebehandlungen;442
30.6;Definition eigener Fehlerklassen;444
30.7;Standardfehlerklassen;446
31;Kapitel 27: Mehr über Zeiger;449
31.1;Zeiger auf Zeiger;450
31.2;Variable Anzahl von Argumenten;452
31.3;Zeiger auf Funktionen;456
31.4;Komplexe Deklarationen;458
31.5;Definition von Typnamen;460
31.6;Matrizen als Argumente von Funktionen;462
32;Kapitel 28: Templates;465
32.1;Funktions- und Klassen-Templates;466
32.2;Definition von Templates;468
32.3;Instantiierung von Templates;470
32.4;Template-Parameter;472
32.5;Template-Argumente;474
32.6;Spezialisierungen;476
32.7;Default-Argumente von Templates;478
32.8;Explizite Instantiierung;480
33;Kapitel 29: Container;483
33.1;Arten von Containern;484
33.2;Sequenzielle Container-Klassen;486
33.3;Iteratoren;488
33.4;Vereinbarung sequenzieller Container;490
33.5;Initialisierungslisten und Range-for-Schleifen;492
33.6;Einfügen in sequenziellen Containern;494
33.7;Elementzugriff;496
33.8;Größe von Containern;498
33.9;Löschen in sequenziellen Containern;500
33.10;Listenoperationen;502
33.11;Die Container-Klasse array;504
34;Kapitel 30: Mehrfachvererbung;507
34.1;Mehrfach abgeleitete Klassen;508
34.2;Mehrfache indirekte Basisklassen;510
34.3;Virtuelle Basisklassen;512
34.4;Aufrufe von Konstruktoren;514
34.5;Initialisierung virtueller Basisklassen;516
35;Kapitel 31: Wahlfreier Dateizugriff und Dateisysteme;519
35.1;Dateien für wahlfreien Zugriff öffnen;520
35.2;Wahlfreies Positionieren;522
35.3;Dateistatus;526
35.4;Exception-Handling für Dateien;528
35.5;Persistenz von polymorphen Objekten;530
35.6;Anwendung: Indexdateien;534
35.7;Implementierung eines Index-Dateisystems;536
35.8;Portabler Zugriff auf das Dateisystem;538
36;Kapitel 32: Variadische Templates;543
36.1;Variable Anzahl von Parametern;544
36.2;Operationen mit Parameterpacks;546
36.3;Standard-Template für Tupel;548
36.4;Typsichere Varianten;550
36.5;Die Standard-Klassen optional und any;552
37;Kapitel 33: Assoziative Container und Hash-Tabellen;555
37.1;Assoziative Container;556
37.2;Sets und Multisets;558
37.3;Maps und Multimaps;560
37.4;Hash-Tabellen;562
37.5;Ungeordnete assoziative Container;564
37.6;Hash-Tabellen für selbstdefinierte Typen;566
38;Kapitel 34: Bitmanipulationen;569
38.1;Logische Bitoperatoren;570
38.2;Shift-Operatoren;572
38.3;Bitmasken;574
38.4;Verwenden von Bitmasken;576
38.5;Bitfelder;578
38.6;Standard-Templates für Bitsets;580
39;Kapitel 35: Smart Pointer;585
39.1;Grundlagen;586
39.2;Die Smart Pointer der Standardbibliothek;588
39.3;Smart Pointer vom Typ unique_ptr einsetzen;590
39.4;Smart Pointer vom Typ unique_ptr einsetzen (2);592
39.5;Das Klassen-Template shared_ptr;594
39.6;Das Klassen-Template shared_ptr (2);596
39.7;Das Klassen-Template shared_ptr (3);598
39.8;Das Klassen-Template weak_ptr;600
40;Kapitel 36: Multithreading;603
40.1;Threads;604
40.2;Erzeugen und Ausführen von Threads;606
40.3;Initialisierung und Zuweisung;608
40.4;Konkurrierende Speicherzugriffe;610
40.5;Thread-ID;612
40.6;Locks;614
40.7;Bedingungsvariablen;616
41;Kapitel 37: Algorithmen der Standardbibliothek;621
41.1;Algorithmen: Grundlagen;622
41.2;Funktionsobjekte;624
41.3;Lambda-Funktionen;628
41.4;Algorithmen und Iteratoren;630
41.5;Vordefinierte Iteratoren;632
41.6;Nicht-modifizierende Algorithmen;634
41.7;Modifizierende Algorithmen;638
41.8;Mutierende Algorithmen;642
41.9;Sortieren und verwandte Operationen;644
42;Kapitel 38: Numerische Bibliothek;649
42.1;Komplexe Zahlen;650
42.2;Das Klassen-Template complex;652
42.3;Methoden von complex;654
42.4;Komplexe Funktionen;656
42.5;Das Klassen-Template valarray;658
42.6;Zuweisung numerischer Vektoren;660
42.7;Arithmetische Operationen;662
42.8;Weitere Operationen;664
42.9;Selektive Indizierung;666
42.10;Verallgemeinerte selektive Indizierung;668
42.11;Indirekte und maskierte Indizierung;672
42.12;Übungen zu Kapitel 1;676
42.13;Lösungen zu Kapitel 1;678
42.14;Übungen zu Kapitel 2;680
42.15;Lösungen zu Kapitel 2;682
42.16;Übungen zu Kapitel 3;684
42.17;Lösungen zu Kapitel 3;686
42.18;Übungen zu Kapitel 4;688
42.19;Lösungen zu Kapitel 4;690
42.20;Übungen zu Kapitel 5;694
42.21;Lösungen zu Kapitel 5;696
42.22;Übungen zu Kapitel 6;698
42.23;Lösungen zu Kapitel 6;700
42.24;Übungen zu Kapitel 7;704
42.25;Lösungen zu Kapitel 7;708
42.26;Übungen zu Kapitel 8;716
42.27;Lösungen zu Kapitel 8;718
42.28;Übungen zu Kapitel 9;722
42.29;Lösungen zu Kapitel 9;725
42.30;Übungen zu Kapitel 10;732
42.31;Lösungen zu Kapitel 10;736
42.32;Übungen zu Kapitel 11;742
42.33;Lösungen zu Kapitel 11;744
42.34;Übungen zu Kapitel 12;750
42.35;Lösungen zu Kapitel 12;752
42.36;Übungen zu Kapitel 13;756
42.37;Lösungen zu Kapitel 13;760
42.38;Übungen zu Kapitel 14;768
42.39;Lösungen zu Kapitel 14;772
42.40;Übungen zu Kapitel 15;780
42.41;Lösungen zu Kapitel 15;784
42.42;Übungen zu Kapitel 16;794
42.43;Lösungen zu Kapitel 16;798
42.44;Übungen zu Kapitel 17;806
42.45;Lösungen zu Kapitel 17;810
42.46;Übungen zu Kapitel 18;826
42.47;Lösungen zu Kapitel 18;829
42.48;Übungen zu Kapitel 19;840
42.49;Lösungen zu Kapitel 19;842
42.50;Übungen zu Kapitel 20;848
42.51;Lösungen zu Kapitel 20;850
42.52;Übungen zu Kapitel 21;860
42.53;Lösungen zu Kapitel 21;862
42.54;Übungen zu Kapitel 22;872
42.55;Lösungen zu Kapitel 22;876
42.56;Übungen zu Kapitel 23;886
42.57;Lösungen zu Kapitel 23;887
42.58;Übungen zu Kapitel 24;890
42.59;Lösungen zu Kapitel 24;893
42.60;Übungen zu Kapitel 25;900
42.61;Lösungen zu Kapitel 25;902
42.62;Übungen zu Kapitel 26;910
42.63;Lösungen zu Kapitel 26;913
42.64;Übungen zu Kapitel 27;924
42.65;Lösungen zu Kapitel 27;926
42.66;Übungen zu Kapitel 28;930
42.67;Lösungen zu Kapitel 28;933
42.68;Übungen zu Kapitel 29;942
42.69;Lösungen zu Kapitel 29;944
42.70;Übungen zu Kapitel 30;948
42.71;Lösungen zu Kapitel 30;952
42.72;Übungen zu Kapitel 31;958
42.73;Lösungen zu Kapitel 31;962
42.74;Übungen zu Kapitel 33;984
42.75;Lösungen zu Kapitel 33;986
42.76;Übungen zu Kapitel 34;992
42.77;Lösungen zu Kapitel 34;994
42.78;Übungen zu Kapitel 35;998
42.79;Lösungen zu Kapitel 35;1002
42.80;Übungen zu Kapitel 36;1014
42.81;Lösungen zu Kapitel 36;1018
42.82;Binäre Zahlendarstellung;1026
42.83;Präprozessor-Direktiven;1029
42.84;Vordefinierte Standardmakros;1036
42.85;Ungepufferte Konsolen-Ein-/Ausgabe;1037
42.86;Einbinden von C-Funktionen;1039
42.87;Operatorenübersicht;1041
42.88;Vorrangtabelle für Operatoren;1043
42.89;ASCII-Code-Tabelle;1044
42.90;Bildschirmsteuerzeichen;1046
42.91;Infos zu den Beispielen, Lösungen und Compilern;1047
43;Stichwortverzeichnis;1071

Über Autor(innen)

Ulla Kirch ist em. Professorin für Informatik an der Hochschule München.Peter Prinz ist nach seiner Promotion an der LMU München seit vielen Jahren selbstständig als Seminar- und Projektleiter in der Informatik tätig.