C++ (eBook)

Das komplette Starterkit für den einfachen Einstieg in die Programmierung

Dirk Louis (Autor)

eBook Download: PDF | EPUB

2018 | 2. Auflage
490 Seiten
Carl Hanser Verlag GmbH & Co. KG
978-3-446-45388-3 (ISBN)

Infos

C++ 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.

Inhalt

Inhalt 7
Vorwort 17
Teil I: Grundkurs 19
1 Keine Angst vor C++! 21
1.1 Von C zu C++ 22
1.1.1 Rückblick 22
1.1.2 Die strukturierte Programmierung 24
1.1.3 Chips sind billig, Programmierer teuer 26
1.1.4 Fassen wir zusammen 27
1.2 Von der Idee zum fertigen Programm 28
1.3 Näher hingeschaut: der C++-Compiler 30
1.3.1 Der Compiler ist ein strenger Lehrer 30
1.3.2 Definition und Deklaration 31
1.3.3 Das Konzept der Headerdateien 33
1.3.4 Namensräume 34
1.3.5 Der Compiler bei der Arbeit 36
1.3.6 ISO und die Compiler-Wahl 37
1.3.7 Der neue C++17-Standard 37
1.4 Übungen 38
2 Grundkurs: Das erste Programm 39
2.1 Hallo Welt! – das Programmgerüst 39
2.1.1 Typischer Programmaufbau 40
2.1.2 Die Eintrittsfunktion main() 41
2.1.3 Die Anweisungen 42
2.1.4 Headerdateien 44
2.1.5 Kommentare 45
2.2 Programmerstellung 46
2.2.1 Programmerstellung mit Visual Studio 46
2.2.2 Programmerstellung mit GNU-Compiler 53
2.2.3 Programmausführung 54
2.3 Stil 56
2.4 Übungen 57
3 Grundkurs: Daten und Variablen 59
3.1 Konstanten (Literale) 59
3.2 Variablen 62
3.2.1 Variablendefinition 62
3.2.2 Werte in Variablen speichern 65
3.2.3 Variablen bei der Definition initialisieren 66
3.2.4 Werte von Variablen abfragen 67
3.3 Konstante Variablen 68
3.4 Die Datentypen 69
3.4.1 Die Bedeutung des Datentyps 69
3.4.2 Die elementaren Datentypen 73
3.4.3 Weitere Datentypen 75
3.5 Typumwandlung 75
3.5.1 Typumwandlung bei der Ein- und Ausgabe 75
3.5.2 Automatische Typumwandlungen 78
3.5.3 Explizite Typumwandlungen 79
3.6 Übungen 80
4 Grundkurs: Operatoren und Ausdrücke 83
4.1 Rechenoperationen 83
4.1.1 Die arithmetischen Operatoren 83
4.1.2 Die mathematischen Funktionen 86
4.2 Ausdrücke 87
4.3 Die kombinierten Zuweisungen 89
4.4 Inkrement und Dekrement 89
4.5 Strings addieren 91
4.6 Weitere Operatoren 92
4.7 Übungen 92
5 Grundkurs: Kontrollstrukturen 93
5.1 Entscheidungen und Bedingungen 93
5.1.1 Bedingungen 94
5.1.2 Die Vergleichsoperatoren 95
5.1.3 Die logischen Operatoren 96
5.2 Verzweigungen 98
5.2.1 Die einfache if-Anweisung 98
5.2.2 Die if-else-Verzweigung 100
5.2.3 Die switch-Verzweigung 103
5.3 Schleifen 107
5.3.1 Die while-Schleife 107
5.3.2 Die do-while-Schleife 111
5.3.3 Die for-Schleife 113
5.3.4 Schleifen mit mehreren Schleifenvariablen 114
5.3.5 Performance-Tipps 115
5.4 Sprunganweisungen 115
5.4.1 Abbruchbefehle für Schleife 117
5.4.2 Abbruchbefehle für Funktionen 120
5.4.3 Sprünge mit goto 120
5.5 Fallstricke 120

5.5.2 Nebeneffekte in booleschen Ausdrücken 121
5.5.3 Dangling else-Problem 122
5.5.4 Endlosschleifen 123
5.6 Übungen 124
6 Grundkurs: Eigene Funktionen 127
6.1 Definition und Aufruf 128
6.1.1 Der Ort der Funktionsdefinition 129
6.1.2 Funktionsprototypen (Deklaration) 130
6.2 Rückgabewerte und Parameter 131
6.2.1 Rückgabewerte 133
6.2.2 Parameter 135
6.3 Lokale und globale Variablen 140
6.3.1 Lokale Variablen 140
6.3.2 Globale Variablen 141
6.3.3 Gültigkeitsbereiche und Verdeckung 142
6.4 Funktionen und der Stack 144
6.5 Überladung 146
6.6 Übungen 148
7 Grundkurs: Eigene Datentypen 149
7.1 Arrays 149
7.1.1 Definition 149
7.1.2 Auf Array-Elemente zugreifen 151
7.1.3 Initialisierung 151
7.1.4 Arrays in Schleifen durchlaufen 152
7.1.5 Arrays an Funktionen übergeben 155
7.1.6 Mehrdimensionale Arrays 155
7.1.7 Vor- und Nachteile der Programmierung mit Arrays 156
7.2 Aufzählungen 156
7.2.1 Definition 159
7.2.2 Variablen 159
7.2.3 Aufzählungstypen und switch-Verzweigungen 160
7.2.4 Die neuen enum class-Aufzählungen 160
7.3 Strukturen 161
7.3.1 Definition 162
7.3.2 Variablendefinition 163
7.3.3 Zugriff auf Elemente 164
7.3.4 Initialisierung 164
7.3.5 Arrays von Strukturen 164
7.4 Klassen 166
7.4.1 Definition 166
7.4.2 Variablen, Objekte und Konstruktoren 166
7.4.3 Zugriffsschutz 167
7.5 Übungen 170
8 Grundkurs: Zeiger und Referenzen 171
8.1 Zeiger 171
8.1.1 Definition 172
8.1.2 Initialisierung 172
8.1.3 Dereferenzierung 174
8.1.4 Zeigerarithmetik 176
8.2 Referenzen 177
8.3 Einsatzgebiete 177
8.3.1 call by reference 178
8.3.2 Dynamische Speicherreservierung 183
8.4 Übungen 189
9 Grundkurs: Noch ein paar Tipps 191
9.1 Wie gehe ich neue Programme an? 191
9.2 Wo finde ich Hilfe? 192
9.2.1 Hilfe zu Compiler-Meldungen 192
9.2.2 Hilfe bei der Lösung von Programmieraufgaben 193
9.2.3 Hilfe bei Programmen, die nicht richtig funktionieren 197
9.2.4 Debuggen 197
9.3 Programme optimieren 199
Teil II – Aufbaukurs: die Standardbibliothek 201
10 Aufbaukurs: Einführung 203
10.1 Bibliotheken verwenden 203
10.2 Hilfe zu den Bibliothekselementen 204
11 Aufbaukurs: Mathematische Funktionen 207
11.1 Die mathematischen Funktionen 207
11.1.1 Mathematische Konstanten 209
11.1.2 Verwendung der trigonometrischen Funktionen 210
11.1.3 Überläufe 210
11.2 Zufallszahlen 211
11.3 Komplexe Zahlen 213
11.4 Übungen 214
12 Aufbaukurs: Strings 215
12.1 String-Literale 215
12.1.1 Escape-Sequenzen 216
12.1.2 Zeilenumbrüche 218
12.2 Strings erzeugen 219
12.3 Strings aneinanderhängen 220
12.4 Strings vergleichen 220
12.5 Sonstige String-Manipulationen 223
12.6 C-Strings 224
12.7 Umwandlungen zwischen Strings und Zahlen 224
12.8 Übungen 225
13 Aufbaukurs: Ein- und Ausgabe 227
13.1 Daten auf die Konsole ausgeben 227
13.2 Formatierte Ausgabe 228
13.2.1 Ausgabebreite 228
13.2.2 Füllzeichen 229
13.2.3 Genauigkeit 229
13.2.4 Formatierte Ausgabe mit printf() 230
13.3 Deutsche Umlaute 231
13.4 Daten über die Konsole (Tastatur) einlesen 234
13.5 Fehlerbehandlung 235
13.6 Streams 237
13.7 Textdateien 238
13.7.1 In Textdateien schreiben 239
13.7.2 Aus Textdateien lesen 241
13.8 Binärdateien 244
13.9 Übungen 246
14 Aufbaukurs: Zeit und Datum 247
14.1 Zeit und Datum 247
14.2 Laufzeitmessungen 253
14.3 Übungen 255
15 Aufbaukurs: Container 257
15.1 Die STL 257
15.2 vector – ein intelligenter Daten-Container 260
15.2.1 Einsatz eines Containers 261
15.2.2 Größenmanagement von Containern 262
15.2.3 Typische Memberfunktionen 263
15.3 Der Gebrauch von Iteratoren 264
15.4 Die Algorithmen 267
15.4.1 generate() 270
15.4.2 stable_sort() 271
15.5 Schlüssel/Wert-Paare 272
15.6 Übungen 274
16 Aufbaukurs: Programme aus mehreren Quelltextdateien 275
16.1 Quelltext verteilen 275
16.1.1 Funktionen über Dateigrenzen hinweg verwenden 276
16.1.2 Klassen über Dateigrenzen hinweg verwenden 276
16.1.3 Variablen über Dateigrenzen hinweg verwenden 277
16.1.4 Typdefinitionen über Dateigrenzen hinweg verwenden 278
16.2 Mehrfacheinkopieren von Headerdateien verhindern 279
16.3 Übungen 281
Teil III – Objektorientierte Programmierung 283
17 OOP-Kurs: Klassen 285
17.1 Objektorientiert denken – objektorientiert programmieren 285
17.1.1 Objektorientiertes Programmieren 285
17.1.2 Wie sind Objekte beschaffen? 286
17.1.3 Wie findet man einen objektorientierten Lösungsansatz? 288
17.1.4 Objekte und Klassen 289
17.2 Klassendefinition 292
17.2.1 Zugriffsrechte 293
17.2.2 Quelltext- und Headerdatei 295
17.2.3 Klassen zu Visual-Studio-Projekten hinzufügen 298
17.3 Membervariablen 301
17.3.1 Anfangswerte 302
17.3.2 Private-Deklaration 306
17.3.3 Eingebettete Objekte 308
17.3.4 Konstante Membervariablen 310
17.3.5 Statische Membervariablen 311
17.4 Memberfunktionen 312
17.4.1 Definition innerhalb der Klassendefinition 312
17.4.2 Definition außerhalb der Klassendefinition 313
17.4.3 Der this-Zeiger 314
17.4.4 Statische Memberfunktionen 315
17.4.5 Konstante Memberfunktionen 316
17.4.6 Get-/Set-Memberfunktionen 317
17.5 Die Konstruktoren 320
17.5.1 Definition und Aufruf 320
17.5.2 Ersatz- und Standardkonstruktoren 322
17.6 Der Destruktor 325
17.7 Übungen 326
18 OOP-Kurs: Vererbung 329
18.1 Das Prinzip der Vererbung 329
18.1.1 Der grundlegende Mechanismus 330
18.1.2 Die Syntax 331
18.1.3 Wann ist Vererbung gerechtfertigt? 332
18.1.4 Einige wichtige Fakten 333
18.2 Das Basisklassenunterobjekt 334
18.2.1 Zugriff 335
18.2.2 Instanzbildung 338
18.3 Die Zugriffsspezifizierer für die Vererbung 340
18.4 Verdecken, überschreiben und überladen 341
18.4.1 Verdeckung 342
18.4.2 Überladung 342
18.4.3 Überschreibung 343
18.5 Der Destruktor 343
18.6 Mehrfachvererbung 344
18.7 Übungen 344
19 OOP-Kurs: Polymorphie 347
19.1 Grundprinzip und Implementierung 348
19.2 Späte und frühe Bindung 351
19.2.1 Frühe Bindung 351
19.2.2 Späte Bindung 352
19.3 Generische Programmierung 353
19.3.1 Basisklassen-Arrays 354
19.3.2 Basisklassenparameter 356
19.4 Typidentifizierung zur Laufzeit (RTTI) 357
19.4.1 Umwandlung mit dynamic_cast 357
19.4.2 Der typeid()-Operator 359
19.5 Abstrakte Klassen 359
19.5.1 Rein virtuelle Funktionen 360
19.5.2 Abstrakte Klassen 360
19.6 Übungen 361
20 OOP-Kurs: Ausnahmebehandlung 363
20.1 Fehlerprüfung mit Ausnahmen 364
20.2 Ausnahmen abfangen 366
20.3 Ausnahmen auslösen 369
20.4 Programmfluss und Ausnahmebehandlung 371
20.4.1 Wo wird der Programmfluss nach einer Ausnahme fortgesetzt? 372
20.4.2 Die Problematik des gestörten Programmflusses 372
20.5 Übungen 374
Teil IV – Profikurs 375
21 Profikurs: Allgemeine Techniken 377
21.1 Vorzeichen und Überlauf 377
21.2 Arithmetische Konvertierungen 379
21.3 Lokale static-Variablen 379
21.4 Der ?:-Operator 380
21.5 Bit-Operatoren 380
21.5.1 Multiplikation mit 2 381
21.5.2 Division durch 2 382
21.5.3 Klein- und Großschreibung 382
21.5.4 Flags umschalten 383
21.5.5 Gerade Zahlen erkennen 383
21.6 Zeiger auf Funktionen 385
21.7 Rekursion 387
21.8 constexpr-Funktionen 389
21.9 Variablendefinition in if und switch 390
22 Profikurs: Objektorientierte Techniken 393
22.1 Zeiger auf Memberfunktionen 393
22.2 Friends 395
22.3 Überladung von Operatoren 396
22.3.1 Syntax 396
22.3.2 Überladung des Inkrement-Operators ++ 397
22.3.3 Überladung arithmetischer Operatoren +, += 398
22.3.4 Überladung der Streamoperatoren < <
22.4 Objekte vergleichen 400
22.4.1 Gleichheit 400
22.4.2 Größenvergleiche 402
22.5 Objekte kopieren 404
23 Profikurs: Gültigkeitsbereiche und Lebensdauer 409
24 Profikurs: Templates 413
24.1 Funktionen-Templates 414
24.2 Klassen-Templates 415
25 Profikurs: Reguläre Ausdrücke 419
25.1 Syntax regulärer Ausdrücke 419
25.1.1 Zeichen und Zeichenklassen 420
25.1.2 Quantifizierer 421
25.1.3 Gruppierung 422
25.1.4 Assertionen (Anker) 423
25.2 Musterabgleich mit regulären Ausdrücken 423
25.3 Suchen mit regulären Ausdrücken 424
25.4 Ersetzen mit regulären Ausdrücken 425
26 Profikurs: Lambda-Ausdrücke 427
26.1 Syntax 427
26.2 Einsatz 429
A Anhang A: Lösungen 431
B Anhang B: Die Beispiele zum Buch 451
B.1 Installation der Visual Studio Community Edition 451
B.2 Ausführung der Beispielprogramme 454
B.2.1 Ausführung mit VS Community Edition 2017 455
B.2.2 Ausführung mit beliebigen integrierten Entwicklungsumgebungen 456
B.2.3 Ausführung mit GNU-Konsolen-Compiler 457
C Anhang C: Zeichensätze 459
C.1 Der ASCII-Zeichensatz 459
C.2 Der ANSI-Zeichensatz 460
D Anhang D: Syntaxreferenz 463
D.1 Schlüsselwörter 463
D.2 Elementare Typen 464
D.3 Strings 465
D.4 Operatoren 466
D.5 Ablaufsteuerung 467
D.6 Ausnahmebehandlung 469
D.7 Aufzählungen 469
D.7.1 enum 469
D.7.2 enum class (C++11) 470
D.8 Arrays 470
D.9 Zeiger 471
D.10 Strukturen 471
D.11 Klassen 472
D.12 Vererbung 475
D.13 Namensräume 475
E Anhang E: Die Standardbibliothek 477
E.1 Die C-Standardbibliothek 477
E.2 Die C++-Standardbibliothek 478
Index 481
Leere Seite 2

Textauszug

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

Produkt-Details

• Erscheint lt. Verlag: 9.4.2018
• Verlagsort: München
• Sprache: deutsch
• Themenwelt: Informatik ► Programmiersprachen / -werkzeuge ► C / C++
• Schlagworte: C++11 • Objektorientierung • Programmiersprache • Programmierung • Standardbibliothek • Visual C++
• ISBN-10: 3-446-45388-1 / 3446453881
• ISBN-13: 978-3-446-45388-3 / 9783446453883