Produkt

KlappentextC++ ist eine der wichtigsten und meistgenutzten Programmiersprachen weltweit, gilt aber auch als sehr kompliziert.
Dieses Buch vermittelt Ihnen in leicht verständlichen Lektionen die Grundlagen der C++-Programmierung nach dem neuesten Standard C++ 17. Schritt für Schritt erfahren Sie alles über die Sprache und die Konzepte, die der C++-Programmierung zugrunde liegen.
Erste Schritte mit C++
- Der sichere Einstieg
- Keine Vorkenntnisse erforderlich
- Von den Grundlagen bis zum Profikurs
Der mehrteilige Aufbau des Buches spiegelt dabei Ihre vier Entwicklungsstufen wider:
Auf der ersten Stufe werden Sie in lockerem, leicht verständlichem Stil in die Grundlagen und Hintergründe der Programmierung eingeführt.
Die zweite Stufe erschließt Ihnen dann die wichtigsten Elemente der C++-Standardbibliothek, mit deren Hilfe Sie die unterschiedlichsten Programmideen umsetzen können.
Der dritte Teil führt Sie in die Geheimnisse der Objektorientierung ein und im vierten Teil untersuchen wir noch einige weit fortgeschrittene Themen wie die Operatorenüberladung, Zeiger auf Funktionen oder die Möglichkeiten der Bitmanipulation.
Referenz und Nachschlagewerk
Abgerundet wird das Buch durch zahlreiche Übungen, einen Lösungsteil, eine Syntax-Referenz und einen umfangreicher Index, damit Ihnen das Buch auch nach dem ersten Durcharbeiten als Referenz und Nachschlagewerk gute Dienste leisten kann.

Dirk Louis studierte Informatik und Biologie und ist Autor aus Leidenschaft. Java, Android und C++ sind seine Kernthemen.

Details

Weitere ISBN/GTIN9783446457270

ProduktartE-Book

EinbandartE-Book

FormatEPUB

Format HinweisePub Wasserzeichen

Verlag

Hanser, Carl GmbH + Co.

Erscheinungsjahr2018

Erscheinungsdatum09.04.2018

Auflage1. Auflage

Seiten490 Seiten

SpracheDeutsch

Artikel-Nr.3387796

Rubriken

Genre9200

Inhalt/Kritik

Inhaltsverzeichnis

1;Inhalt;7
2;Vorwort;17
3;Teil I: Grundkurs;19
3.1;1 Keine Angst vor C++!;21
3.1.1;1.1 Von C zu C++;22
3.1.1.1;1.1.1 Rückblick;22
3.1.1.2;1.1.2 Die strukturierte Programmierung;24
3.1.1.3;1.1.3 Chips sind billig, Programmierer teuer;26
3.1.1.4;1.1.4 Fassen wir zusammen;27
3.1.2;1.2 Von der Idee zum fertigen Programm;28
3.1.3;1.3 Näher hingeschaut: der C++-Compiler;30
3.1.3.1;1.3.1 Der Compiler ist ein strenger Lehrer;30
3.1.3.2;1.3.2 Definition und Deklaration;31
3.1.3.3;1.3.3 Das Konzept der Headerdateien;33
3.1.3.4;1.3.4 Namensräume;34
3.1.3.5;1.3.5 Der Compiler bei der Arbeit;36
3.1.3.6;1.3.6 ISO und die Compiler-Wahl;37
3.1.3.7;1.3.7 Der neue C++17-Standard;37
3.1.4;1.4 Übungen;38
3.2;2 Grundkurs: Das erste Programm;39
3.2.1;2.1 Hallo Welt! - das Programmgerüst;39
3.2.1.1;2.1.1 Typischer Programmaufbau;40
3.2.1.2;2.1.2 Die Eintrittsfunktion main();41
3.2.1.3;2.1.3 Die Anweisungen;42
3.2.1.4;2.1.4 Headerdateien;44
3.2.1.5;2.1.5 Kommentare;45
3.2.2;2.2 Programmerstellung;46
3.2.2.1;2.2.1 Programmerstellung mit Visual Studio;46
3.2.2.2;2.2.2 Programmerstellung mit GNU-Compiler;53
3.2.2.3;2.2.3 Programmausführung;54
3.2.3;2.3 Stil;56
3.2.4;2.4 Übungen;57
3.3;3 Grundkurs: Daten und Variablen;59
3.3.1;3.1 Konstanten (Literale);59
3.3.2;3.2 Variablen;62
3.3.2.1;3.2.1 Variablendefinition;62
3.3.2.2;3.2.2 Werte in Variablen speichern;65
3.3.2.3;3.2.3 Variablen bei der Definition initialisieren;66
3.3.2.4;3.2.4 Werte von Variablen abfragen;67
3.3.3;3.3 Konstante Variablen;68
3.3.4;3.4 Die Datentypen;69
3.3.4.1;3.4.1 Die Bedeutung des Datentyps;69
3.3.4.2;3.4.2 Die elementaren Datentypen;73
3.3.4.3;3.4.3 Weitere Datentypen;75
3.3.5;3.5 Typumwandlung;75
3.3.5.1;3.5.1 Typumwandlung bei der Ein- und Ausgabe;75
3.3.5.2;3.5.2 Automatische Typumwandlungen;78
3.3.5.3;3.5.3 Explizite Typumwandlungen;79
3.3.6;3.6 Übungen;80
3.4;4 Grundkurs: Operatoren und Ausdrücke;83
3.4.1;4.1 Rechenoperationen;83
3.4.1.1;4.1.1 Die arithmetischen Operatoren;83
3.4.1.2;4.1.2 Die mathematischen Funktionen;86
3.4.2;4.2 Ausdrücke;87
3.4.3;4.3 Die kombinierten Zuweisungen;89
3.4.4;4.4 Inkrement und Dekrement;89
3.4.5;4.5 Strings addieren;91
3.4.6;4.6 Weitere Operatoren;92
3.4.7;4.7 Übungen;92
3.5;5 Grundkurs: Kontrollstrukturen;93
3.5.1;5.1 Entscheidungen und Bedingungen;93
3.5.1.1;5.1.1 Bedingungen;94
3.5.1.2;5.1.2 Die Vergleichsoperatoren;95
3.5.1.3;5.1.3 Die logischen Operatoren;96
3.5.2;5.2 Verzweigungen;98
3.5.2.1;5.2.1 Die einfache if-Anweisung;98
3.5.2.2;5.2.2 Die if-else-Verzweigung;100
3.5.2.3;5.2.3 Die switch-Verzweigung;103
3.5.3;5.3 Schleifen;107
3.5.3.1;5.3.1 Die while-Schleife;107
3.5.3.2;5.3.2 Die do-while-Schleife;111
3.5.3.3;5.3.3 Die for-Schleife;113
3.5.3.4;5.3.4 Schleifen mit mehreren Schleifenvariablen;114
3.5.3.5;5.3.5 Performance-Tipps;115
3.5.4;5.4 Sprunganweisungen;115
3.5.4.1;5.4.1 Abbruchbefehle für Schleife;117
3.5.4.2;5.4.2 Abbruchbefehle für Funktionen;120
3.5.4.3;5.4.3 Sprünge mit goto;120
3.5.5;5.5 Fallstricke;120
3.5.5.1;5.5.1 Die leere Anweisung ;;120
3.5.5.2;5.5.2 Nebeneffekte in booleschen Ausdrücken;121
3.5.5.3;5.5.3 Dangling else-Problem;122
3.5.5.4;5.5.4 Endlosschleifen;123
3.5.6;5.6 Übungen;124
3.6;6 Grundkurs: Eigene Funktionen;127
3.6.1;6.1 Definition und Aufruf;128
3.6.1.1;6.1.1 Der Ort der Funktionsdefinition;129
3.6.1.2;6.1.2 Funktionsprototypen (Deklaration);130
3.6.2;6.2 Rückgabewerte und Parameter;131
3.6.2.1;6.2.1 Rückgabewerte;133
3.6.2.2;6.2.2 Parameter;135
3.6.3;6.3 Lokale und globale Variablen;140
3.6.3.1;6.3.1 Lokale Variablen;140
3.6.3.2;6.3.2 Globale Variablen;141
3.6.3.3;6.3.3 Gültigkeitsbereiche und Verdeckung;142
3.6.4;6.4 Funktionen und der Stack;144
3.6.5;6.5 Überladung;146
3.6.6;6.6 Übungen;148
3.7;7 Grundkurs: Eigene Datentypen;149
3.7.1;7.1 Arrays;149
3.7.1.1;7.1.1 Definition;149
3.7.1.2;7.1.2 Auf Array-Elemente zugreifen;151
3.7.1.3;7.1.3 Initialisierung;151
3.7.1.4;7.1.4 Arrays in Schleifen durchlaufen;152
3.7.1.5;7.1.5 Arrays an Funktionen übergeben;155
3.7.1.6;7.1.6 Mehrdimensionale Arrays;155
3.7.1.7;7.1.7 Vor- und Nachteile der Programmierung mit Arrays;156
3.7.2;7.2 Aufzählungen;156
3.7.2.1;7.2.1 Definition;159
3.7.2.2;7.2.2 Variablen;159
3.7.2.3;7.2.3 Aufzählungstypen und switch-Verzweigungen;160
3.7.2.4;7.2.4 Die neuen enum class-Aufzählungen;160
3.7.3;7.3 Strukturen;161
3.7.3.1;7.3.1 Definition;162
3.7.3.2;7.3.2 Variablendefinition;163
3.7.3.3;7.3.3 Zugriff auf Elemente;164
3.7.3.4;7.3.4 Initialisierung;164
3.7.3.5;7.3.5 Arrays von Strukturen;164
3.7.4;7.4 Klassen;166
3.7.4.1;7.4.1 Definition;166
3.7.4.2;7.4.2 Variablen, Objekte und Konstruktoren;166
3.7.4.3;7.4.3 Zugriffsschutz;167
3.7.5;7.5 Übungen;170
3.8;8 Grundkurs: Zeiger und Referenzen;171
3.8.1;8.1 Zeiger;171
3.8.1.1;8.1.1 Definition;172
3.8.1.2;8.1.2 Initialisierung;172
3.8.1.3;8.1.3 Dereferenzierung;174
3.8.1.4;8.1.4 Zeigerarithmetik;176
3.8.2;8.2 Referenzen;177
3.8.3;8.3 Einsatzgebiete;177
3.8.3.1;8.3.1 call by reference;178
3.8.3.2;8.3.2 Dynamische Speicherreservierung;183
3.8.4;8.4 Übungen;189
3.9;9 Grundkurs: Noch ein paar Tipps;191
3.9.1;9.1 Wie gehe ich neue Programme an?;191
3.9.2;9.2 Wo finde ich Hilfe?;192
3.9.2.1;9.2.1 Hilfe zu Compiler-Meldungen;192
3.9.2.2;9.2.2 Hilfe bei der Lösung von Programmieraufgaben;193
3.9.2.3;9.2.3 Hilfe bei Programmen, die nicht richtig funktionieren;197
3.9.2.4;9.2.4 Debuggen;197
3.9.3;9.3 Programme optimieren;199
4;Teil II - Aufbaukurs: die Standardbibliothek;201
4.1;10 Aufbaukurs: Einführung;203
4.1.1;10.1 Bibliotheken verwenden;203
4.1.2;10.2 Hilfe zu den Bibliothekselementen;204
4.2;11 Aufbaukurs: Mathematische Funktionen;207
4.2.1;11.1 Die mathematischen Funktionen;207
4.2.1.1;11.1.1 Mathematische Konstanten;209
4.2.1.2;11.1.2 Verwendung der trigonometrischen Funktionen;210
4.2.1.3;11.1.3 Überläufe;210
4.2.2;11.2 Zufallszahlen;211
4.2.3;11.3 Komplexe Zahlen;213
4.2.4;11.4 Übungen;214
4.3;12 Aufbaukurs: Strings;215
4.3.1;12.1 String-Literale;215
4.3.1.1;12.1.1 Escape-Sequenzen;216
4.3.1.2;12.1.2 Zeilenumbrüche;218
4.3.2;12.2 Strings erzeugen;219
4.3.3;12.3 Strings aneinanderhängen;220
4.3.4;12.4 Strings vergleichen;220
4.3.5;12.5 Sonstige String-Manipulationen;223
4.3.6;12.6 C-Strings;224
4.3.7;12.7 Umwandlungen zwischen Strings und Zahlen;224
4.3.8;12.8 Übungen;225
4.4;13 Aufbaukurs: Ein- und Ausgabe;227
4.4.1;13.1 Daten auf die Konsole ausgeben;227
4.4.2;13.2 Formatierte Ausgabe;228
4.4.2.1;13.2.1 Ausgabebreite;228
4.4.2.2;13.2.2 Füllzeichen;229
4.4.2.3;13.2.3 Genauigkeit;229
4.4.2.4;13.2.4 Formatierte Ausgabe mit printf();230
4.4.3;13.3 Deutsche Umlaute;231
4.4.4;13.4 Daten über die Konsole (Tastatur) einlesen;234
4.4.5;13.5 Fehlerbehandlung;235
4.4.6;13.6 Streams;237
4.4.7;13.7 Textdateien;238
4.4.7.1;13.7.1 In Textdateien schreiben;239
4.4.7.2;13.7.2 Aus Textdateien lesen;241
4.4.8;13.8 Binärdateien;244
4.4.9;13.9 Übungen;246
4.5;14 Aufbaukurs: Zeit und Datum;247
4.5.1;14.1 Zeit und Datum;247
4.5.2;14.2 Laufzeitmessungen;253
4.5.3;14.3 Übungen;255
4.6;15 Aufbaukurs: Container;257
4.6.1;15.1 Die STL;257
4.6.2;15.2 vector - ein intelligenter Daten-Container;260
4.6.2.1;15.2.1 Einsatz eines Containers;261
4.6.2.2;15.2.2 Größenmanagement von Containern;262
4.6.2.3;15.2.3 Typische Memberfunktionen;263
4.6.3;15.3 Der Gebrauch von Iteratoren;264
4.6.4;15.4 Die Algorithmen;267
4.6.4.1;15.4.1 generate();270
4.6.4.2;15.4.2 stable_sort();271
4.6.5;15.5 Schlüssel/Wert-Paare;272
4.6.6;15.6 Übungen;274
4.7;16 Aufbaukurs: Programme aus mehreren Quelltextdateien;275
4.7.1;16.1 Quelltext verteilen;275
4.7.1.1;16.1.1 Funktionen über Dateigrenzen hinweg verwenden;276
4.7.1.2;16.1.2 Klassen über Dateigrenzen hinweg verwenden;276
4.7.1.3;16.1.3 Variablen über Dateigrenzen hinweg verwenden;277
4.7.1.4;16.1.4 Typdefinitionen über Dateigrenzen hinweg verwenden;278
4.7.2;16.2 Mehrfacheinkopieren von Headerdateien verhindern;279
4.7.3;16.3 Übungen;281
5;Teil III - Objektorientierte Programmierung;283
5.1;17 OOP-Kurs: Klassen;285
5.1.1;17.1 Objektorientiert denken - objektorientiert programmieren;285
5.1.1.1;17.1.1 Objektorientiertes Programmieren;285
5.1.1.2;17.1.2 Wie sind Objekte beschaffen?;286
5.1.1.3;17.1.3 Wie findet man einen objektorientierten Lösungsansatz?;288
5.1.1.4;17.1.4 Objekte und Klassen;289
5.1.2;17.2 Klassendefinition;292
5.1.2.1;17.2.1 Zugriffsrechte;293
5.1.2.2;17.2.2 Quelltext- und Headerdatei;295
5.1.2.3;17.2.3 Klassen zu Visual-Studio-Projekten hinzufügen;298
5.1.3;17.3 Membervariablen;301
5.1.3.1;17.3.1 Anfangswerte;302
5.1.3.2;17.3.2 Private-Deklaration;306
5.1.3.3;17.3.3 Eingebettete Objekte;308
5.1.3.4;17.3.4 Konstante Membervariablen;310
5.1.3.5;17.3.5 Statische Membervariablen;311
5.1.4;17.4 Memberfunktionen;312
5.1.4.1;17.4.1 Definition innerhalb der Klassendefinition;312
5.1.4.2;17.4.2 Definition außerhalb der Klassendefinition;313
5.1.4.3;17.4.3 Der this-Zeiger;314
5.1.4.4;17.4.4 Statische Memberfunktionen;315
5.1.4.5;17.4.5 Konstante Memberfunktionen;316
5.1.4.6;17.4.6 Get-/Set-Memberfunktionen;317
5.1.5;17.5 Die Konstruktoren;320
5.1.5.1;17.5.1 Definition und Aufruf;320
5.1.5.2;17.5.2 Ersatz- und Standardkonstruktoren;322
5.1.6;17.6 Der Destruktor;325
5.1.7;17.7 Übungen;326
5.2;18 OOP-Kurs: Vererbung;329
5.2.1;18.1 Das Prinzip der Vererbung;329
5.2.1.1;18.1.1 Der grundlegende Mechanismus;330
5.2.1.2;18.1.2 Die Syntax;331
5.2.1.3;18.1.3 Wann ist Vererbung gerechtfertigt?;332
5.2.1.4;18.1.4 Einige wichtige Fakten;333
5.2.2;18.2 Das Basisklassenunterobjekt;334
5.2.2.1;18.2.1 Zugriff;335
5.2.2.2;18.2.2 Instanzbildung;338
5.2.3;18.3 Die Zugriffsspezifizierer für die Vererbung;340
5.2.4;18.4 Verdecken, überschreiben und überladen;341
5.2.4.1;18.4.1 Verdeckung;342
5.2.4.2;18.4.2 Überladung;342
5.2.4.3;18.4.3 Überschreibung;343
5.2.5;18.5 Der Destruktor;343
5.2.6;18.6 Mehrfachvererbung;344
5.2.7;18.7 Übungen;344
5.3;19 OOP-Kurs: Polymorphie;347
5.3.1;19.1 Grundprinzip und Implementierung;348
5.3.2;19.2 Späte und frühe Bindung;351
5.3.2.1;19.2.1 Frühe Bindung;351
5.3.2.2;19.2.2 Späte Bindung;352
5.3.3;19.3 Generische Programmierung;353
5.3.3.1;19.3.1 Basisklassen-Arrays;354
5.3.3.2;19.3.2 Basisklassenparameter;356
5.3.4;19.4 Typidentifizierung zur Laufzeit (RTTI);357
5.3.4.1;19.4.1 Umwandlung mit dynamic_cast;357
5.3.4.2;19.4.2 Der typeid()-Operator;359
5.3.5;19.5 Abstrakte Klassen;359
5.3.5.1;19.5.1 Rein virtuelle Funktionen;360
5.3.5.2;19.5.2 Abstrakte Klassen;360
5.3.6;19.6 Übungen;361
5.4;20 OOP-Kurs: Ausnahmebehandlung;363
5.4.1;20.1 Fehlerprüfung mit Ausnahmen;364
5.4.2;20.2 Ausnahmen abfangen;366
5.4.3;20.3 Ausnahmen auslösen;369
5.4.4;20.4 Programmfluss und Ausnahmebehandlung;371
5.4.4.1;20.4.1 Wo wird der Programmfluss nach einer Ausnahme fortgesetzt?;372
5.4.4.2;20.4.2 Die Problematik des gestörten Programmflusses;372
5.4.5;20.5 Übungen;374
6;Teil IV - Profikurs;375
6.1;21 Profikurs: Allgemeine Techniken;377
6.1.1;21.1 Vorzeichen und Überlauf;377
6.1.2;21.2 Arithmetische Konvertierungen;379
6.1.3;21.3 Lokale static-Variablen;379
6.1.4;21.4 Der ?:-Operator;380
6.1.5;21.5 Bit-Operatoren;380
6.1.5.1;21.5.1 Multiplikation mit 2;381
6.1.5.2;21.5.2 Division durch 2;382
6.1.5.3;21.5.3 Klein- und Großschreibung;382
6.1.5.4;21.5.4 Flags umschalten;383
6.1.5.5;21.5.5 Gerade Zahlen erkennen;383
6.1.6;21.6 Zeiger auf Funktionen;385
6.1.7;21.7 Rekursion;387
6.1.8;21.8 constexpr-Funktionen;389
6.1.9;21.9 Variablendefinition in if und switch;390
6.2;22 Profikurs: Objektorientierte Techniken;393
6.2.1;22.1 Zeiger auf Memberfunktionen;393
6.2.2;22.2 Friends;395
6.2.3;22.3 Überladung von Operatoren;396
6.2.3.1;22.3.1 Syntax;396
6.2.3.2;22.3.2 Überladung des Inkrement-Operators ++;397
6.2.3.3;22.3.3 Überladung arithmetischer Operatoren +, +=;398
6.2.3.4;22.3.4 Überladung der Streamoperatoren >;399
6.2.4;22.4 Objekte vergleichen;400
6.2.4.1;22.4.1 Gleichheit;400
6.2.4.2;22.4.2 Größenvergleiche;402
6.2.5;22.5 Objekte kopieren;404
6.3;23 Profikurs: Gültigkeitsbereiche und Lebensdauer;409
6.4;24 Profikurs: Templates;413
6.4.1;24.1 Funktionen-Templates;414
6.4.2;24.2 Klassen-Templates;415
6.5;25 Profikurs: Reguläre Ausdrücke;419
6.5.1;25.1 Syntax regulärer Ausdrücke;419
6.5.1.1;25.1.1 Zeichen und Zeichenklassen;420
6.5.1.2;25.1.2 Quantifizierer;421
6.5.1.3;25.1.3 Gruppierung;422
6.5.1.4;25.1.4 Assertionen (Anker);423
6.5.2;25.2 Musterabgleich mit regulären Ausdrücken;423
6.5.3;25.3 Suchen mit regulären Ausdrücken;424
6.5.4;25.4 Ersetzen mit regulären Ausdrücken;425
6.6;26 Profikurs: Lambda-Ausdrücke;427
6.6.1;26.1 Syntax;427
6.6.2;26.2 Einsatz;429
7;A Anhang A: Lösungen;431
8;B Anhang B: Die Beispiele zum Buch;451
8.1;B.1 Installation der Visual Studio Community Edition;451
8.2;B.2 Ausführung der Beispielprogramme;454
8.2.1;B.2.1 Ausführung mit VS Community Edition 2017;455
8.2.2;B.2.2 Ausführung mit beliebigen integrierten Entwicklungsumgebungen;456
8.2.3;B.2.3 Ausführung mit GNU-Konsolen-Compiler;457
9;C Anhang C: Zeichensätze;459
9.1;C.1 Der ASCII-Zeichensatz;459
9.2;C.2 Der ANSI-Zeichensatz;460
10;D Anhang D: Syntaxreferenz;463
10.1;D.1 Schlüsselwörter;463
10.2;D.2 Elementare Typen;464
10.3;D.3 Strings;465
10.4;D.4 Operatoren;466
10.5;D.5 Ablaufsteuerung;467
10.6;D.6 Ausnahmebehandlung;469
10.7;D.7 Aufzählungen;469
10.7.1;D.7.1 enum;469
10.7.2;D.7.2 enum class (C++11);470
10.8;D.8 Arrays;470
10.9;D.9 Zeiger;471
10.10;D.10 Strukturen;471
10.11;D.11 Klassen;472
10.12;D.12 Vererbung;475
10.13;D.13 Namensräume;475
11;E Anhang E: Die Standardbibliothek;477
11.1;E.1 Die C-Standardbibliothek;477
11.2;E.2 Die C++-Standardbibliothek;478
12;Index;481
13;Leere Seite;2mehr

Leseprobe

1 Keine Angst vor C++!

C++ steht in dem Ruf, eine besonders mächtige und leistungsfähige, aber leider auch eine sehr schwer zu erlernende Programmiersprache zu sein. Letzteres ist wohl darauf zurückzuführen, dass die vielfältigen Möglichkeiten und die Freiheiten, die C++ dem Programmierer bietet, einer ebenso großen Zahl an Konzepten, Techniken und unterschiedlichen Syntaxformen gegenüberstehen. Und gerade diese Syntaxformen - das lässt sich nicht leugnen - können auf Anfänger schon recht abschreckend wirken. Einige Kostproben gefällig? Zeilen der Form:

virtual const char* f() const noexcept;

sind in C++ keineswegs unüblich und auch Berechnungen der Form:

i = m++*+n;

sind möglich. Besondere Freude bereiten aber Deklarationen wie z. B.:

int *(*f(int))(int, int);

Falls Ihnen jetzt Zweifel kommen, ob Sie mit C++ wirklich die richtige Wahl getroffen haben, so lassen Sie sich versichern:

C++ ist viel einfacher, als es manchmal den Anschein hat.

Schon bald werden Sie Ihre eigenen C++-Programme schreiben.

Mit jedem Programm, das Sie schreiben, wird Ihnen C++ vertrauter und selbstverständlicher erscheinen.

Am Ende dieses Buchs werden Sie nicht nur in der Lage sein, attraktive und professionelle Programmvorhaben anzugehen, Sie werden auch verstehen, was die erste der obigen Beispielzeilen bedeutet, und Sie werden den Kopf darüber schütteln, warum der Verfasser der eigentlich doch ganz einfachen zweiten Beispielzeile den Code nicht lesefreundlicher formatiert hat.

Nur die Bedeutung der dritten Beispielzeile werden Sie nach der Lektüre dieses Buchs immer noch nicht verstehen. Aber trösten Sie sich: Die Konstruktion, die in dieser Zeile deklariert wird 1, ist so abgehoben, dass Sie unter zehn professionellen C++-Programmierern vermutlich höchstens einen finden werden, der diese Konstruktion erkennt, geschweige denn sie selbst schon einmal eingesetzt hätte.

Warum aber ist C++ so mächtig? Warum gibt es so viele Konzepte in der Sprache und warum ist die Syntax so kryptisch? Die Antwort auf diese Fragen liegt in der Geschichte von C++.

1.1 Von C zu C++
"The times they are a changin´" - die Zeiten ändern sich - heißt es in einem berühmten Song von Bob Dylan. Sicherlich hatte Dylan dabei nicht die Entwicklungen in der IT-Branche und der Softwareerstellung im Auge, doch allgemeine Wahrheiten lassen sich eben auf viele verschiedene Bereiche anwenden - und manchmal eben auch auf den Bereich der Softwareentwicklung.

Dort hat im Laufe der letzten Jahrzehnte tatsächlich ein grundlegender Wandel stattgefunden.

1.1.1 Rückblick
Wann die Entwicklung des Computers, der Rechenmaschine, begonnen hat, ist gar nicht so leicht zu sagen. Es hängt sehr davon ab, wie weit man zurückgehen möchte. In einer Aprilausgabe der renommierten Fachzeitschrift "Spektrum der Wissenschaften" wurde vor einigen Jahren beispielsweise von einer Aufsehen erregenden Entdeckung berichtet: Amerikanische Archäologen hatten auf einer Insel bei Neuguinea einen frühzeitlichen Computer entdeckt. Aus Seilen und Rollen hatten die Ureinwohner aus der Elektronik bekannte Schaltbausteine wie AND-Gatter, OR-Gatter und Inverter erstellt und zu einem echten Rechenwerk zusammengesetzt. Die Archäologen nahmen an, dass die damalige Priesterkaste diesen "Computer" als eine Art Orakel betrieb und ihr Wissen um die Konstruktion dieses Orakels zum Machterhalt nutzte. Schematische Abbildungen zur Funktionsweise des Rechenwerks und eine Einführung in die digitale Schaltungslogik rundeten den Artikel ab. Natürlich handelte es sich um einen Aprilscherz, aber immerhin: Unter dem Eindruck von so viel Logik und Wissenschaft blieb der gesunde Menschenverstand einiger Leser auf der Strecke. In den nachfolgenden Monaten ergingen daraufhin einige böse Briefe an die Redaktion von aufgebrachten Lesern, die die sensationelle Nachricht sofort weiterverbreitet und sich dabei bei ihren Professoren und Kollegen blamiert hatten.

Nicht ganz so weit zurückliegend, dafür aber verbrieft, ist die Erfindung des Lochkartensystems durch den Deutsch-Amerikaner Hermann Hollerith. Um das Jahr 1890 entwickelte er ein Verfahren, bei dem Daten durch Lochung bestimmter Felder auf vorgefertigten Karten (eben den Lochkarten) kodiert und festgehalten wurden. Mit Hilfe spezieller Maschinen, den sogenannten Hollerith- oder Lochkartenmaschinen, konnte man diese Daten automatisch auswerten, beispielsweise zur Erstellung von Serienbriefen, zur statistischen Datenerfassung oder allgemein zur Auswertung großer Datenmengen.

Der erste offiziell anerkannte, noch mechanische Computer war der 1936 gebaute Z1 des Berliners Konrad Zuse. Kurz darauf folgten Röhren-, später Transistoren- und schließlich Chip-Rechner. In der Zwischenzeit hatte sich auch bei der Softwareentwicklung Einiges getan: Anstatt Lochkarten zu stanzen, gab man Maschinenbefehlprogramme über ein Terminal ein. Irgendwann wurden die Maschinenbefehle durch die Sprache Assembler ersetzt und schließlich kamen die ersten höheren Programmiersprachen, die interpretiert oder kompiliert wurden.

Interpreter und Compiler

Maschinenbefehle sind "Wörter", die aus einer Folge von Nullen und Einsen bestehen, also beispielsweise 0011000010101011. Das eigentliche Rechenwerk eines Computers, der Prozessor, versteht nur diese binären Befehle (wobei noch zu beachten ist, dass jeder Prozessortyp seinen eigenen spezifischen Sprachschatz hat). Da das Programmieren mit diesen Befehlen für Menschen viel zu mühsam und schwierig ist, kam man auf die Idee, die Programmquelltexte in einer anderen Sprache aufzusetzen und dann mit Hilfe eines passenden Übersetzerprogramms in Maschinenbefehle umschreiben zu lassen. Die üblichen menschlichen Sprachen sind aber viel zu komplex und uneindeutig, um sie maschinell übersetzen zu können. Aus diesem Grunde wurden eigene Programmiersprachen wie C oder Basic entwickelt, mit einfacher Grammatik und geringem Wortschatz, die für Menschen leichter zu erlernen und für Übersetzerprogramme leichter in Maschinenbefehle umzusetzen sind.

Grundsätzlich gibt es zwei Kategorien von Übersetzerprogrammen: die Interpreter und die Compiler.

Ein Interpreter lädt den Quelltext des Programms, übersetzt ihn stückweise und lässt die übersetzten Anweisungen direkt vom Prozessor ausführen. Endet das Programm, endet auch die Ausführung des Interpreters.

Ein Compiler lädt den Quelltext des Programms, übersetzt ihn komplett (wobei er auch kleinere Optimierungen vornehmen kann) und speichert das kompilierte Programm in einer neuen Datei (unter Windows eine .exe-Datei) auf der Festplatte. Wenn der Anwender die .exe-Datei danach aufruft, wird das Programm direkt vom Betriebssystem geladen und ausgeführt.

Bild 1.1 Schematische Darstellung der Arbeit eines Interpreters und eines Compilers. (Beachten Sie, dass bei der Kompilierung das fertige Programm nur auf Rechnern ausgeführt werden kann, deren Architektur und Betriebssystemfamilie zu dem Rechner des Programmierers kompatibel sind.)

Ein interpretiertes Programm kann auf jedem Rechner ausgeführt werden, auf dem ein passender Interpreter verfügbar ist. Die Ausführung ist allerdings langsamer und der Quelltext des Programms ist für jeden einsehbar. 2

Ein kompiliertes Programm kann nur auf Rechnern ausgeführt werden, deren Plattform (Prozessor/Betriebssystem-Kombination) die Maschinenbefehle versteht, die der Compiler erzeugt hat. Dafür kann der Code für die Plattform optimiert werden, ist aufgrund der Binärkodierung vor geistigem Diebstahl weitgehend geschützt und wird schneller ausgeführt, da kein Interpreter zwischengeschaltet werden muss.

1.1.2 Die strukturierte Programmierung
Anfangs erlaubten die Programmiersprachen nur Programme, in denen die einzelnen Anweisungen, die der Computer bei Ausführung des Programms abarbeiten sollte, von oben nach unten im Programmquelltext angegeben werden mussten.

1. Tue dies

2. Tue das

3. Mache jetzt jenes

4. ...

Programmieranfänger dürfte dieses Prinzip begeistern, denn es ist leicht zu verstehen. Doch in der Praxis stellte sich damals bald heraus, dass diese Art der Programmierung ihre Grenzen hat: Einmal implementierte Teillösungen lassen sich schlecht wiederverwerten, größere Programme sind mangels Strukturierung...mehr

Bitte warten - die Druckansicht der Seite wird vorbereitet.

C++

Verfügbare Formate

Produkt

Inhalt/Kritik

Schlagworte

Autor

Windows 10

Java - Der umfassende Programmierkurs

Java, m. 1 Buch, m. 1 E-Book

Android

Android

Services

Infos

Über uns

Leistungen

Newsletter

Zahlung