Embed Size (px)
Citation preview
Auf einen Blick
Über dieses Buch............................................................. 171 OOP-Paradigma und C++ ................................................ 192 Erste Schritte mit C++ ..................................................... 393 OOP-unabhängige Sprachelemente von C++ .................. 694 Klassen ............................................................................ 975 Verwenden von Objekten................................................ 1176 Dynamische Speicherverwaltung..................................... 1437 Mehr über Klassen .......................................................... 1758 Überladen von Operatoren.............................................. 2019 Typumwandlungen .......................................................... 235
10 Abgeleitete Klassen......................................................... 25111 Polymorphie .................................................................... 28312 Mehrfachvererbung ......................................................... 32113 Namensbereiche.............................................................. 34314 Funktions-Templates....................................................... 36515 Klassen-Templates........................................................... 38916 Exception-Handling......................................................... 41717 Mehr über Exceptions ..................................................... 44518 Die Standard-Klasse string .............................................. 46319 Type-Casts und Typinformationen................................... 48520 Streams für die Ein- und Ausgabe .................................. 50321 Datei- und String-Streams............................................... 541
Anhang ............................................................................ 569C-Tutorial ........................................................................ 571Die String-Bibliothek....................................................... 611I/O-Stream-Bibliothek..................................................... 627Die Container-Bibliothek................................................. 655Die Algorithmen-Bibliothek ............................................ 699Die numerische Bibliothek .............................................. 717Komplexe Zahlen............................................................. 719Vektoren.......................................................................... 729Numerische Grenzwerte .................................................. 747Operatorenübersicht und Vorrangtabelle........................ 755Schlüsselwörter in C++.................................................... 759Literatur........................................................................... 761Die CD zum Buch ............................................................ 763Index ............................................................................... 765
I
1.1 Konzepte der OOP ................................................................................ 20
1.2 Datenabstraktion .................................................................................. 22
1.3 Datenkapselung .................................................................................... 24
1.4 Vererbung ............................................................................................. 26
1.5 Entwicklung von C++ ............................................................................ 28
1.6 Eigenschaften von C++ .......................................................................... 30
1.7 Entwicklung eines C++-Programms ...................................................... 32
1.8 Übungen ............................................................................................... 34
1.9 Lösungen .............................................................................................. 36
1.10 Lösungen (Fortsetzung) ........................................................................ 38
2.1 Kommentare ......................................................................................... 40
2.2 Klassen für die Standard-Ein- und Ausgabe .......................................... 42
2.3 Ausgaben mit cout ................................................................................ 44
2.4 Eingaben mit cin ................................................................................... 46
2.5 Einlesen von Zeichen und Strings ......................................................... 48
2.6 Plazierung von Deklarationen ............................................................... 50
2.7 Prototyp von Funktionen ...................................................................... 52
2.8 Inline-Funktionen ................................................................................. 54
2.9 Aufzählungen ........................................................................................ 56
2.10 Der Datentyp bool ................................................................................ 58
2.11 Übungen ............................................................................................... 60
2.12 Lösungen .............................................................................................. 63
2.13 Lösungen (Fortsetzung) ........................................................................ 64
2.14 Lösungen (Fortsetzung) ........................................................................ 66
2.15 Lösungen (Fortsetzung) ........................................................................ 68
nhalt
Über dieses Buch 17
1 OOP-Paradigma und C++ 19
2 Erste Schritte mit C++ 39
Inhalt 7
8
3.1 Default-Argumente ............................................................................... 70
3.2 Überladen von Funktionen ................................................................... 72
3.3 const-Deklarationen ............................................................................. 74
3.4 const-Deklaration von Zeigern ............................................................. 76
3.5 const-Deklaration von Parametern ....................................................... 78
3.6 Definition von Referenzen .................................................................... 80
3.7 Referenzen als Parameter ..................................................................... 82
3.8 Referenzen als Ergebnistyp ................................................................... 84
3.9 Übungen ............................................................................................... 86
3.10 Übungen ............................................................................................... 88
3.11 Lösungen .............................................................................................. 90
3.12 Lösungen (Fortsetzung) ........................................................................ 92
3.13 Lösungen (Fortsetzung) ........................................................................ 94
3.14 Lösungen (Fortsetzung) ........................................................................ 96
4.1 Definition von Klassen .......................................................................... 98
4.2 Definition von Elementfunktionen ....................................................... 100
4.3 Objekte (1) ........................................................................................... 102
4.4 Objekte (2) ........................................................................................... 104
4.5 Konstruktoren (1) ................................................................................. 106
4.6 Konstruktoren (2) ................................................................................. 108
4.7 Destruktoren ........................................................................................ 110
4.8 Übungen ............................................................................................... 112
4.9 Lösungen .............................................................................................. 114
4.10 Lösungen (Fortsetzung) ........................................................................ 116
5.1 Inline-Methoden .................................................................................. 118
5.2 Zugriffsmethoden ................................................................................. 120
5.3 const-Objekte ....................................................................................... 122
5.4 Der Zeiger this ...................................................................................... 124
5.5 Objekte als Argumente (1) ................................................................... 126
5.6 Objekte als Argumente (2) ................................................................... 128
5.7 Objekte als Return-Wert ...................................................................... 130
3 OOP-unabhängige Sprachelemente von C++ 69
4 Klassen 97
5 Verwenden von Objekten 117
Inhalt
5.8 Klassen-Arrays ...................................................................................... 132
5.9 Übungen ............................................................................................... 134
5.10 Lösungen .............................................................................................. 136
5.11 Lösungen (Fortsetzung) ........................................................................ 138
5.12 Lösungen (Fortsetzung) ........................................................................ 140
6.1 Die neuen Operatoren new und delete ................................................. 144
6.2 Speicherreservierung für Standard-Datentypen .................................... 146
6.3 Speicher freigeben ................................................................................ 148
6.4 Speicherverwaltung für Klassen ............................................................ 150
6.5 Fehlerbehandlung ................................................................................. 152
6.6 Dynamische Elemente (1) ..................................................................... 154
6.7 Dynamische Elemente (2) ..................................................................... 156
6.8 Dynamische Elemente (3) ..................................................................... 158
6.9 Kopierkonstruktor ................................................................................. 160
6.10 Zuweisungsoperator ............................................................................. 162
6.11 Übungen ............................................................................................... 164
6.12 Übungen ............................................................................................... 166
6.13 Lösungen .............................................................................................. 168
6.14 Lösungen (Fortsetzung) ........................................................................ 170
6.15 Lösungen (Fortsetzung) ........................................................................ 172
6.16 Lösungen (Fortsetzung) ........................................................................ 174
7.1 Objekte als Klassenelemente ................................................................ 176
7.2 Initialisierung von Teilobjekten ............................................................. 178
7.3 Konstante Datenelemente .................................................................... 180
7.4 Statische Datenelemente ...................................................................... 182
7.5 Statische Methoden .............................................................................. 184
7.6 friend-Funktionen ................................................................................. 186
7.7 friend-Klassen ....................................................................................... 188
7.8 Elementzeiger ....................................................................................... 190
7.9 Übungen ............................................................................................... 192
7.10 Lösungen .............................................................................................. 194
7.11 Lösungen (Fortsetzung) ........................................................................ 196
7.12 Lösungen (Fortsetzung) ........................................................................ 198
6 Dynamische Speicherverwaltung 143
7 Mehr über Klassen 175
Inhalt 9
10
8.1 Grundlagen ........................................................................................... 202
8.2 Operatorfunktionen .............................................................................. 204
8.3 Operator-Überladung mit friend-Funktionen ....................................... 206
8.4 Operator-Überladung mit Elementfunktionen ...................................... 208
8.5 Überladen der Shift-Operatoren ........................................................... 210
8.6 Operatoren für Arrays überladen .......................................................... 212
8.7 Überladen von new und delete ............................................................ 214
8.8 Globale Überladung .............................................................................. 216
8.9 Klassenspezifische Überladung ............................................................. 218
8.10 Übungen ............................................................................................... 220
8.11 Übungen ............................................................................................... 222
8.12 Lösungen .............................................................................................. 224
8.13 Lösungen (Fortsetzung) ........................................................................ 226
8.14 Lösungen (Fortsetzung) ........................................................................ 228
8.15 Lösungen (Fortsetzung) ........................................................................ 230
8.16 Lösungen (Fortsetzung) ........................................................................ 232
9.1 Typumwandlungen ............................................................................... 236
9.2 Konvertierungskonstruktoren ............................................................... 238
9.3 Konvertierungsfunktionen .................................................................... 240
9.4 Mehrdeutigkeiten ................................................................................. 242
9.5 Übungen ............................................................................................... 244
9.6 Lösungen .............................................................................................. 246
9.7 Lösungen (Fortsetzung) ........................................................................ 248
9.8 Lösungen (Fortsetzung) ........................................................................ 250
10.1 Vererbung ............................................................................................. 252
10.2 Definition abgeleiteter Klassen (1) ....................................................... 254
10.3 Definition abgeleiteter Klassen (2) ....................................................... 256
10.4 Methoden abgeleiteter Klassen ............................................................ 258
10.5 Redefinition von Klassenelementen ..................................................... 260
10.6 Konstruktoren ...................................................................................... 262
8 Überladen von Operatoren 201
9 Typumwandlungen 235
10 Abgeleitete Klassen 251
Inhalt
10.7 Basisinitialisierer ................................................................................... 264
10.8 Verwendung abgeleiteter Klassen ......................................................... 266
10.9 protected-Elemente .............................................................................. 268
10.10 protected- und private-Vererbung ........................................................ 270
10.11 Übungen ............................................................................................... 272
10.12 Lösungen .............................................................................................. 274
10.13 Lösungen (Fortsetzung) ........................................................................ 276
10.14 Lösungen (Fortsetzung) ........................................................................ 278
10.15 Lösungen (Fortsetzung) ........................................................................ 280
11.1 Konvertierung abgeleiteter Klassen (1) ................................................. 284
11.2 Konvertierung abgeleiteter Klassen (2) ................................................. 286
11.3 Virtuelle Funktionen (1) ........................................................................ 288
11.4 Virtuelle Funktionen (2) ........................................................................ 290
11.5 Virtuelle Funktionen (3) ........................................................................ 292
11.6 Statische und dynamische Bindung ...................................................... 294
11.7 Implementierung dynamischer Bindung ............................................... 296
11.8 Virtuelle Destruktoren .......................................................................... 298
11.9 Rein virtuelle Funktionen ...................................................................... 300
11.10 Abstrakte Klassen ................................................................................. 302
11.11 Vererbung dynamischer Komponenten ................................................. 304
11.12 Virtuelle Operatorfunktionen ................................................................ 306
11.13 Übungen ............................................................................................... 308
11.14 Übungen ............................................................................................... 310
11.15 Lösungen .............................................................................................. 312
11.16 Lösungen (Fortsetzung) ........................................................................ 314
11.17 Lösungen (Fortsetzung) ........................................................................ 316
11.18 Lösungen (Fortsetzung) ........................................................................ 318
12.1 Definition mehrfacher Ableitungen ....................................................... 322
12.2 Mehrdeutigkeiten ................................................................................. 324
12.3 Virtuelle Basisklassen ............................................................................ 326
12.4 Initialisierung ........................................................................................ 328
12.5 Übungen ............................................................................................... 330
12.6 Übungen ............................................................................................... 332
11 Polymorphie 283
12 Mehrfachvererbung 321
Inhalt 11
12
12.7 Lösungen .............................................................................................. 334
12.8 Lösungen (Fortsetzung) ........................................................................ 336
12.9 Lösungen (Fortsetzung) ........................................................................ 338
12.10 Lösungen (Fortsetzung) ........................................................................ 340
13.1 Namensbereiche ................................................................................... 344
13.2 using-Deklaration und -Direktive ......................................................... 346
13.3 Verschachteln von Namensbereichen ................................................... 348
13.4 Aliasnamen, Anonyme Namensbereiche ............................................... 350
13.5 Verwenden von C-Modulen ................................................................. 352
13.6 Übungen ............................................................................................... 354
13.7 Übungen ............................................................................................... 356
13.8 Lösungen .............................................................................................. 358
13.9 Lösungen (Fortsetzung) ........................................................................ 360
13.10 Lösungen (Fortsetzung) ........................................................................ 362
14.1 Konzept ................................................................................................ 366
14.2 Definition von Funktions-Templates .................................................... 368
14.3 Generierung von Template-Funktionen ................................................ 370
14.4 Typanpassungen ................................................................................... 372
14.5 Spezialisierungen von Template-Funktionen ........................................ 374
14.6 Spezialisierung (ANSI) .......................................................................... 376
14.7 Explizite Argumente für Funktions-Templates ...................................... 378
14.8 Übungen ............................................................................................... 380
14.9 Lösungen .............................................................................................. 382
14.10 Lösungen (Fortsetzung) ........................................................................ 384
14.11 Lösungen (Fortsetzung) ........................................................................ 386
15.1 Konzept ................................................................................................ 390
15.2 Definition von Klassen-Templates ........................................................ 392
15.3 Methoden von Klassen-Templates ....................................................... 394
15.4 Generierung von Template-Klassen ...................................................... 396
13 Namensbereiche 343
14 Funktions-Templates 365
15 Klassen-Templates 389
Inhalt
15.5 Template-Parameter .............................................................................. 398
15.6 Template-Argumente ............................................................................ 400
15.7 Default-Argumente von Templates ....................................................... 402
15.8 Explizite Instantiierung ......................................................................... 404
15.9 Übungen ............................................................................................... 406
15.10 Übungen ............................................................................................... 408
15.11 Lösungen .............................................................................................. 410
15.12 Lösungen (Fortsetzung) ........................................................................ 412
15.13 Lösungen (Fortsetzung) ........................................................................ 414
16.1 Konzept des Exception-Handlings ........................................................ 418
16.2 Auslösen von Exceptions ...................................................................... 420
16.3 Auffangen von Exceptions (1) ............................................................... 422
16.4 Auffangen von Exceptions (2) ............................................................... 424
16.5 Handler-Suche ...................................................................................... 426
16.6 Verschachteln von try-Blöcken .............................................................. 428
16.7 Fehlerklassen ........................................................................................ 430
16.8 Klassenspezifische Exceptions .............................................................. 432
16.9 Übungen ............................................................................................... 434
16.10 Übungen ............................................................................................... 436
16.11 Lösungen .............................................................................................. 438
16.12 Lösungen (Fortsetzung) ........................................................................ 440
17.1 Fehlerklassen-Hierarchien ..................................................................... 446
17.2 Verwendung von Standard-Exceptions ................................................. 448
17.3 Exception-Spezifikation ........................................................................ 450
17.4 Unerwartete Exceptions ........................................................................ 452
17.5 Die Funktion set_terminate() ................................................................ 454
17.6 Exception-Spezifikation virtueller Funktionen ...................................... 456
17.7 Übungen ............................................................................................... 458
17.8 Lösung .................................................................................................. 460
17.9 Lösung (Fortsetzung) ............................................................................ 462
16 Exception-Handling 417
17 Mehr über Exceptions 445
Inhalt 13
14
18.1 Die String-Bibliothek ............................................................................ 464
18.2 Konstruktoren der Klasse string ........................................................... 466
18.3 Länge und Kapazität von Strings .......................................................... 468
18.4 Konvertierung, Exceptions .................................................................... 470
18.5 Zugriff auf einzelne Zeichen .................................................................. 472
18.6 Einfügen und Löschen in Strings .......................................................... 474
18.7 Suchen und Ersetzen in Strings ............................................................ 476
18.8 Übungen ............................................................................................... 478
18.9 Übungen ............................................................................................... 480
18.10 Lösung .................................................................................................. 482
18.11 Lösung (Fortsetzung) ............................................................................ 484
19.1 Typumwandlungen in Klassenhierarchien ............................................. 486
19.2 Dynamischer Cast (1) ........................................................................... 488
19.3 Dynamischer Cast (2) ........................................................................... 490
19.4 Statischer Cast ...................................................................................... 492
19.5 reinterpret-Cast, const-Cast ................................................................. 494
19.6 Typinformationen ................................................................................. 496
19.7 Übungen ............................................................................................... 498
19.8 Lösung .................................................................................................. 500
20.1 Die I/O-Klassenhierarchie ..................................................................... 504
20.2 Die Klasse ios ....................................................................................... 506
20.3 Die Klasse ostream ............................................................................... 508
20.4 Die Klasse istream ................................................................................ 510
20.5 Unformatierte Eingabe ......................................................................... 512
20.6 Unformatierte Ausgabe ........................................................................ 514
20.7 Status eines Streams ............................................................................ 516
20.8 Status abfragen und ändern ................................................................. 518
20.9 Format-Flags ........................................................................................ 520
20.10 Formatierung ganzer Zahlen ................................................................. 522
20.11 Formatierung von Gleitpunktzahlen ..................................................... 524
20.12 Ausgabe in Felder ................................................................................. 526
18 Die Standard-Klasse string 463
19 Type-Casts und Typinformationen 485
20 Streams für die Ein- und Ausgabe 503
Inhalt
20.13 Weitere Manipulatoren ......................................................................... 528
20.14 Selbstdefinierte Manipulatoren ............................................................ 530
20.15 Selbstdefinierte Manipulatoren mit Parametern ................................... 532
20.16 Übungen ............................................................................................... 534
20.17 Lösung .................................................................................................. 536
21.1 Die File-Stream-Klassen ........................................................................ 542
21.2 Sequenzieller Dateizugriff ..................................................................... 544
21.3 Wahlfreier Dateizugriff .......................................................................... 546
21.4 Die String-Stream-Klassen .................................................................... 548
21.5 Lesen und Schreiben von String-Streams .............................................. 550
21.6 Übungen ............................................................................................... 552
21.7 Übungen ............................................................................................... 554
21.8 Lösungen .............................................................................................. 556
21.9 Lösungen (Fortsetzung) ........................................................................ 558
21.10 Lösungen (Fortsetzung) ........................................................................ 560
21.11 Lösungen (Fortsetzung) ........................................................................ 562
21.12 Lösungen (Fortsetzung) ........................................................................ 564
21.13 Lösungen (Fortsetzung) ........................................................................ 566
21.14 Lösungen (Fortsetzung) ........................................................................ 568
C-Tutorial ............................................................................................... 571
Die String-Bibliothek ............................................................................. 611
I/O-Stream-Bibliothek ........................................................................... 627
Die Container-Bibliothek ....................................................................... 655
Die Algorithmen-Bibliothek................................................................... 699
Die numerische Bibliothek..................................................................... 717
Komplexe Zahlen ................................................................................... 719
Vektoren ................................................................................................ 729
Numerische Grenzwerte......................................................................... 747
Operatorenübersicht und Vorrangtabelle .............................................. 755
Schlüsselwörter in C++ .......................................................................... 759
Literatur ................................................................................................. 761
Die CD zum Buch................................................................................... 763
21 Datei- und String-Streams 541
Anhang 569
Index 767
Inhalt 15
Über dieses Buch
Dieses Buch wendet sich an Leser mit Grundkenntnissen in C oder C++, die die objektorien-tierte Programmierung mit C++ kennenlernen oder vertiefen möchten.
Die C++-Sprachbeschreibung basiert auf dem ANSI-Standard X3J16 des American NationalStandards Institute, der 1998 als internationaler Standard (ISO/IEC 14882) verabschiedetwurde. Die Darstellung der Sprache C++ ist damit weitgehend plattformunabhängig. DerANSI-Standard wird von allen gängigen C++-Compilern unterstützt.
Die Kapitel im Buch sind so angeordnet, dass der Leser von grundlegenden Konzepten derobjektorientierten Programmierung bis hin zur professionellen Software-Entwicklung geführtwird. Hierbei werden alle objektorientierten Sprachelemente von C++ einschließlich der C-Spracherweiterungen umfassend behandelt.
Jede Doppelseite ist wie folgt gegliedert: Auf der rechten Seite sind Konzepte und Sprachele-mente beschrieben, welche durch Grafiken und Programmbeispiele auf der linken Seite illu-striert werden. Die Programmbeispiele sind so ausgewählt, dass sie eine typische Anwendungfür das jeweilige Sprachelement zeigen. Darüber hinaus werden zahlreiche Datenstrukturenund Algorithmen implementiert, die den Leser mit einem breiten Anwendungsspektrum ver-traut machen.
Um die objektorientierte Programmierung effektiv einsetzen zu können, ist viel eigene Erfah-rung durch selbständiges Entwickeln von Programmen notwendig. Am Ende jedes Kapitelssind deshalb Übungen formuliert, zu denen auf den folgenden Seiten Musterlösungen ange-geben sind. Der Leser kann damit seine erreichten Fähigkeiten testen und das Verständnis ver-tiefen.
Der Anhang beginnt mit einem C-Tutorial. Es ermöglicht dem Leser, seine C-Kenntnisse auf-zufrischen und beim Arbeiten mit C++ schnell das eine oder andere Detail der Sprache Cnachzuschlagen. Außerdem sind im Anhang die wichtigsten Klassen der Standard Template Li-brary (STL) sowie nützliche Tabellen zusammengestellt. Das Buch soll damit auch den geübtenC++-Programmierer begleiten, der ein gut strukturiertes und verständliches Nachschlagewerkzur Hand haben will.
Auf der CD zum Buch befinden sich alle Musterlösungen zu den Übungen. Damit der Leserseine Programme direkt testen kann, sind außerdem der Compiler GNU C++ für Windowsund der Borland C++ Compiler beigefügt. Hinweise zur Installation der Compiler befindensich im Anhang »Die CD zum Buch«.
Wir bedanken uns bei allen, die bei der Entstehung des Buches mitgewirkt haben, auch beiunseren Kindern, die uns oft genug in Ruhe gelassen haben, und wünschen Ihnen, lieber Le-ser: Viel Spaß bei der objektorientierten Programmierung mit C++!
Ulla Kirch-Prinz Peter Prinz
Über dieses Buch 17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Kapitel 1: OOP-Paradigma und C++
Dieses Kapitel beschreibt zunächst die allgemeinen Konzepte der objekt-orientierten Programmierung. Anschließend werden die charakteristischenEigenschaften von C++ und seine historische Entwicklung vorgestellt.
17
18
19
20
21
20
1.1 Konzepte der OOP
Klassisches prozedurales Konzept
Objektorientiertes Konzept
Daten Daten
Funktion Funktion Funktion
Objekt 1 Objekt 2
Eigenschaften
__________
Methoden
Eigenschaften
__________
Methoden
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
OOP
Die objektorientierte Programmierung (kurz OOP) ist eine grundsätzlich neue Art der Soft-ware-Entwicklung. Sie ist geeignet, auf hohem Abstraktionsniveau die Komplexität großerProjekte zu bewältigen.
Die OOP stellt die Objekte in den Mittelpunkt, also die Dinge, um die es bei der jeweiligenProblemstellung geht. Beispielsweise arbeitet ein Programm zur Lagerverwaltung mit Artikeln,Bestellungen, Auslieferungen, Rechnungen usw. Ein Objekt, das im Programm einen Artikelrepräsentiert, besitzt dann alle Eigenschaften und Fähigkeiten, die für die Handhabung von Ar-tikeln im Programm wichtig sind.
Für die traditionelle, prozedurale Programmierung ist es charakteristisch, dass Daten undFunktionen, die diese Daten verarbeiten, keine Einheit bilden. Daraus resultiert eine größereFehleranfälligkeit, z.B. durch fehlerhafte Zugriffe auf die Daten oder Verwendung nichtinitia-lisierter Daten. Hinzu kommt ein hoher Wartungsaufwand, etwa wenn die Daten an neue An-forderungen angepaßt werden müssen.
Dagegen bilden die Objekte in der OOP eine Einheit aus Daten (= Eigenschaften) und Funk-tionen (= Methoden, Fähigkeiten). Für die Software-Qualität ergeben sich daraus entschei-dende Vorteile:
� Höhere Zuverlässigkeit
� Geringerer Wartungsaufwand
� Bessere Wiederverwendbarkeit
Merkmale der OOP
Eine objektorientierte Programmiersprache ist dadurch gekennzeichnet, dass sie Sprachele-mente zur Unterstützung der folgenden OOP-Paradigmen besitzt:
Datenabstraktion
Es können abstrakte Datentypen (Klassen) definiert werden, welche die Eigenschaften und Fä-higkeiten von Objekten beschreiben.
Datenkapselung
Elemente eines Objekts können vor unkontrolliertem Zugriff von außen geschützt werden.Für die Kommunikation mit der Außenwelt, d.h. mit anderen Objekten, besitzt jedes Objekteine »öffentliche Schnittstelle«.
Vererbung
Neue Objekte lassen sich aus schon vorhandenen Objekten ableiten. Sie »erben« die vorhan-denen Eigenschaften und Fähigkeiten, die ergänzt und verändert werden können.
Polymorphie
Die Vererbung erlaubt das Arbeiten mit einer ganzen Familie gleichartiger Objekte. »Polymor-phie« (griech. Vielgestaltigkeit) bezeichnet hier die Möglichkeit, dass der Aufruf einer Me-thode zur Laufzeit verschiedene Wirkungen haben kann, je nach dem genauen Typ des Ob-jekts.
OOP-Paradigma und C++ 21
22
1.2 Datenabstraktion
Klassen und Objekte
reale Welt
Flugzeuge
Datenabstraktion
KlasseEigenschaften:
BaujahrReichweiteStatus. . .
________________
Methoden:starten, fliegen,landen, . . .
Instantiierung
Objekte
Flugzeug 1
Baujahr = 2001 Reichweite = 7000 Status = parken . . .__________________
Methoden
Flugzeug 2
Baujahr = 1998 Reichweite = 12000 Status = landen . . .__________________
Methoden
. . .
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Abstraktion
Eine Möglichkeit, um komplexe Sachverhalte zu handhaben, ist die Abstraktion. Eigenschaf-ten und Vorgänge werden auf das Wesentliche reduziert und mit einem Oberbegriff versehen.Ein Flugzeug ist ein Beispiel für eine in verschiedener Hinsicht durchgeführte Abstraktion:
� Ein Flugzeug ist die Zusammenfassung verschiedener Einzelteile wie Motor, Tragflächen,Räder usw. Darüber hinaus besitzt jedes Flugzeug Eigenschaften wie Reichweite, Höchst-geschwindigkeit und Transportkapazität. Auch der aktuelle Status, wie z.B. »Das Flugzeugist geparkt«, gehört zu den Eigenschaften.
� Die Fähigkeiten eines Flugzeugs bestehen natürlich in erster Linie aus Starten, Fliegen undLanden. Außerdem muss ein Flugzeug getankt, beladen, entladen und gewartet werden.
� Ein Flugzeug ist auch der Oberbegriff für verschiedene Flugzeugtypen wie Segelflugzeug,Motorflugzeug, Düsenjäger, Transportflugzeug, Passagierflugzeug usw.
Sofern die Details eines Flugzeugs bzw. die Unterschiede zwischen verschiedenen Flugzeug-typen nicht interessieren, wird einfach der abstrakte Begriff »Flugzeug« verwendet. Damitkönnen die für ein Flugzeug typischen Aktionen in den Vordergrund rücken: Ein Flugzeugkann gebaut, gewartet oder demontiert werden. Ein Flugzeug startet, fliegt, z.B. von Mün-chen nach Köln, oder landet.
Klassen und Objekte
Eine objektorientierte Programmiersprache unterstützt die Datenabstraktion, indem sie Sprach-elemente zur Definition von Klassen zur Verfügung stellt. Klassen beschreiben die Eigenschaftenvon Objekten und legen mit den Methoden fest, welche Aktionen die Objekte ausführen kön-nen. Ein konkretes Objekt wird nach dem »Muster« der Klasse erzeugt und bildet eine Instanzder Klasse.
Das nebenstehende Beispiel zeigt dies anhand des Begriffs »Flugzeug«: Die Klasse Flugzeugbeschreibt die verschiedenen Aspekte eines Flugzeugs, welche im Programm von Interessesind. Immer dann, wenn im Programm ein konkretes Flugzeug benötigt wird, wird ein Objektnach dem Muster der Klasse Flugzeug instantiiert.
Klassen können auch für abstrakte Objekte und Vorgänge definiert werden, wie z.B. »Auf-trag«, »Qualität« oder »Volleyballspiel«.
In C++ sind Klassen spezielle, strukturierte Datentypen, die neben Daten (= Eigenschaften)auch Funktionen (= Methoden) enthalten, z.B. zur Manipulation dieser Daten. Die zu einerKlasse gehörenden Funktionen heißen Elementfunktionen. Ein Objekt ist nichts anderes alseine Variable vom Typ einer bestimmten Klasse.
OOP-Paradigma und C++ 23
24
1.3 Datenkapselung
Kontrollierter Zugriff auf die Daten
�����������
���� � ���� �
���� � ���� �
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Datenkapselung
Ein Anwendungsprogramm arbeitet mit Objekten, indem es die Methoden aus der öffentli-chen Schnittstelle der entsprechenden Klasse aufruft.
Die interne Darstellung der Daten braucht das Anwendungsprogramm nicht zu kennen. BeiBedarf kann die interne Darstellung der Daten auch geändert werden, ohne dass die Verwen-dung der Klasse davon betroffen ist, vorausgesetzt, die Schnittstellen der Methoden bleibendieselben.
Beispiel: Für Objekte einer Klasse, die ein Datum enthalten, soll der Wertebereich des Da-tums vergrößert werden. Die notwendige Änderung der internen Darstellung unddie entsprechenden Anpassungen der Methoden kann so vorgenommen werden,dass sie nur die Klasse selbst betreffen.
Der Zugriff auf die Daten eines Objekts erfolgt im allgemeinen nicht direkt, sondern in kon-trollierter Weise über die Methoden. Da eine Klasse auch die Erzeugung und die Zerstörungeines Objekts festlegt, kann so folgendes garantiert werden:
� Nach dem Erzeugen eines Objekts sind die Daten stets mit vernünftigen Anfangswertenversehen.
� Fehlerhafte oder unzulässige Zugriffe werden frühzeitig durch die Methoden abgefangen.
� Sofern ein Objekt im weiteren Programmverlauf nicht mehr benötigt wird, kann es in ge-ordneter Weise »zerstört« werden. Beispielsweise kann es nötig sein, geöffnete Dateien zuschließen, dynamisch reservierten Speicher wieder freizugeben oder Zeiger auf einen Pseu-dowert zurückzusetzen.
Ein Objekt verwaltet sich also mit Hilfe seiner Methoden selbst und kapselt sein »Innenleben«von der Außenwelt ab. Dadurch ist jederzeit die Integrität der Daten sichergestellt.
Zur Unterstützung der Datenkapselung bieten objektorientierte ProgrammiersprachenSprachelemente, die den Zugriff auf Daten und Methoden einschränken bzw. sperren können.Hierzu gehört die Möglichkeit, die Elemente einer Klasse als private oder public zu deklarieren:
� Auf private-Elemente können nur die Methoden der Klasse zugreifen. Sie sind damit vordem direkten, unkontrollierten Zugriff von außen geschützt.
� Die public-Elemente bilden die öffentliche Schnittstelle. Auf sie kann uneingeschränkt zu-gegriffen werden.
OOP-Paradigma und C++ 25
26
1.4 Vererbung
Basisklasse und abgeleitete Klassen
����������� Flugzeug
������� ���
�������� ��� ���
��������
��� � ������ ���
������������������ �� ��
��������
��� ����������
���� � � ����
������������������ �� ��
��������
� ���� ��������
�������� ���������
���������� ������Transportflugzeug
���������� ������Passagierflugzeug
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Vererbung
Aus einer bereits existierenden Klasse kann eine neue Klasse gebildet werden, die weitereEigenschaften und Fähigkeiten besitzt. Diese abgeleitete Klasse »erbt« dabei die Daten undMethoden der sogenannten Basisklasse.
Benötigt beispielsweise eine Anwendung, die mit einer Klasse Flugzeug arbeitet, die Unter-scheidung von Transport- und Passagierflugzeugen, so wird man entsprechende Klassen vonder Basisklasse Flugzeug ableiten. In den Programmteilen, wo es auf diese Unterscheidungnicht ankommt, können Transport- oder Passagierflugzeuge wie normale Flugzeuge behandeltwerden.
Objekte von abgeleiteten Klassen sind stets »spezielle Objekte« vom Typ der Basisklasse. DieVererbung ermöglicht es so, hierarchische Beziehungen zwischen Objekten auszudrücken.
Durch Vererbung werden ganze »Familien« von Klassen gebildet. Man spricht auch von»Klassenhierarchien«. C++ besitzt sehr effiziente Mechanismen zur Bildung von Klassenhierar-chien.
Wiederverwendbarkeit
Die Vererbung ist ein wichtiges Mittel, um bereits entwickelten Programmcode wiederver-wendbar zu machen.
Bei der Bildung abgeleiteter Klassen muss nur die öffentliche Schnittstelle der Basisklasse be-kannt sein. Die interne Darstellung von Daten sowie die Definition von Elementfunktionenbraucht der Programmierer nicht zu kennen. Vorhandene Klassen können daher als leicht er-weiterbare »Bausteine« in einem neuen Programm eingesetzt werden. Zahlreiche Klassen-bibliotheken unterstützen dieses Konzept.
Polymorphie
In der OOP bezeichnet Polymorphie (griech. Vielgestaltigkeit) die Möglichkeit, dass der Aufrufeiner Methode zur Laufzeit verschiedene Wirkungen haben kann. Dies hat folgenden Hinter-grund:
Eine abgeleitete Klasse muss eine Methode der Basisklasse nicht unverändert übernehmen.Für die Objekte der abgeleiteten Klasse kann die Methode neu definiert werden: Sie wird denneuen Eigenschaften der Klasse angepaßt. Innerhalb einer Klassenhierarchie kann daher derName einer Methode für verschiedene Implementierungen stehen.
Beispielsweise wird es in einer Klassenhierarchie von geometrischen Figuren immer wiedereine Methode geben, die eine konkrete geometrische Figur zeichnet, z.B. eine Methodedraw(). Wird nun für ein Objekt draw() aufgerufen, so entscheidet der Typ des Objekts,welche konkrete Methode zur Ausführung kommt.
Bei der Erstellung des Programms ist der genaue Typ des Objekts oft noch unbekannt. Dannwird erst zur Laufzeit entschieden, welche Methode zur Ausführung kommt.
OOP-Paradigma und C++ 27
28
1.5 Entwicklung von C++
C
Algol, Ada, ...(Erweiterungen)
Smalltalk, Simula,Eiffel (OOP-Unterstützung)
1980
C mit Klassen
1983
C++
1989
Bildung desX3J16-ANSI-
Kommitees
1990
AT&TC++ Release 2.0
1996
Draft ProposalX3J16/96-0225
1991
AT&TC++ Release 3.0
1998
ISO-StandardISO/IEC 14882
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Ursprung
C++ wurde von Bjarne Stroustrup in den Bell-Laboratorien (Murray Hill, USA) entwickelt, umSimulationsprojekte mit minimalem Speicherplatz und Zeitbedarf zu realisieren. Frühe Versio-nen der Sprache, die zunächst als »C mit Klassen« bezeichnet wurde, gibt es seit 1980. DerName C++ wurde 1983 von Rick Mascitti geprägt. Er weist darauf hin, dass die Programmier-sprache C++ evolutionär aus der Programmiersprache C entstanden ist: ++ ist der Inkrement-operator von C.
Einflüsse
C wurde wegen ihrer Effizienz und Portabilität als Grundlage von C++ gewählt. Bei der Wei-terentwicklung von C++ wurde stets auf die Kompatibilität zu C geachtet. Somit bleibt dieumfangreiche, unter C entwickelte Software auch in C++-Programmen einsatzfähig. Dazu ge-hören beispielsweise Tools und Bibliotheken für Grafik-Systeme oder Datenbankanwendun-gen.
Bei der Realisierung objektorientierter Konzepte hatte die Programmiersprache SIMULA67maßgeblichen Einfluß, insbesondere bei der Bildung von Klassen, der Vererbung und demEntwurf virtueller Funktionen. Das Überladen von Operatoren und die Möglichkeit, Deklara-tionen im Programmtext frei plazieren zu können, wurde der Programmiersprache ALGOL68entlehnt. Die Programmiersprachen Ada und Clu haben die Entwicklung von Templates unddie Ausnahmebehandlung beeinflußt.
Schließlich gehen viele Entwicklungen aus den Jahren 1987 bis 1991 auf die direkten Erfah-rungen und Probleme von C++-Programmierern zurück. Hierzu gehören beispielsweise dieMehrfachvererbung, das Konzept der rein virtuellen Funktionen und die Nutzung gemeinsa-mer Speicherbereiche für Objekte.
Standardisierung
Parallel zu diesen Entwicklungen unterstützte die Firma AT&T frühzeitig die Etablierung einesC++-Standards. Hierbei ging es darum, dass möglichst viele Compiler-Bauer und Software-Entwickler sich auf eine einheitliche Sprachbeschreibung einigten, um die Bildung von Dia-lekten und »Sprachverwirrungen« zu vermeiden.
Im Jahr 1989 konnte auf Initiative von Hewlett-Packard ein ANSI-Kommitee (American Na-tional Standards Institute) gebildet werden, das verschiedene Entwürfe (engl. Draft ProposalX3J16) für einen Standard geschaffen hat. Dieser Standard wurde 1998 als ISO-Standard (In-ternational Standards Organization, ISO/IEC 14882) verabschiedet.
OOP-Paradigma und C++ 29
30
1.6 Eigenschaften von C++
Die Hybrid-Sprache C++
��� ������������� ���� ����
��������������� ���� ����� ��� ��� ���� ����� ��������� � � �
���� ��� ��!����
"���� #�� $������ %� � ��� ���&�� ��� � � �
���� � � ����&��� � ���� �� �� '����� ��������� ���� ��������� �� � � �
�
�� ��� �� ���
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
C als Teilmenge von C++
C++ ist keine rein objektorientierte Sprache, wie z.B. Smalltalk oder Eiffel. Bei letzteren wur-den die objektorientierten Paradigmen ohne Wenn und Aber realisiert, wobei allerdings lang-sameres Laufzeitverhalten in Kauf genommen wurde. C++ ist eine Hybrid (griech. »Misch«)-Sprache: Sie enthält die Programmiersprache C als Teilmenge. Damit hat man zunächst in C++alle Möglichkeiten, die auch C bietet, wie z.B.:
� maschinennahes Programmieren
� Entwickeln von portablen Programmen
� strukturiertes und modulares Programmieren
Darüber hinaus ergeben sich weitere entscheidende Vorteile:
� Die umfangreiche Software, die in C entwickelt worden ist, kann unverändert genutzt wer-den.
� C-Programmierer brauchen keine komplett neue Sprache zu lernen. Sie haben sich ledig-lich mit den Erweiterungen von C und den Neuerungen bzgl. der objektorientierten Pro-grammierung auseinanderzusetzen.
Erweiterung von C
Die sprachlichen Möglichkeiten von C wurden innerhalb von C++ erweitert, indem Sprachele-mente zur Bildung von
� Inline-Funktionen
� Default-Argumenten
� Referenztypen
� Überladung von Funktionen und Operatoren
� Templates (Schablonen für die Definition von Funktionen und Klassen)
� Exception-Handling (Ausnahmebehandlung)
zur Verfügung gestellt wurden. Auch wenn diese Sprachelemente noch keinen Bezug zur OOPhaben, sind sie doch wesentlich für die effiziente Realisierung von C++ als OOP-Sprache.
OOP-Unterstützung
C++ unterstützt die Konzepte der objektorientierten Programmierung durch die Möglichkei-ten:
� Klassen zu bilden
� den Zugriff auf Daten und Elementfunktionen durch public-, private- oder protec-ted-Spezifikationen zu steuern
� Klassen (auch mehrfach) zu vererben
� Elementfunktionen als virtuell zu deklarieren und so polymorphe Klassen zu bilden
OOP-Paradigma und C++ 31
32
1.7 Entwicklung eines C++-Programms
Der Weg zum ausführbaren Programm
Editor
Quelldatei Header-Dateien Standard-Header-Dateien
Compiler
Objektdatei
evtl. weitereObjektdateien
Linker Standard-Bibliothek
evtl. weitereBibliotheken
ausf hrba reDatei
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Zur Erstellung und Übersetzung eines C++-Programms sind grundsätzlich die gleichen Schrittewie in C notwendig:
1. Das Programm wird mit einem Editor erstellt.
2. Das Programm wird kompiliert, d.h. in die Maschinensprache des Rechners übersetzt.
3. Der Linker erzeugt schließlich die ausführbare Datei.
Editor
Mit einem Editor werden die Textdateien erstellt, die den C++-Code enthalten. Dabei sindzwei Arten von Dateien zu unterscheiden:
� QuelldateienQuelldateien, auch Source-Dateien genannt, enthalten die Definitionen von globalen Va-riablen und Funktionen.
Jedes C++-Programm besteht aus mindestens einer Quelldatei.
� Header-DateienHeader-Dateien, auch Include-Dateien genannt, verwalten zentral die Informationen, diein verschiedenen Quelldateien gebraucht werden. Dazu gehören:
� Typdefinitionen, z.B. Klassendefinitionen
� Deklarationen von globalen Variablen und Funktionen
� Definition von Makros und Inline-Funktionen
Bei der Benennung der Dateien muss die richtige Endung (engl. Extension) verwendet wer-den. Diese variieren jedoch von Compiler zu Compiler: Für Quelldateien sind die gebräuch-lichsten Endungen .cpp und .cc. Die Namen von Header-Dateien enden entweder wie in Cmit .h oder sie haben keine Endung. Aber auch Endungen wie .hpp können vorkommen. DieHeader-Dateien der C-Standard-Bibliothek können natürlich weiter benutzt werden. Mehrdazu in Kapitel 13, »Namensbereiche«.
Compiler
Eine Übersetzungseinheit besteht aus einer Quelldatei und den inkludierten Header-Dateien.Der Compiler erzeugt aus jeder Übersetzungseinheit eine Objektdatei (auch Modul genannt),die den Maschinen-Code enthält.
Neben den Compilern, die direkt den Maschinen-Code erzeugen, gibt es auch C++- nachC-Übersetzungsprogramme, sogenannte »C-Front-Compiler«. Diese übersetzen ein C++-Programm in ein C-Programm. Erst anschließend wird die Objektdatei mit einem Standard-C-Compiler erzeugt.
Linker
Der Linker bindet die Objektdateien zu einer ausführbaren Datei. Diese enthält neben denselbsterzeugten Objektdateien auch den Startup-Code und die Module mit den verwendetenFunktionen und Klassen der Standardbibliothek.
OOP-Paradigma und C++ 33
34
1.8 Übungen
Definition der Struktur tm in time.h
Beispielaufruf für time( ) und localtime( )
struct tm{ int tm_sec; // 0 – 59(60) int tm_min; // 0 - 59 int tm_hour; // 0 - 23
int tm_mday; // Tag im Monat: 1 - 31 int tm_mon; // Monat: 0 - 11 int tm_year; // Jahre seit 1900
int tm_wday; // Wochentag: 0 - 6 int tm_yday; // Tag im Jahr: 0 - 365
int tm_isdst; // Flag für Sommerzeit};
#include <time.h>
struct tm *zeit; time_t sec; . . . time(&sec); zeit = localtime(&sec);
cout << "Heute ist der " << zeit->tm_yday +1 << ". Tag des Jahres.\n"; . . .
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1. Aufgabe
� Deklarieren Sie eine Struktur Datum zur Darstellung eines Datums mit ganzzahligen Kom-ponenten für Tag, Monat und Jahr.
� Schreiben Sie eine Funktion showDate(), die ein als Argument übergebenes Datum imFormat tag.monat.jahr ausgibt.
� Schreiben Sie eine Funktion getDate(), die ein Datum im Dialog einliest und eine Be-reichsüberprüfung vornimmt. Bei einem gültigen Datum wird dieses in die Strukturvariablezurückgeschrieben, deren Adresse als Argument übergeben wird.Return-Wert: 1 bei gültiger Eingabe, andernfalls 0.
� Erstellen Sie eine Funktion isLeapYear(), die überprüft, ob eine als Argument überge-bene Jahreszahl ein Schaltjahr ist. Trifft dies zu, so liefert die Funktion 1 zurück, andernfalls 0.
� Testen Sie die Funktionen mit einem geeigneten Hauptprogramm.
2. Aufgabe
� Das Programm aus der 1. Aufgabe soll modular aufgebaut werden. Stellen Sie zu diesemZweck die Definition der Struktur Datum und die Prototypen der Funktionen in die Hea-der-Datei datum.h. Die Implementierung der Funktionen ist in eine separate Quelldatei datum.cpp zu kopie-ren. Das Hauptprogramm, das mit der Struktur Datum und den zugehörigen Funktionenarbeitet, steht ebenfalls in einer eigenen Quelldatei.
� Ergänzen Sie das Programm um eine Funktion actDate(), die das aktuelle Datum in dieStrukturvariable zurückschreibt, deren Adresse als Argument übergeben wird.Return-Wert: keiner.
Die Funktion time() liefert die Systemzeit in Form von Anzahl Sekunden und schreibt diesein die durch secPtr adressierte Variable. Dieser Wert kann der Funktion localtime()übergeben werden, welche die Anzahl der Sekunden in das lokale Datum vom Typ tm um-wandelt und einen Zeiger auf diese Struktur zurückliefert. Die Definition der Struktur tm istnebenstehend angegeben. Der Datentyp time_t ist in time.h als long definiert.
� Testen Sie das Programm, indem Sie auch die Funktion actDate() aufrufen und das ak-tuelle Datum anzeigen lassen.
Hinweis Für die Bereichsüberprüfung definieren Sie einen Vektor, der die Anzahl derTage für jeden Monat speichert (z.B. 31 für Januar usw.). Um festzustellen, ob ein Jahrein Schaltjahr ist, rufen Sie die Funktion isLeapYear() auf.
Hinweis Ein Jahr ist ein Schaltjahr, wenn es durch 4 teilbar ist. Ausgenommen sind dieJahre, die durch 100 teilbar und kein Vielfaches von 400 sind.
Hinweis Verwenden Sie die in time.h deklarierten Funktionentime_t time(time_t *secPtr);struct tm *localtime(const time_t *secPtr);
OOP-Paradigma und C++ 35
36
1.9 Lösungen
Zur 1. und 2. Aufgabe
/************************************************************* Datei: datum.h Zweck: Definition der Struktur Datum und Deklaration zugehoeriger Funktionen. *************************************************************/
#ifndef _DATUM_ /* Nachfolgender Block nur, falls */ /* datum.h noch nicht inkludiert */#define _DATUM_
struct Datum { int tag, monat, jahr; };
/* Prototypen: */void showDate(Datum dat);int getDate(Datum *p);void actDate(Datum *p);int isLeapYear(int year);
#endif
/************************************************************* Datei: datum.cpp Zweck: Definition der Funktionen fuer die Struktur Datum *************************************************************/
#include <stdio.h>#include <time.h>#include "datum.h"
/* ----------------------------------------------------------- showDate(): Datum anzeigen */void showDate(Datum dat){ printf("%d.%d.%d", dat.tag, dat.monat, dat.jahr);}
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/* ----------------------------------------------------------- getDate(): Datum im Dialog einlesen Return-Wert: 1 (true), falls Eingabe ok 0 (false) sonst. */int getDate(Datum *p){ static int tageImMonat[] = { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; int tag=0, monat=0, jahr=0;
printf("\nTag: "); scanf("%d", &tag); if(tag < 1 || tag > 31) return 0;
printf("Monat: "); scanf("%d", &monat); if(monat < 1 || monat > 12 || tag > tageImMonat[monat]) return 0;
printf("Jahr: "); scanf("%d", &jahr); if(jahr < 1 || (!isLeapYear(jahr) && tag == 29) ) return 0;
p->tag = tag; p->monat = monat; p->jahr = jahr;
return 1;}
/* ----------------------------------------------------------- actDate(): das aktuelle Datum holen */void actDate(Datum *p){ struct tm *systime; time_t sec;
time(&sec); systime = localtime(&sec);
p->tag = systime->tm_mday; p->monat = systime->tm_mon + 1; p->jahr = systime->tm_year + 1900;}
OOP-Paradigma und C++ 37
38
1.10 Lösungen (Fortsetzung)/* ----------------------------------------------------------- isLeapYear(): stellt fest, ob ein Schaltjahr vorliegt. Return-Wert: 1 (true), falls ja 0 (false) falls nein */int isLeapYear(int year){ return (year%4 == 0 && year%100 != 0) || year%400 == 0;}
/************************************************************* Datei: datum_t.cpp Zweck: Mit Strukturen vom Typ Datum arbeiten und modulare Programmiertechnik einsetzen. Module: datum_t.cpp datum.cpp *************************************************************/
#include <stdio.h>#include "datum.h" /* Struktur Datum und */ /* Prototypen von Funktionen */ int main(){ struct Datum birthday = { 19, 5, 1986 }; printf("\nMit der Struktur Datum arbeiten\n");
printf("\nEin Geburtstag: "); showDate( birthday);
printf("\n\nWann haben Sie Geburtstag?\n"); if (!getDate( &birthday)) printf("Fehler bei der Eingabe!\n"); else { printf("\nIhr Geburtstag: "); showDate( birthday); } actDate( &birthday); printf("\n\nDas heutige Datum: "); showDate( birthday); printf("\n\n");
return 0;}
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Kapitel 2: Erste Schritte mit C++
Dieses Kapitel beschreibt Erweiterungen der Programmiersprache C, wie:
� die freie Plazierungsmöglichkeit von Deklarationen
� Inline-Funktionen
� Aufzählungen
Außerdem werden die neuen Streams cin, cout und cerr kurz vorgestellt,damit sie von Beginn an in Beispielprogrammen und Übungen eingesetzt wer-den können.
17
18
19
20
21
40
2.1 Kommentare
Beispielprogramm
/************************************************************** Ein Programm mit vielen Kommentaren, das die Verwendung ** von Strukturen zeigt. ** Strukturnamen sind in C++ Typnamen! *************************************************************/
#include <stdio.h> // Fuer den Prototyp von printf()
struct buch // Definition der Struktur buch{
char autor[32];char titel[32];float preis;
}; // Semikolon nicht vergessen.
void display( buch *buchptr); // Prototyp von display()
int main() // Mit Strukturvariablen vom Typ buch arbeiten.{
buch roman = { "Al Capone", "Das grosse Spiel", 39.90F},gedichte = { "Winter, Eva", "Traumreise", 79.80F};
display( &roman); // Die Adresse der Variablendisplay( &gedichte); // uebergeben.
printf("Gesamtpreis: %.2f\n",roman.preis + gedichte.preis);
return 0;}
// -----------------------------------------------------------// Funktion: display()// Argument: Zeiger auf eine Struktur vom Typ buch// Return-Wert: keiner
void display( buch *buchptr){
printf("\n""Autor: %s\n""Titel: %s\n""Verkaufspreis: %6.2f\n\n",buchptr->autor, buchptr->titel, buchptr->preis);
}
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Kommentare
C++ kennt zwei Formen von Kommentaren:
� Den traditionellen C-Kommentar: /* Ein Kommentar */
� Den Einzeilen-Kommentar: // Ein Kommentar
Der neue Einzeilen-Kommentar beginnt mit // (zwei Schrägstriche). Es werden alle weiterenZeichen bis zum Zeilenende ignoriert.
Der Einzeilen-Kommentar eignet sich daher besonders für die kurze Kommentierung einzel-ner Programmzeilen.
++zaehler; // Index erhöhen
Jede Form von Kommentar kann auch dazu verwendet werden, die jeweils andere Form aus-zukommentieren:
/*++zaehler; // zaehler = zaehler + 1;*/
oder umgekehrt:
// ++zaehler; /* zaehler = zaehler + 1; */
Zum Beispielprogramm
Das nebenstehende Beispielprogramm demonstriert die großzügige Verwendung von Kom-mentaren. Der Quelltext wird so leichter nachvollziehbar, insbesondere auch durch die opti-sche Gliederung mit Hilfe von Kommentaren.
Im Programm wird eine Struktur buch definiert und gezeigt, wie mit Variablen dieses Typs ge-arbeitet wird.
Im Unterschied zu C ist der Strukturname auch bereits der Typname. Das Schlüsselwortstruct wird nur in der Strukturdefinition benötigt und kann in nachfolgenden Deklarationenweggelassen werden:
struct buch roman; /* Syntax von C */buch roman; // erweiterte Syntax von C++
In C++ ist weiterhin die »alte« C-Syntax zulässig. Das hier für struct-Typen Gesagte gilt ana-log auch für union- und enum-Typen.
Erste Schritte mit C++ 41
42
2.2 Klassen für die Standard-Ein- und Ausgabe
Ein- und Ausgabe-Streams
cout
cerr
clog
cincin>>zeichen;
Tastatur
char zeichen;
clog<<"Test2\n";
cerr<<"Test1\n";
cout<<"Hallo!\n";
!
BildschirmProgramm
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
I/O-Streams
Zusätzlich zum Ein- und Ausgabesystem von C verfügt C++ über neue Streams auf der Basisvon Klassen. Der Begriff Stream (dt. Strom) spiegelt die Situation wider, dass Zeichenfolgenbei der Ein- und Ausgabe als Datenstrom behandelt werden.
Ein wesentlicher Vorteil der neuen Streams ist die Typsicherheit:
Bei den klassischen C-Funktionen, wie zum Beispiel printf(), kann der Compiler nicht im-mer den richtigen Aufruf überprüfen. Ein falsches Formatelement oder der falsche Typ einesArguments führen unweigerlich zu einem Laufzeitfehler.
Beispiel: double x = 1.5;printf("%d", x); // Fehler!
// Falsches Formatelement.
Derartige Fehler sind bei Verwendung der neuen Streams ausgeschlossen: Der Compiler ent-scheidet anhand des Argumenttyps, welche Eingabe- bzw. Ausgabe-Routine aufzurufen ist.
cin, cout, cerr, clog
Die Klassen für die neuen Streams sind in der Header-Datei iostream deklariert, und es gibtfolgende Objekte:
cin Standard-Eingabe
cout Standard-Ausgabe
cerr Standard-Fehlerausgabe
clog Standard-Fehlerausgabe
Diese Streams basieren auf den C-Streams stdin, stdout und stderr. Im Unterschied zucerr ist der Stream clog gepuffert und wird normalerweise für Protokollausgaben verwen-det.
Alte und neue Stream-Funktionen sollten in einem Programm nicht gemischt werden, d.h.wenn beispielsweise für die Eingabe cin benutzt wird, sollte an anderer Stelle nicht scanf()aufgerufen werden.
Im folgenden wird gezeigt, wie die neuen Streams zu verwenden sind. Dazu sind noch keineKenntnisse über Klassen notwendig. Erst in einem späteren Kapitel wird auf die Klassenhier-archie der iostream-Bibliothek eingegangen und werden weitergehende Fähigkeiten beschrie-ben.
Alle in der C++-Standard-Bibliothek definierten globalen Bezeichner gehören zum Namens-bereich std. Im Anschluß an die Direktive
using namespace std;
können diese Bezeichner direkt angesprochen werden.
Erste Schritte mit C++ 43
44
2.3 Ausgaben mit cout
Bildschirmausgaben mit printf()
Bildschirmausgaben mit cout
#include <stdio.h>
int main(){
float zahl = 12.345f;
printf("Der Wert der Zahl: %f\n", zahl);
return 0;}
#include <iostream>using namespace std;
int main(){
float zahl = 12.345f;
cout << "Der Wert der Zahl: "; // Ein Stringcout << zahl; // Ein float-Wertcout << '\n'; // Ein Zeichen
// Und nochmal in einer Anweisung:
cout <<"Der Wert der Zahl: " << zahl << ’\n’;
return 0;}
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Ausgaben mit cout
Für die Ausgabe mit den Klassen der iostream-Bibliothek wurde der Shift-Operator <<»überladen«, d.h., er hat für Objekte dieser Klassen eine neue Bedeutung erhalten.
Beispiel: cout << "Hello world!\n";
Diese Anweisung bewirkt, dass der String "Hello world!\n" zur Standard-Ausgabe ( alsoauf den Bildschirm) »geschoben« wird. Mit seiner Richtung zeigt der Operator << an, wohingeschoben wird.
Ebenso wie Strings können auch Werte mit einem anderen Datentyp ausgeben werden.
Beispiel: int zaehler = 10;cout << zaehler; // Ausgabe: 10
Das Objekt cout ist »intelligent« genug, den Typ der Daten zu erkennen: Mit cout und demOperator << können außer Strings alle Werte ausgegeben werden, die einen elementaren Da-tentyp haben. Darüber hinaus kann der Anwendungsbereich des Operators << jederzeit aufandere Datentypen, auch selbstdefinierte Datentypen, ausgedehnt werden. Dazu muss derOperator << überladen werden. Diese Technik wird in einem späteren Kapitel behandelt.
Der Ausdruck cout << Wert; repräsentiert selbst wieder das Objekt cout. Daher kann derOperator << auch mehrfach hintereinander angewendet werden.
Beispiel: cout << "Dieser String und ein Zeichen: " << 'A';
In diesem Beispiel wird die Zeichenkonstante 'A' benutzt. Hier ist der folgende Unterschiedzwischen C und C++ zu beachten:
C: Eine Zeichenkonstante ist vom Typ int.C++: Eine Zeichenkonstante ist vom Typ char.
Am Bildschirm wird also wirklich A ausgegeben, und nicht etwa der Zeichencode von 'A'.
Ausgaben mit cerr
Die Standard-Fehlerausgabe cerr bietet dieselben Möglichkeiten wie cout. Insbesonderesendet auch cerr seine Ausgabe normalerweise zum Bildschirm.
Die Unterscheidung zwischen cout und cerr ist dann wichtig, wenn Ausgaben umgelenktwerden (z.B. in eine Datei). Fehlermeldungen sollten deshalb über cerr ausgegeben werden.Nur so ist sichergestellt, dass diese auch dann noch auf dem Bildschirm erscheinen, wenn dieStandard-Ausgabe umgeleitet wurde.
Erste Schritte mit C++ 45
46
2.4 Eingaben mit cin
Beispiel für Stream-I/O mit cin, cout, cerr
//------------------------------------------------------------// Das Programm liest zwei Zahlen im Dialog ein// und gibt die groessere Zahl aus.//------------------------------------------------------------
#include <iostream>using namespace std;
int max( int, int);
char prompt[] ="Geben Sie zwei verschiedene Ganzzahlen ein: \n";
int main(){
int zahl1, zahl2;
// ----- ohne Fehlerbehandlung: -----cout << prompt;cin >> zahl1 ; cin >> zahl2;cout << "Die groessere Zahl ist: "
<< max(zahl1, zahl2) << "\n";
// ----- nochmal mit Fehlerbehandlung: -----cout << prompt;if( cin >> zahl1 && cin >> zahl2){
cout << "Die groessere Zahl ist: "<< max( zahl1, zahl2) << "\n";
return 0;}else{
cerr << "Fehlerhafte Eingabe! \n";return 1;
}}
int max( int a, int b) // Maximum von a und b liefern.{
return (a > b ? a : b);}
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Eingaben mit cin
Das Lesen von der Standard-Eingabe (also von der Tastatur) erfolgt mit cin und dem Opera-tor >> .
Beispiel: float var;cin >> var; // Gleitpunktzahl in var einlesen
Die Daten werden also von cin in die Variable var »geschoben«. Über den Typ der Variablenlegt cin selbständig fest, was als Eingabe akzeptiert wird und wie die Konvertierung erfolgt.Auf diese Weise können Werte mit einem elementaren Datentyp und Strings eingelesen wer-den.
Im Gegensatz zur Eingabe mit scanf() können keine leichtsinnigen Fehler durch die Wahlfalscher Formatelemente gemacht werden! Das obige Beispiel ist wirkungsgleich mit folgen-der scanf-Anweisung:
float var;scanf("%f", &var); // Gleitpunktzahl in var einlesen
Wie von scanf() her bekannt, gelten auch beim Einlesen mit cin und dem Operator >> fol-gende Regeln:
� Führende Zwischenraumzeichen werden überlesen.
� Die Verarbeitung der Eingabe bricht ab, wenn ein Zeichen nicht verarbeitet werden kann.
Beispiel: cin >> var; // Gleitpunktzahl in var einlesen
Erfolgt hier die Eingabe
1.20 DM
so wird 1.20 in der Variablen var gespeichert, und alle weiteren Zeichen bleiben im Einga-bepuffer. Bei der Eingabe von
DM 1.20
würde kein Wert an var zugewiesen, und die Eingabe bleibt unverarbeitet im Puffer.
Fehlerbehandlung
Das Progamm kann feststellen, ob ein Wert eingelesen wurde: Erfolgt die Eingabe nämlich ineiner Verzweigungs- oder Laufbedingung, so liefert der Ausdruck »wahr«, wenn die Eingabeerfolgreich war, andernfalls »falsch«.
Beispiel: float var;if( ! (cin >> var) ) cerr << "Fehler: Keine Zahl eingelesen!\n";
Auch das nebenstehende Beispiel demonstriert die Behandlung von Eingabefehlern.
Erste Schritte mit C++ 47
48
2.5 Einlesen von Zeichen und Strings
Beispielprogramm
//------------------------------------------------------------// Das Geruest eines Filterprogramms// bei Verwendung von cin und cout//------------------------------------------------------------
#include <iostream>using namespace std;
int main(){
int c;
// Solange ein Zeichen eingelesen werden kann:while( ( c = cin.get()) != EOF){
cout << (char)c; // Zeichen wieder ausgeben.}
return 0;}
Hinweis Beim Lesen von der Tastatur wird das »Dateiende« durch ^Z (unter DOS/Win-dows) bzw. ^D (unter UNIX) erzeugt.
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Eingabe von Einzelzeichen
Mit dem Operator >> kann auch ein einzelnes Zeichen eingelesen werden.
Beispiel: char c;cin >> c; // Ein Zeichen nach c einlesen.
Dabei ist aber zu beachten, dass der Operator >> standardmäßig führende Zwischenraumzei-chen überliest! Bei der Eingabe
<Eingabetaste> <Tab> <Leertaste> <A> <Eingabetaste>
würde 'A' der Variablen c zugewiesen.
Soll jedes Zeichen, also auch ein Zwischenraumzeichen, eingelesen werden, kann dazu diecin-Methode get() aufgerufen werden.
Beispiel: int c;c = cin.get(); // Ein Zeichen nach c einlesen.
Die Methoden eines Objekts werden wie die Komponenten einer Strukturvariablen angespro-chen, also mit dem Punktoperator. Die Anweisung c = cin.get(); ist wirkungsgleich mitfolgender C-Anweisung:
c = getchar(); // Ein Zeichen nach c einlesen.
Insbesondere liefert cin.get() den Wert EOF, wenn das Dateiende erreicht ist oder ein Feh-ler auftrat. Das ist auch der Grund, warum hier c als int-Variable deklariert wurde.
Das nebenstehende Beispiel zeigt, wie das klassische Filtergerüst in C++ aussieht.
Eingabe von Strings
Auch die Eingabe von Strings mit dem Operator >> verhält sich wie die entsprechendescanf("%s", ... ); -Anweisung: Führende Zwischenraumzeichen werden überlesen,und Zwischenraumzeichen trennen die »Eingabefelder«.
Beispiel: char name[20];cin >> name; // Einen String nach name einlesen.
Bei der Eingabe von
Edith und Uwe
wird also nur das Wort "Edith" eingelesen. Alle weiteren Zeichen bleiben im Eingabepuffer.
Für das Einlesen einer vollständigen Zeile stellt cin die Methode getline() zur Verfügung.Beim Aufruf ist außer dem Eingabepuffer auch seine Größe anzugeben.
Beispiel: char name[20]cin.getline( name, 20); // String in name einlesen
Hiermit wird eine Zeile (incl. '\n'), aber maximal 19 Zeichen eingelesen. Das Zeilenendezei-chen '\n' wird nicht im String gespeichert.
Erste Schritte mit C++ 49
50
2.6 Plazierung von Deklarationen
Deklaration von Variablen direkt vor ihrer Verwendung
Unterscheidung globaler und lokaler Variablen
//------------------------------------------------------------// Die Funktion NumSort() sortiert einen Vektor v[]// mit Gleitpunktzahlen in aufsteigender Reihenfolge// nach dem Selection-Sort-Algorithmus.//------------------------------------------------------------
void NumSort(double v[], int len){
for(int i = 0; i < len -1; i++){int mini = i; // mini: Der Index des bis dahin
// kleinsten Vektorelements.for( int j = i + 1; j < len; j++)
if( v[j] < v[mini]) // Index des kleinerenmini = j; // Elements merken.
double temp = v[i]; // v[i] und v[mini]v[i] = v[mini]; // tauschen.v[mini] = temp;
}}
#include <iostream>using namespace std;
char msg[] = "Ich bin der globale String!\n";
int main(){
char msg[] = "Ich bin der lokale String!\n";
cout << msg; // lokalcout << ::msg; // global
return 0;}
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Freie Plazierung
Bevor eine Variable oder Funktion in einem C++-Programm verwendet werden kann, muss siedeklariert werden.
Die Plazierung von Deklarationen ist in C auf bestimmte Stellen in einem Programm einge-schränkt: entweder außerhalb von Funktionen oder innerhalb von Funktionen unmittelbarhinter einer sich öffnenden geschweiften Klammer, d.h. am Beginn eines Blocks.
Dagegen können Deklarationen in C++ frei plaziert werden: Deklarationen dürfen auch über-all dort stehen, wo eine Anweisung erlaubt ist. Dadurch lassen sich Variablen näher bei derStelle deklarieren, wo sie auch verwendet werden. Sinnvoll eingesetzt, kann diese zusätzlicheFreiheit dazu beitragen, die Lesbarkeit von Programmen zu verbessern.
Eine typische Anwendung ist die Deklaration eines Schleifenzählers innerhalb einer for-Schleife.
Beispiel: for ( int i = 1; i <= 10; i++) cout << i << ". Durchlauf\n";
Die Deklaration wird hier im Initialisierungsteil vorgenommen.
Geltungsbereich
Der Geltungsbereich einer Variablen wird durch ihre Speicherklasse bestimmt. Lokale Variab-len haben den Geltungsbereich »Block«. Dieser beginnt mit der Deklaration und endet mitder Klammer }, die den Block schließt.
Gemäß dem C++-ANSI-Standard gilt aber für die for-Schleife folgende Ausnahme: Der Gel-tungsbereich einer Variablen, die im Initialisierungsteil der for-Anweisung deklariert wird, istdie for-Anweisung (und nicht etwa der Block, der die for-Anweisung enthält).
Bezogen auf das obige Beispiel bedeutet dies, dass die Variable i nach der Schleife nicht mehrzur Verfügung steht.
Der Bereichs-Operator ::
In C++ gibt es den neuen Operator ::, mit dem Bezug auf bestimmte Bereiche genommenwerden kann. Hauptsächlich wird er in Verbindung mit Klassen eingesetzt. Er läßt sich aberauch zur Unterscheidung globaler und lokaler Variablen einsetzen.
Eine innerhalb eines Blocks deklarierte Variable var »verdrängt« eine globale Variable glei-chen Namens. Im Geltungsbereich der lokalen Variablen kann dennoch mit
::var
auf die globale Variable zugegriffen werden. Von dieser Möglichkeit sollte natürlich möglichstselten Gebrauch gemacht werden, da die Lesbarkeit des Programms darunter leidet.
Erste Schritte mit C++ 51
52
2.7 Prototyp von Funktionen
Einsatz von Prototypen
��������
�� ��� ����
// Definition der Funktion fun()
double fun() { . . . // Was die Funktion macht. }
�� ��� ����
// Prototyp und Aufruf der Funktion fun()
double fun(void); void f1() { . . . double a = fun(); . . . }
�� ��� ����
// Prototyp und Aufruf der Funktion fun()
double fun(void); void f2() { . . . double b = fun(); . . . }
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Funktionsprototypen
Funktionsprototypen wurden in C mit dem ANSI-Standard eingeführt. Der Prototyp einerFunktion ist die vollständige Deklaration der Funktion. Diese beschreibt
� den Typ des Return-Werts der Funktion und
� die Anzahl, die Reihenfolge und den Typ der Parameter
Der Compiler kann so bei jedem Aufruf prüfen, ob die Anzahl und der Typ der Argumenterichtig angegeben wurde.
Beispiel: int atoi(const char *str); //Prototyp von atoi()
Dieser Prototyp besagt,
1. dass die Funktion atoi() ein Argument erhält, nämlich einen String, der konstant seindarf, und
2. dass der Return-Wert vom Typ int ist.
Die Angabe des Prototyps kann nur dann entfallen, wenn sich die Definition der Funktion inderselben Quelldatei vor ihrem ersten Aufruf befindet. In diesem Fall ist die Definition selbstschon die Deklaration der Funktion.
Unterschied zu C
Eine Funktionsdeklaration mit leeren Klammern
typ func();
wird in C und C++ unterschiedlich interpretiert:
C: Keine Information über die Parameter der Funktion
C++: Die Funktion besitzt keine Parameter
Der Grund hierfür liegt in der Kompatibilität von ANSI-C zum Kernighan&Ritchie-Standard.Um Probleme zu vermeiden, sollte daher eine Funktion ohne Parameter stets wie folgt dekla-riert werden:
typ func(void);
Hinweis Anders als in C, gibt es in C++ für den Typ einer Funktion keine Standard-Vor-gabe. Daher muss (!) jede Funktion vor ihrem ersten Aufruf deklariert werden. Der Proto-typ wird entweder direkt in der Quelldatei angegeben oder indirekt durch Inkludieren ei-ner Header-Datei, die den Prototyp enthält.
Erste Schritte mit C++ 53
54
2.8 Inline-Funktionen
Inline-Funktionen und Makros
//------------------------------------------------------------// Beispielprogramm zum Vergleich von// inline-Funktionen und Makros//------------------------------------------------------------
#include <iostream>using namespace std;
#define QUADRAT(x) ((x) * (x))
inline double quadrat(double x ){
return( x * x);}
int main(){
double zahl, erg;
zahl = 4.0;erg = QUADRAT(++zahl); // Achtung Seiteneffekt!cout << "Ergebnis: " << erg << "\n"; // falsch!
zahl = 4.0;erg = quadrat(++zahl); // alles ok!cout << "Ergebnis: " << erg << "\n";
return 0;}
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Inline-Definition
Beim Aufruf einer Funktion wird die Rücksprungadresse auf dem Stack gesichert und die Pro-grammausführung in der Funktion fortgesetzt. Nach Beendigung der Funktion erfolgt derRücksprung mit Hilfe der gesicherten Adresse. Dieser »Overhead« kann bei kleinen Funk-tionen im Vergleich zur eigentlichen Aufgabe der Funktion erheblich sein.
Zur Vermeidung dieses Nachteils kann in C++ eine Funktion als inline-Funktion definiertwerden. Beim Aufruf einer solchen Funktion fügt der Compiler den Funktionscode direkt ander Stelle ihres Aufrufs ein. Damit wird zur Laufzeit kein Unterprogrammsprung ausgeführt.Die Verwendung von inline-Funktionen erhöht so die Ausführgeschwindigkeit eines Pro-gramms.
Eine Funktion wird als »inline« definiert, indem das Schlüsselwort inline dem Funktions-kopf vorangestellt wird:
Beispiel: inline double min( double x, double y){ return (x < y ? x : y);}
Es ist naheliegend, dass eine inline-Funktion nur aus wenigen Anweisungen bestehensollte. Andernfalls wird der Programmcode bei mehrmaligen Aufrufen der Funktion zu um-fangreich.
Der Compiler kann bei zu umfangreichen Funktionen auch auf das Einfügen des Funktions-codes verzichten: Das Schlüsselwort inline wird ignoriert und eine entsprechende Warnungausgegeben. Dies kann schon dann der Fall sein, wenn die Funktion eine Schleife enthält.
Definition in Header-Dateien
Bevor eine inline-Funktion aufgerufen werden kann, muss sie zuvor in derselben Quelldateidefiniert worden sein. Für den Aufruf einer inline-Funktion genügt es nicht, ihren Prototypanzugeben. Der Compiler muss auch den Anweisungsblock der Funktion kennen.
Deshalb wird eine inline-Funktion, die in mehreren Quelldateien verfügbar sein soll, übli-cherweise in einer Header-Datei definiert. Das ist ein wesentlicher Unterschied zu »norma-len« Funktionen, deren Definition immer in einer Quelldatei stehen sollte.
Unterschied zu Makros
Inline-Funktionen sind mit parametrisierten Makros vergleichbar. Beim Aufruf eines Makrosnimmt der Präprozessor noch vor dem eigentlichen Kompiliervorgang einen textuellen Ersatzvor. Hierbei findet keine Typüberprüfung von Argumenten statt.
Im Unterschied dazu prüft der Compiler beim Aufruf einer inline-Funktion die Korrektheitdes Aufrufs, so wie bei jeder anderen Funktion auch. Darüber hinaus können auch keine Sei-teneffekte auftreten!
Erste Schritte mit C++ 55
56
2.9 Aufzählungen
Beispielprogramm
//------------------------------------------------------------// Definition und Verwendung von Aufzaehlungen//------------------------------------------------------------
#include <ctype.h>#include <iostream>using namespace std;
enum SpruchTyp { WISSEN = 'W', LOESUNG = 'L',FAEHIGKEIT = 'F', ENDE = 'Q' };
int main(){
SpruchTyp spruch;char antwort;
do{cout << "\nWelchen Spruch wuenschen Sie?\n\n"
<< "\t <W> = Wissen\n"<< "\t <L> = Loesung\n"<< "\t <F> = Faehigkeit\n"<< "\t <Q> = Quit (Ende des Programms)\n";
cin >> antwort;spruch = (SpruchTyp)toupper(antwort);
switch( spruch){
case WISSEN:cout << "\nWissen ist Macht, \n"
"nichts wissen macht auch nichts!\n\n";break;
case LOESUNG:cout << "\nEine Loesung hatte ich,\n"
"aber die passte nicht zum Problem!\n\n";break;
case FAEHIGKEIT:cout << "\nZu allem faehig, \n"
"aber zu nichts zu gebrauchen!\n\n";break;
}}while( spruch != ENDE);
return 0;}
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Definition von Aufzählungen
Eine Aufzählung (engl. enumeration) ist ein selbstdefinierter Datentyp, dessen Wertebereichnur bestimmte ganzzahlige Werte umfasst.
Die Definition einer Aufzählung erfolgt mit dem Schlüsselwort enum. Dabei werden in einerAufzählungsliste die möglichen Werte und gleichzeitig Namen für diese Werte festgelegt.
Beispiel: enum Schalter { AUS, AN }; // Typ und KonstanteSchalter schalter1 = AUS; // Variable mit Wert AUS
Hiermit wird der Aufzählungstyp Schalter definiert und außerdem eine Variableschalter1 vom Typ Schalter.
Die in der Aufzählungsliste angegebenen Namen bezeichnen ganzzahlige Konstanten. Sofernkeine anderen Werte festgelegt werden, hat die erste Konstante den Wert 0 und jede weitereKonstante einen um eins höheren Wert als der Vorgänger.
Im obigen Beispiel hat also die Konstante AUS den Wert 0 und AN den Wert 1. Eine Variablevom Typ Schalter kann nur die Werte AUS oder AN annehmen.
Die Werte der Konstanten können explizit angegeben werden. Dabei ist jeder int-Wert zu-lässig.
Beispiel: enum Grundfarbe { BLAU = 1, GRUEN = 2, ROT = 4 };
Die explizite Wertzuweisung kann auch nur für einen Teil der Konstanten erfolgen:
enum Schalter { AUS, OFF = 0, AN, ON = 1 };
In dem hier definierten Aufzählungstyp Schalter haben die Konstanten AUS und OFF denWert 0, die Konstanten AN und ON den Wert 1.
Mit einer Aufzählung können bequem symbolische Konstanten definiert werden. Dies stellteine Alternative zur #define-Direktive dar. Sollen nur die Konstanten definiert werden, musskein Typname für die Aufzählung angegeben werden.
Beispiel: enum { SCHWARZ, BLAU, GRUEN, GELB, ROT, WEISS };
Operationen mit Aufzählungen
In C werden Variablen, die einen Aufzählungstyp besitzen, wie int-Variablen behandelt. Da-gegen sind in C++ Aufzählungen eigenständige Datentypen, für die keine arithmetischenOperatoren definiert sind!
Für Aufzählungen wird jedoch die Ganzzahlerweiterung durchgeführt, d.h., der Wert einerAufzählungsvariablen kann implizit in einen int-Wert umgewandelt werden. Für den umge-kehrten Weg ist immer eine explizite Typumwandlung notwendig.
Erste Schritte mit C++ 57
58
2.10 Der Datentyp bool
Eine Funktion mit dem Ergebnistyp bool
//------------------------------------------------------------// Die inline-Funktion testRange() prueft,// ob ein int-Wert im Bereich zwischen// MIN_VAL und MAX_VAL liegt.//// Return-Wert: true oder false.//------------------------------------------------------------
enum { MIN_VAL = 20, MAX_VAL = 500 };
inline bool testRange( int val){
return (val >= MIN_VAL && val <= MAX_VAL);}
Hinweis
Wenn Sie einen Compiler benutzen, der den Datentyp bool noch nicht unterstützt, kön-nen Sie hilfsweise auch mit der folgenden Definition arbeiten:
enum bool { false, true };
Der Compiler wird aber immer dann ein »Warning« ausgeben, wenn ein Ausdruck vom Typint nach bool konvertiert werden muss.
Alternativ kann bool auch als Synonym für int definiert werden:
#define bool int#define false 0#define true 1
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Datentyp bool
In Verzweigungen oder Schleifen werden Ausdrücke verwendet, die »falsch« oder »wahr«sein können. Für die Darstellung dieser booleschen Werte benutzen C und frühere Versionenvon C++ den Typ int: Der int-Wert 0 bedeutet »falsch«, 1 bzw. jeder Wert ungleich 0 be-deutet »wahr«. Das ist hinreichend, aber keine gute Datenabstraktion.
Deshalb wurden in C++ für boolesche Werte der neue Datentyp bool sowie die Literalefalse und true eingeführt. Variablen mit dem Typ bool können nur zwei Werte annehmen:false für falsch und true für wahr.
Beispiel: bool merker = true; // Definition von merker.
if( merker == true ) // merker gesetzt ? . . .
Die Vergleichsoperatoren, also
< <= > >= == !=
liefern als Ergebnis den booleschen Wert true oder false.
Beispiel: float x = 1.5;bool vergleich = x < 2; // vergleich = true;
Boolesche Ausdrücke können mit den booleschen Operatoren
&& (UND) || (ODER) ! (NICHT)
verknüpft werden. Sowohl die Operanden als auch das Ergebnis dieser Operanden haben denTyp bool.
Beispiel: int a = 1, b =20;while( a < 10 && b > 10){ . . . }
Der Datentyp bool ist eng mit dem Typ int verbunden: In beiden Richtungen (also von intnach bool und von bool nach int) werden implizite Typumwandlungen vorgenommen.
Beispiel: cout << "Der Wert von false: " << (int) false << "Der Wert von true: " << (int) true << '\n';
Hier wird false bzw. true in int umgewandelt und ausgegeben, nämlich als 0 bzw. 1, wienicht anders zu erwarten ist. Der Cast wäre hier allerdings nicht nötig gewesen: Standardmä-ßig gibt cout boolesche Werte als 0 bzw. 1 aus.
In der umgekehrten Richtung wird 0 in false umgewandelt und jeder andere Wert in true.
Erste Schritte mit C++ 59
60
2.11 Übungen
Beispielaufruf der Funktion sprintf()
Manipulatoren für die Ein- und/oder Ausgabe
#include <stdio.h>#include <iostream>using namespace std;
float dm = 123.90;char buf[81]; . . . sprintf( buf,"Ein Beispiel! Betrag: %10.2f\n", dm); cout << buf;
Manipulator Bedeutung für
oct, dec, hex Oktale, dezimale, hexadezimale Ein-/Ausgabe(Standard: dec)
cin, cout
setw(n) Setzt die Feldbreite n. Diese Einstellung gilt nur für die nächste Ein-/Ausgabe!
cin, cout
flush Leert den Ausgabepuffer. cout
endl Gibt ein New-Line aus u. leert den Ausgabepuffer. cout
setfill(c) Definiert das Füllsymbol c (Standard: Leerzeichen). cout
setprecision(n) Definiert die Genauigkeit n zur Ausgabe von Gleitpunktzahlen (Standard: 6 Stellen).
cout
Hinweis
1. Mit dem Manipulator setw(n) für die Eingabe wird festgelegt, wieviele Zeichen in ei-nen String maximal eingelesen werden, nämlich höchstens n-1. Damit kann verhindertwerden, dass bei der Eingabe von Strings über das Ende des char-Vektors hinaus ge-schrieben wird.
2. Bei der Ausgabe von Gleitpunktzahlen werden standardmäßig keine abschließendenNullen nach dem Dezimalpunkt angezeigt. Sollen stets so viele Stellen nach dem Dezi-malpunkt angezeigt werden, wie mit der Angabe von setprecision() festgelegtwurde, kann das durch die folgende Anweisung erreicht werden:
cout.setf(ios::fixed);
Damit ist die Ausgabe auf die Dezimalpunkt-Darstellung festgelegt. Ohne diese Anwei-sung wird bei sehr kleinen bzw. großen Zahlen auf die Exponential-Darstellung umge-schaltet.
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1. Aufgabe
In einem C++-Programm, das für die Bildschirm-Ein-/Ausgabe mit den neuen Streams arbei-tet, sollte nicht zusätzlich die Funktion printf() verwendet werden. Will man auf die For-matierungsmöglichkeiten von printf() nicht verzichten, so kann die Formatierung im Spei-cher erfolgen. Sie ist damit von der eigentlichen Ausgabe getrennt.
Die Formatierung im Speicher erfolgt mit der Standard-Funktion sprintf(). Diese arbeitetwie printf(), jedoch mit dem Unterschied, dass die Zeichen nicht in die Standard-Ausgabe,sondern in einen String kopiert werden. Dieser ist als erstes Argument von sprintf() anzu-geben. Die weiteren Argumente entsprechen denen von printf(). Der Prototyp vonsprintf() ist in der Header-Datei stdio.h enthalten.
Testen Sie die Formatierungsmöglichkeiten mit sprintf(), indem Sie die Tabellenüber-schrift:
Artikelnummer Artikelbezeichnung Preis-------------------------------------------------
sowie drei passende Tabellenzeilen zunächst in einen String kopieren und anschließend mitcout ausgeben lassen.
2. Aufgabe
Die Klasse iostream bietet verschiedene Formatierungsmöglichkeiten für die Ein-/Ausgabe.Hierzu gehören sogenannte Manipulatoren, die als Operanden der Shift-Operatoren den Ein-/Ausgabestrom »manipulieren«. Beispielsweise setzt der Manipulator setw() eine Feld-breite:
cout << setw(8) << x;
Der Wert der Variablen x wird dann rechtsbündig in ein Feld der Feldbreite 8 positioniert. Ne-benstehend sind mehrere wichtige Manipulatoren zusammengestellt.
Für alle Manipulatoren, die mindestens ein Argument erhalten, muss zusätzlich die Header-Datei iomanip inkludiert werden.
Testen Sie die verschiedenen Formatierungsmöglichkeiten mit Hilfe der Manipulatoren, in-dem Sie:
� Eine Ganzzahl mit cin einlesen und ihren Wert dezimal, oktal und hexadezimal ausgeben.
� Eine Ganzzahl oktal und eine zweite Ganzzahl hexadezimal mit cin einlesen und anschlie-ßend beide in zwei verschiedenen Zeilen dezimal ausgeben.
� Eine Ganzzahl in ein Feld der Feldbreite 20 ausgeben, das mit dem Zeichen '*' aufgefülltwird.
� Einen String in ein Feld vorgegebener Breite setzen.
� Eine Gleitpunktzahl mit der Genauigkeit 12 ausgeben lassen.
Erste Schritte mit C++ 61
62
3. Aufgabe
� Ändern Sie die Definitionen der Funktionen getDate() und showDate() in der Quell-datei datum.cpp (vgl. 1. Kapitel, 2. Aufgabe), indem Sie die C-Funktionen für die Ein-/Ausgabe durch cin und cout ersetzen.Außerdem sind die Funktionen getDate() und isLeapYear() so zu ändern, dass sieden Ergebnistyp bool statt int besitzen.
� Deklarieren Sie in einer Header-Datei person.h eine Struktur Person mit Komponentenfür Name, Vorname und Geburtsdatum. Verwenden Sie hierbei die bereits definierte Struk-tur Datum.
� Schreiben Sie eine Funktion getPerson(), welche die Daten einer Person in eine Struk-turvariable vom Typ Person einliest. Verwenden Sie die bereits erstellte Funktion get-Date().
� Erstellen Sie eine Funktion showPerson(), welche die Daten einer Person, die ihr als Ar-gument übergeben werden, ausgibt. Verwenden Sie die bereits erstellte FunktionshowDate().
� Stellen Sie die Prototypen der Funktionen getPerson() und showPerson() in die Hea-der-Datei person.h. Die Definitionen der Funktionen getPerson() und showPer-son() sollen in einer eigenen Quelldatei person.cpp stehen.
� Testen Sie die Funktionen mit einer geeigneten main-Funktion, die Sie ebenfalls in einereigenen Quelldatei person_t.cpp erstellen.
Die Dateien dieser Aufgabe:
Die Header-Dateien: date.h person.h
Die Quelldateien: date.cpp person.cpp person_t.cpp
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2.12 Lösungen
Zur 1. Aufgabe
// -------------------------------------------------------------// Datei: sprintf.cpp// Zweck: Formatierung im Speicher mit sprintf()// und Ausgabe mit cout.// -------------------------------------------------------------
#include <stdio.h> // Prototyp von sprintf().#include <iostream> // Fuer cout.using namespace std;
struct artikel { int nr; char bez[20]; double preis; };
int main(){ artikel artTab[3] = { { 110, "Hose", 98.90 }, { 120, "Jacke", 148.00 }, { 130, "Bluse", 88.80 } }; char str[50];
cout << "\n Artikelnummer Bezeichnung Preis" << "\n----------------------------------------------\n";
for( int i = 0; i < 3; ++i) { sprintf(str," %-20d %-20s %6.2f\n", artTab[i].nr, artTab[i].bez, artTab[i].preis);
cout << str; }
return 0;}
Erste Schritte mit C++ 63
64
2.13 Lösungen (Fortsetzung)
Zur 2. Aufgabe
// -------------------------------------------------------------// Datei: cincout.cpp// Zweck: Formatierte Ein-/Ausgabe mit cin, cout.// -------------------------------------------------------------
#include <iostream>#include <iomanip> // Fuer Manipulatoren mit Argumentenusing namespace std;
int main(){ int x, y, z;
// Teil a) cout << "\nBitte eine Ganzzahl eingeben: "; cin >> dec >> x;
cout << "dezimal: " << dec << x << endl; cout << "oktal: " << oct << x << endl; cout << "hex: " << hex << x << endl;
// Teil b) cout << endl << "Bitte eine oktale Ganzzahl eingeben: "; cin >> oct >> y; cout << endl << "Bitte eine Hex-Zahl eingeben: "; cin >> hex >> z;
cout << dec; cout << "Die erste Zahl dezimal: " << y << endl; cout << "Die zweite Zahl dezimal: " << z << endl;
// Teil c) cout << endl; cout << setw(20) << setfill('*') << 1234 << endl;
// Teil d) cout << endl; cout << setw(20) << "Feldbreite: 20" << endl; cout << "Ohne Feldbreite" << endl;
// Teil e) cout.setf(ios::fixed); cout << endl; cout << setprecision(12) << 12.3456789012345 << endl;
return 0;}
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Zur 3. Aufgabe
// -------------------------------------------------------------// Datei: datum.h// Zweck: Definition der Struktur Datum und// Deklaration zugehoeriger Funktionen.// -------------------------------------------------------------
#ifndef _DATUM_#define _DATUM_
// Falls Typ bool noch nicht definiert:// #define bool int// #define false 0// #define true 1
struct Datum { int tag, monat, jahr; };
// Prototypen: void showDate(Datum dat);bool getDate(Datum *p);void actDate(Datum *p);bool isLeapYear(int year);
#endif
// -------------------------------------------------------------// Datei: datum.cpp// Zweck: Definition der Funktionen fuer die Struktur Datum.// -------------------------------------------------------------
#include "datum.h"#include <time.h>
#include <iostream>using namespace std;
// -------------------------------------------------------------// showDate(): Datum anzeigen
void showDate(Datum dat){ cout << dat.tag << '.' << dat.monat << '.' << dat.jahr << endl;}
Erste Schritte mit C++ 65
66
2.14 Lösungen (Fortsetzung)
Zur 3. Aufgabe (Fortsetzung)
// -------------------------------------------------------------// getDate(): Datum im Dialog einlesen// Return-Wert: true, falls Eingabe ok// false sonst.
bool getDate(Datum *p){ static int tageImMonat[] = { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; int tag=0, monat=0, jahr=0;
cout << "\nTag: "; cin >> tag; if(tag < 1 || tag > 31) return false;
cout << "Monat: "; cin >> monat; if(monat < 1 || monat > 12 || tag > tageImMonat[monat]) return false;
cout << "Jahr: "; cin >> jahr; if(jahr < 1 || (!isLeapYear(jahr) && monat == 2 && tag == 29) ) return false;
p->tag = tag; p->monat = monat; p->jahr = jahr;
return true;}
// -------------------------------------------------------------// actDate(): Das aktuelle Datum holen.
void actDate(Datum *p){ struct tm *systime; time_t sec;
time(&sec); systime = localtime(&sec);
p->tag = systime->tm_mday; p->monat = systime->tm_mon + 1; p->jahr = systime->tm_year + 1900;}
C++ – Alles zur objektorientierten Programmierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// -------------------------------------------------------------// isLeapYear(): Stellt fest, ob ein Schaltjahr vorliegt.// Return-Wert: true, falls ja// false, falls nein
bool isLeapYear(int year){ return (year%4 == 0 && year%100 != 0) || year%400 == 0;}
// -------------------------------------------------------------// Header-Datei person.h// Modulare Programmiertechnik einsetzen.// -------------------------------------------------------------
#ifndef _PERSON_#define _PERSON_
#include "datum.h"
struct Person{ char name[32]; char vorname[24]; Datum geb;};
// Die Prototypen:bool getPerson(Person *p);void showPerson( Person pers);
#endif
Erste Schritte mit C++ 67
68
2.15 Lösungen (Fortsetzung)
Zur 3. Aufgabe (Fortsetzung)
// -------------------------------------------------------------// Datei: person.cpp// Zweck: Definition der Funktionen fuer die Struktur Person// -------------------------------------------------------------#include "person.h"#include <iostream>#include <iomanip>using namespace std;
bool getPerson(Person *p){ cout << "\nBitte Daten einer Personen eingeben.\n";
cout << "\nNachname: "; cin >> setw(31) >> p->name;
cout << "\nVorname: "; cin >> setw(23) >> p->vorname;
cout << "\nGeburtstag: "; return getDate(&(p->geb));}
void showPerson(Person pers){ cout << "\n\n\n" << "Die Personen-Daten:" << endl; cout << "-------------------" << endl; cout << "\tName: " << pers.name << endl; cout << "\tVorname: " << pers.vorname << endl; cout << "\tGeburtstag: "; showDate(pers.geb);}
// -------------------------------------------------------------// Datei: person_t.cpp// Zweck: Mit Strukturen vom Typ Person und Datum arbeiten// und modulare Programmiertechnik einsetzen.// Module: person_t.cpp person.cpp datum.cpp// -------------------------------------------------------------#include "person.h"#include <iostream>using namespace std;
int main(){ Person pers; if (!getPerson(&pers)) cerr << "\nFehler bei der Eingabe!\n"; else showPerson(pers);
return 0;}
C++ – Alles zur objektorientierten Programmierung
Die CD zum Buch
Im folgenden erhalten Sie eine kurze Übersicht über den Inhalt der CD. Weitere Hinweise fin-den Sie in der Datei LiesMich.txt oder LiesMich.htm im Hauptverzeichnis der CD. Details zurInstallation eines Compilers stehen in einer LiesMich-Datei im entsprechenden Unterver-zeichnis. Die beiliegende CD enthält folgende Unterverzeichnisse:
Buch.src
Hier befinden sich die Lösungen zu den Aufgaben im Buch nach Kapiteln geordnet. So enthältz.B. das Verzeichnis Kap05 die Lösungen zu den Aufgaben aus dem 5. Kapitel.
Borland\BorlandCommandLineTools
In diesem Verzeichnis befindet sich der Borland C++ Compiler 5.5 (BCC32). Dieser frei ver-fügbare Compiler wird aus der Kommandozeile aufgerufen. Er ist der Kern von Borland's C++Compiler Technologie und wird z.B. auch vom Borland C++ Builder 5 Enterprise verwendet.Zur Installation rufen Sie in diesem Verzeichnis das Programm FreeCommandLineTools.exeauf.
cygwin
Hier befindet sich der GNU C++ Compiler für Windows von der Firma Cygwin. Dieser Com-piler ist besonders für Freunde von UNIX zu empfehlen, da er auch UNIX-Systemaufrufe, z.B.fork(), unterstützt. Außerdem wird neben dem Compiler eine UNIX Umgebung bereitgestellt.So ist beispielsweise die Ausführung von Shell-Skripten möglich. Zur Installation rufen Sie indiesem Verzeichnis das Programm full.exe auf.
CREdit
Sofern Sie nicht schon einen eigenen Editor zur Erstellung von C++ Programmen verwenden,können Sie diesen modernen, frei verfügbaren Programm-Editor einsetzen. Er unterstütztSyntax-Highlighting und ermöglicht den direkten Aufruf eines Kommandozeilen Compilers.Zur Installation rufen Sie in diesem Verzeichnis das Programm setup.exe auf.
Borland\CBuilder5
In diesem Verzeichnis befindet sich eine Trial Version des Borland C++Builder 5 Enterprise, d.i.eine integrierte Entwicklungsumgebung für C++ mit zahlreichen Tools. Die Trial Version erfor-dert eine Registrierung bei Borland und kann dann 60 Tage benutzt werden.
Zur Installation rufen Sie in diesem Verzeichnis das Programm install.exe auf. Sie werden dannzur Registrierung aufgefordert und erhalten anschliessend per email von Borland ein Passwort.Mit diesem Passwort kann die Installation abgeschlossen werden.
Die CD zum Buch 763
Index
!#define 574#ifndef 101#include 574__cplusplus 353
AAbbau
von Objekten 263Ableitung
direkte 255mehrfache 323
abort() 453, 455abs() 722, 737Absolutbetrag
einer komplexen Zahl 722abstrakt
Klasse 303Abstraktion 23Access Declaration 271acos() 739Ada 29Adapter
-Klasse 658Addition 756adjacent_find( ) 702adjustfield 520, 632, 633Adresse 598Adressoperator 598
& 81Alert 578Algol68 29Algorithmen-Bibliothek 699Algorithmus
Binary-Search 357Bubble-Sort- 381Euklid 245für sortierte Mengen 713Heap-Sort- 479, 481, 715Laufzeit 656Mengen-Operationen 714Permutationen 712Quick-Sort- 357, 479Rotieren 709
Selection-Sort- 371Transformation 706Verteilungen 708Zerlegungen 711zum Ersetzen 707zum Füllen 707zum Kopieren 704zum Löschen 708zum Mischen 713zum Sortieren 710zum Suchen 701zum Tauschen 706
Aliasnamebei Referenzen 81für Namensbereich 351
Allokator 612-Klasse 658-Zugriff 665
Anfangswert 179, 578ANSI
Komitee 29-Standard 243, 293, 345, 377
Anweisungbreak 593continue 593do-while 591for 590goto 593if-else 591return 574, 594switch 592while 590
any( ) 694app 542, 634append() 475, 617apply() 734arg() 722Argument 595
Default- 71, 403-Liste 403Objekt 127Typüberprüfung 55von Funktions-Templates 379von Klassen-Templates 401
Index 765
766
Array 133assoziativer 213, 221von Objekten 133
array 596ASCII-Code 577asin() 739assign( ) 616, 618, 666, 671, 676assoziativer Array 213at( ) 473, 614, 662, 664, 669atan() 739atan2() 739ate 542, 634Aufbau
von Objekten 107, 299Aufruf
Funktions- 595impliziter 111-Konvention 71-Konventionen 83redefinierter Methoden 267von Destruktoren 299von Konstruktoren 329von Operatorfunktionen 207
Aufzählung 57Ausdruck 586
boolscher 59mit Referenztyp 85
Ausgabe 45formatierte 580Gleitpunktzahl 582in Dateien 543-puffer leeren 528, 529, 644rechts-/linksbündig 581-Streams 509unformatierte 515von booleschen Werten 529von Ganzzahlen 523von Gleitpunktzahlen 524, 525von String-Streams 551
Ausnahme-Behandlung 419Auswahloperator 589, 757
Bback( ) 664, 669, 674, 680Backslash 577Backspace 578bad() 516, 519, 635
bad_alloc 718bad_cast 489bad_exception 453bad_typeid 497badbit 516, 632basefield 520, 632Basic Types 575basic_filebuf 629basic_ifstream 628basic_ios 628basic_istream 628basic_istringstream 628basic_ofstream 628basic_ostringstream 628basic_streambuf 628, 629basic_string 465, 611basic_stringbuf 629basic_stringstream 628Basis
interner Darstellung 749Basisinitialisierer 265, 329Basisklasse 27, 253
direkte 255, 325indirekte 255, 325mehrfache 325virtuelle 327, 491
Basisklassenzeiger 287Baum
binärer 479Höhe 478optimal 478
beg 635begin( ) 665, 670, 675, 685, 689Behandlung
von Fehlern 419Bell Labs 572Bereich
privater 99public- 99
Bereichsoperator 51, 183, 261, 267, 345, 757Bereichsüberprüfung
durch Zugriffsmethoden 121für Strings 473
BetriebssystemUnix 572
Bewertungbedingte 757
Index
Bezeichner 347, 580globaler 349Read-Only- 81
BibliothekAlgorithmen- 700C- 353I/O-Stream- 627iostream- 43, 505Klassen- 295numerische 717String- 465, 611zur Sprachunterstützung 747
bidirektionalIterator 660
binär 586Binärmodus 607binary 542, 634BinaryPredicate 678binarySearch() 381Bindung
dynamische 295frühe 295späte 295statische 295
Bindungsinformation 353Bit
-Operator 588Bitfeld 520, 521, 524, 632Bit-Operatoren 756Bitset
Container 657bitset<N> 659, 693Blatt 478Block 51
catch- 423try- 423
Blockweise I/O 545bool 59, 588boolalpha 529, 633, 639break 593BS 578bsearch() 357Bubble-down 479Bubble-Sort-Algorithmus 381Bubble-up 479
CC 29
-Compiler 353-Erweiterungen 31, 69-Funktion in C++-Programmen 353-Header-Datei 353-Module in C++-Programmen 353Programmiersprache 572Standardbibliothek 572-String 155, 465
C++Eigenschaften 31Geschichte 29Programmerstellung 33Unterschied zu C 45, 51, 53, 57, 75
c_str() 471, 616Call
by Reference 83, 127, 596by Value 79, 127, 596
Call by reference 600, 603Call by value 603calloc() 604capacity( ) 469, 614, 665Carriage Return 578case 593Cast
const- 495Cross- 491Down- 487, 493in void* 491-Operatoren 756reinterpret- 495statischer 493Up- 487, 493
Cast-Operator 589catch 423cctype 612cerr 43, 45, 511, 631cfloat 748char 575CHAR_MAX 753CHAR_MIN 753charT 612, 628cin 43, 47, 511, 631class 99
base 253derived 253
Index 767
768
Clean up 111clear( ) 516, 519, 615, 635, 666, 667, 670, 672, 675, 677, 686, 691
climits 748clog 43, 511, 631close() 542, 650, 651, 652Clu 29Code
ASCII 577Exit- 574Zeichen- 581
ComissionInternational Electrotechnical 750
Comparator-Klasse 658
compare() 622Compiler 33Compilierung
bedingte 353complete 486complex 718conj() 722const 75, 181, 495, 497, 601
Methode 123-Objekt 75-Parameter 75, 79-Zeiger 77
const_cast 495const_iterator 660const_reverse_iterator 660const-Cast 495, 756Container 657
assoziativer 657, 659-Klasse 391, 658sequentieller 657, 658
Container-Bibliothek 655Container-Klasse 487continue 593copy( ) 616, 704copy_backward( ) 704copyfmt() 638cos() 724, 738cosh() 725, 739Cosinus 724, 739
Hyperbolicus 725, 739Cotangens 724count( ) 687, 691, 694, 703count_if( ) 703
cout 43, 45, 509, 511, 631CR 578Cross Cast 491cshift() 734cstdlib 612cstring 612Ctrl-D 513Ctrl-Z 513cur 635cwchar 612cwtype 612
DDarstellung
als Festpunktzahl 525exponentielle 525interne 749
data() 471, 616Datei
aktuelle Position 607ausführbare 33binäre 607Ein-/Ausgabe 543-Ende 48, 585eröffnen 543, 605Header- 33-Name 543Objekt- 33-Offset 609Quell- 33schließen 543-Stream 543-Zugriff, sequentieller 545-zugriff, wahlfrei 547
Dateiende 583Dateiverarbeitung 543Dateizugriff
wahlfrei 609Datenabstraktion 21, 23, 99, 253Datenelement
konstantes 181statisches 183
Datenkapselung 21, 25, 99, 187, 255, 269Datensatz 602Datentyp 497
bool 59char 575
Index
double 576elementarer 575float 576-Hierarchie 237int 575Klasse 99long 575long double 576Referenz 81short 575size_t 356, 589von Konstante 576
DBL_DIG 753DBL_EPSILON 753DBL_MANT_DIG 753DBL_MAX 753DBL_MAX_10_EXP 753DBL_MAX_EXP 753DBL_MIN 753DBL_MIN_10_EXP 753DBL_MIN_EXP 753dec 60, 520, 522, 632, 639Default
-Konstruktor 109, 119, 133, 263-New-Handler 153
Default-Argument 71von Templates 403
default-Marke 593Definition
abgeleiteter Klassen 255Funktion 594Variable 578von Destruktoren 111von Funktions-Templates 369von Konstruktoren 107
Deklarationconst 79extern 353friend 187, 189Plazierung 51private 25public 25using- 347virtueller Basisklassen 327von Destruktoren 111von Funktionen 53von Funktions-Templates 373von konstanten Objekten 75
von konstanten Zeigern 77von Konstruktoren 107von Objekten 103von Referenzen 81von Variablen 51von Zeigern auf konstante Objekte 77
Dekrement-Operator 586
delete 145, 149, 757klassenspezifisch überladen 219überladen 215
denorm_min() 752Deque
Container 657deque<T> 658, 669Design
von Klassenhierarchien 327Destruktor 103, 111
abgeleiteter Klassen 265Aufruf-Reihenfolge 299Minimal-Version 111virtueller 299
dezimalKonstante 576
Dezimalpunktanzeigen 525
Dezimalzahl 576Diagramm
Vererbungs- 329Differenzmenge 714
symmetrische 714digits 749digits10 749direkt
Ableitung 255Direktive
#define 574#define- 75using- 347
Division 586, 756Modulo- 586
double 576Down Cast 487, 493Draft Proposal 29dynamic_cast 489dynamisch
Bindung 295
Index
770
EEditor 33Eiffel 31Ein-/Ausgabe
Streams 505Einfügen
in Deques 671in Listen 676in Maps 690in Queues 681in Sets 687in Stacks 683in Vektoren 667
Eingabe 47-Operator 511-Puffer 584unformatierte 513von Dateien 543von Strings 49von String-Streams 551Zahlen 583Zeichen 583
Eingabefeld 583Einlesen
unformatiertes 513von Dateien 543
Elementdynamisches 155, 305eines Namensbereichs 345private- 99protected 269public- 99Vektor- 596
Elementfunktion 23, 99abgeleiteter Klassen 259const- 123Definition 101inline- 119Redefinition 261virtuell 289von Klassen-Templates 395
Elementinitialisierer 265für Standardtypen 181für Teilobjekte 179
Elementzeiger 191Dereferenzierung 757
else-if-Kette 592
else-Zweig 591empty( ) 675, 680, 682, 684, 686, 690end 635end( ) 665, 670, 675, 685, 689endl 60, 529, 644Endlosschleife 591ends 529, 644enum 57Enumeration 57EOF 49, 583eof() 516, 519, 635, 641eofbit 516, 632epsilon() 752equal( ) 703equal_range( ) 687, 691, 713erase( ) 475, 618, 667, 672, 677, 686, 691Ergebnistyp
einer Funktion 73virtueller Funktionen 293
Eröffnungsmodus 517Datei- 543
Ersatztextueller 55
Ersatzbezeichnerbei Referenzen 81
Ersatztext 574Ersetzungsverfahren 707Erweiterbarkeit 505Escape-Sequenz 578Exception 144
auffangen 423auslösen 421auswerfen 427bad_alloc 215, 718bad_cast 489der Standard-Bibliothek 449failure 507-Handler 423-Handler, genereller 425klassenspezifische 433length_error 612-Liste 451matching 427nicht behandelte 429out_of_range 612-Spezifikation 451-Spezifikation virtueller Funktionen 457
Index
-Spezifikation, fehlende 457unerwartete 453weitergeben 429
exception 449Header-Datei 453
Exception-HandlingKonzept 419Standard- 449
exceptions() 636Exit
-Code 574exit() 453exklusiv-ODER 588exp() 725, 740explicit 243explizit
Inline 119Instantiierung 405Instantiierung von Funktions-Templates 379Typumwandlung 237
Exponenteiner Gleitpunktzahl 749
Exponentialfunktion 725, 740exponentielle
Notation 577extern 353
Ffail() 516, 519, 635failbit 516, 519, 543, 632failure 507, 628false 59fclose() 606Fehler
-arten 447Ausgabe- 515-Behandlung 144, 153-Check bei Templates 397-klassenhierarchie 447logischer 447-meldung 507-Meldungen 45-Objekt 421-Objekt, erzeugen 427-Objekt, initialisieren 431-Objekt, zerstören 429-Situationen 419
Fehlerbehandlung 419Ein-/Ausgabe- 47konventionelle 419
Fehlerklasse 421, 431bad_typeid 497exception 449failure 507, 628, 631logic_error 447out_of_range 449OutOfRange 431
FehlerklassenStandard- 447
Fehlersuche 574Feld
-ausrichtung 521, 527-breite 527
Feldbreite 581, 582, 584feof() 608fflush() 584fgetc() 607fgets() 608FIFO-Prinzip 393, 657filebuf 507, 630, 650FILE-Pointer 606File-Stream 543fill( ) 527, 637, 707fill_n( ) 707Filterprogramm 514find( ) 477, 619, 687, 691, 701find_ first_of() 620find_end( ) 703find_first_not_of() 621find_first_of( ) 701find_if( ) 701find_last_not_of() 621find_last_of() 620first 687fixed 524, 633, 639Flächenberechnung
geometrischer Figuren 89Flag
von ios 517flags() 520, 521, 636flip( ) 668, 694float 576float.h 576float_round_style 751floatfield 520, 524, 632, 633
Index 771
772
FLT_DIG 753FLT_EPSILON 753FLT_MANT_DIG 753FLT_MAX 753FLT_MAX_10_EXP 753FLT_MAX_EXP 753FLT_MIN 753FLT_MIN_10_EXP 753FLT_MIN_EXP 753FLT_RADIX 753flush 60, 529, 644flush() 515, 643fmtflags 632fopen() 605for 590for_each( ) 701Form Feed 578Format
-Element 580-Flags von ios 509, 521, 632-Flags, Zugriff 521-String 580-Variable 521
Formatierung 61I/O- 521von Ganzzahlen 523von Gleitpunktzahlen 525
Forward-Iterator 660fprintf() 608fputc() 607fputs() 608free() 145, 605Freigabe
von Speicherplatz 149Freispeicher 145friend
-Funktion 187-Klasse 189-Technik 189
front( ) 664, 669, 674, 680Front-Compiler 33fscanf() 608fseek() 609fstream 505, 543, 629, 630, 652ftell() 610Füllen 707Füllzeichen 527
Funktion 572Aufruf 595Definition 594Deklaration 595Element- 99elementare 724, 737Familien 367friend- 187globale 101Hyperbel- 725, 739Inline- 55inverse trigonometrische 739Konvertierungs- 241main() 572, 573, 594Name 594Operator- 205rein virtuelle 301rekursiv 595transzendente 737trigonometrische 724, 739überladen 73virtuelle 289
Funktionsblock 574Funktionsobjekt 662, 700Funktions-Template 367
Definition 369verschachtelte 371
fwrite() 608
GGanzzahl 576
Ausgabe 580-Erweiterung 57
gcount() 512, 647Geltungsbereich 51
globaler 345Genauigkeit 576, 582, 749
von Gleitpunktzahlen 525generate( ) 707generate_n( ) 707Generator 700Generierung
von Template-Funktionen 371get() 49, 512, 545, 646get_allocator( ) 665, 671, 674, 685getc() 607getchar() 584
Index
getline() 49, 512, 626, 646getloc() 637, 642gets() 585get-Zeiger 545Gleichung
quadratische 89Gleitpunkt
-Konstante 576-Zahl 577
Gleitpunkttyp 575Gleitpunktzahl
Ausgabe 525, 582normalisierte Form 750
globalVariable 579
good() 516, 519goodbit 516, 632goto 593Grenzwerte
numerische 747gslice 741, 742gslice_array 744, 746
HHandler
terminate- 455unexpected- 453
has_denorm 750has_denorm_loss 750has_infinity 750has_quiet_NaN 750has_signaling_NaN 750Hat
-Beziehung 253Header-Datei 33, 55, 101, 353, 574
bitset 662C 572cctype 612cfloat 748, 753climits 748, 753complex 718cstdlib 612cstring 612cwchar 612cwtype 612deque 662exception 453
float.h 576fstream 543iomanip 61iostream 43, 511limits 748limits.h 575list 662map 662math.h 573queue 662set 662stack 662Standard- 596stddef.h 599stdexcept 449, 453stdio.h 584, 599string 612type_info 497und Namensbereiche 351und Templates 373valarray 718vector 662
Heap 145, 478, 715Bedingung 478-Sort-Algorithmus 481, 715
hex 60, 520, 522, 632, 639hexadezimal
Konstante 576Hexadezimalzahl 576Hierarchie
von Datentypen 237von Fehlerklassen 447von ios-Klassen 505
Höheeines Baumes 478
HT 578Hybrid-Sprache 31Hyperbelfunktion 725, 739
II/O-Stream 505
-Bibliothek 627Identifier 580IEC 559 Norm 750IEEE 576if-else 591ifstream 391, 505, 543, 629
Index 773
774
ignore() 512, 647imag() 720, 722Imaginärteil 720imanip 533imbue() 637Implementierung
einer sortierten Liste 409einer Warteschlange 393eines Heaps 481eines Stacks 407einfach verketteter Listen 310mehrfache 367von Persistenz 555von Verschlüsselungsverfahren 553
implizitinline 119Instantiierung von Funktions-Templates 379Typumwandlung 237
in 542, 634in_avail() 641Include-Datei 33includes( ) 714Index 597Index-Operator 473, 757
verallgemeinerter 731Indexoperator 600indirect_array 744, 746indirekt
Basisklasse 255Indizierung
indirekte 746maskierte 746selektive 741verallgemeinerte selektive 744
Initialisierungabgeleiteter Klassen 263bei Mehrfachvererbung 329n-dim. Vektor 598-sliste 109Struktur 602Variable 579Vektor 597von Objekten 103, 107, 179von Referenzen 81von Teilobjekten 179von Vektoren 133
Initialisierungliste 133, 179
InkrementOperator 586
inline 55, 119Destruktor 119explizit 119-Funktion 55Funktions-Templates 371implizit 119Konstruktor 119Methode 119
inplace_merge( ) 714Input-Iterator 660insert( ) 475, 617, 667, 671, 687, 690Instantiierung
explizite von Templates 405von Template-Funktionen 371von Template-Klassen 397
Instanz 103einer Klasse 23
int 575INT_MAX 753INT_MIN 753Integer Types 575Interface
Basisklassen- 293öffentliches 119polymorphes 303Programmers- 509public- 257
internal 527, 633, 639iomanip 529, 630ios 505, 507, 629, 630
-Flags 517-Klassenhierarchie 505
ios::failure 507ios_base 628ios_traits 628ios-Manipulatoren 522iostate 517, 632iostream 629, 630, 649
-Bibliothek 43is_bounded 751is_exact 749is_iec559 750is_integer 749is_modulo 751is_open() 542, 650, 651, 652is_signed 749
Index
is_specialized 749ISO/IEC 572ISO/IEC-Norm 572ISO-Standard 29Ist
-Beziehung 253-Beziehung bei Mehrfachvererbung 323
istream 391, 505, 511, 513, 629, 630, 645istringstream 391, 505, 549, 629istrstream 549iter_swap( ) 706Iterator 656, 660, 699
bidirektionaler 660Random-Access- 660
KK&R-Standard 572Kante 478Kapazität
von Strings 469Kellerstapel 657, 682Kette
else-if 592Klasse 23, 99
abgeleitete 27, 253abstrakte 303Adapter- 658Adresse 113, 165Airplane 331Allokator- 658Angestellter 273Arbeiter 273Artikel 107, 257bad_exception 453Basis- 253Bruch 221Comparator- 658Complex 239Container- 391, 658Datum 127Elektro 257Fehler- 421, 431Firma 193, 309friend- 189Instanz 23KombiKonto 329
konkrete 303Konto 193, 301polymorphe 487Stream- 391String 155Verschachtelung 177
Klassen-Array 133Klassenbibliothek 295, 345Klassenhierarchie 27, 255
Design 327ios 505Typumwandlung in 487
Klassen-Template 391basic_fstream 628basic_ifstream 628basic_ios 628basic_iostream 628basic_istream 628basic_istringstream 628basic_ofstream 628basic_ostream 628basic_ostringstream 628basic_string 465, 611basic_stringstream 628complex 719Definition 393gslice_array 744imanip 533indirect_array 744mask_array 744numeric_limits 747omanip 533slice_array 744, 745smanip 533SortList 409Stack 407string_char_traits 612valarray 729
Klassenvariable 183Knoten 478
innerer 478Kommaoperator 589, 757Kommentar 41, 574Kompatibilität 29konkret
Klasse 303konstant 181
Index 775
776
Konstante 57case- 593ganzzahlige 576Gleitpunkt- 576String- 576, 577symbolische 57, 75, 574
Konstanzwegcasten 495
Konstruktor 103, 107abgeleiteter Klassen 263abstrakter Klassen 305Aufruf 109Aufruf-Reihenfolge 177, 329Default- 109, 119, 263für Teilobjekt 177Konvertierungs- 239Kopier- 161Minimal-Version 109überladen 107
Konvertierungabgeleiteter Klassen 285
Konvertierungs-Funktion 241-Konstruktor 239
Kopierkonstruktor 161abgeleiteter Klassen 305abstrakter Klassen 305
Kopierverfahren 704Kosekans 724
LLänge
von Strings 469Laufbedingung 590Laufzeit 656
Typinformation 488, 497Laufzeitfehler 447LDBL_DIG 753LDBL_EPSILON 753LDBL_MANT_DIG 753LDBL_MAX 753LDBL_MAX_10_EXP 753LDBL_MAX_EXP 753LDBL_MIN 753LDBL_MIN_10_EXP 753LDBL_MIN_EXP 753left 527, 633, 639
length( ) 469, 614length_error 471, 612Lese
-Zeiger 545Lesen
aus Dateien 543blockweises 545von String-Streams 551
lexicographical_compare( ) 711LF 578LIFO-Prinzip 407, 657limits 748limits.h 575Linker 33linksbündig
Ausgabe 527linksorientiert 478Links-Shift 709list<T> 658, 674Liste
Container- 657einfach verkettete 310Parameter 594sortierte 409
LiteralString- 577
locale 637Löschen 708
in Deques 672in Listen 677in Maps 691in Queues 681in Sets 686in Stacks 683in Vektoren 667
log() 725, 740log10() 725, 740Logarithmus 725, 740logic_error 447lokal
Variable 579long 575long double 576LONG_MAX 753LONG_MIN 753lower_bound( ) 687, 691, 713lvalue 493L-Wert 493
Index
Mmain() 572, 573, 594make_heap( ) 715Makro 55, 574
feof() 608malloc() 87, 145, 604Manipulator 509, 522, 529
Ein-/Ausgabe 60-Funktion 531selbstdefinierter 531, 533von ios 524, 639von istream 647von ostream 644
Mantisse 750Map 689
Container 657map<Key, T> 659map<T> 689Marke 593
case- 593default- 593private 99public 99
Maschinencodevon Funktions-Templates 369von Template Methoden 397von Template-Funktionen 371
MascittiRick 29
mask_array 744, 746Maske
boolesche 746math.h 573Matrix 597max( ) 709, 734, 737, 752max_element( ) 709max_exponent 750max_exponent10 750max_size( ) 469, 614, 665, 670, 675, 686, 690
Maximum 709Mehrdeutigkeit
bei Default-Argumenten 73bei Mehrfachvererbung 325bei Typumwandlung 243von Namen 347
mehrdimensional 598
Mehrfachvererbung 323Mehrfachzuweisung 163, 587
von Strings 467Mengen-Operationen 714merge( ) 677, 713Methode 23, 99
abgeleiteter Klassen 259const- 123Definition 101friend- 187inline- 119Read-Only- 123redefinieren 257, 261statische 185von Klassen-Templates 395Zugriffs- 121
Methodentabellevirtuelle 297
min( ) 709, 734, 737, 752min_element( ) 709min_exponent 749min_exponent10 749Minimum 709Mischen 713
von Listen 677mismatch( ) 702Modul 33, 101
C- 353und Templates 373
Modulodivision 586, 756Modulo-Typ 751Modus
Binär- 607multimap<Key, T> 659multimap<T> 692Multiple Inheritance 323Multiplikation 756multiset<T> 659, 688
NNachfolger 478Name 580
Datei- 543Funktion 594Template- 393
name() 497
Index 777
778
NamenKonflikt 349Suche 349von Klassen 99
Namensbereich 345Aliasname 351anonymer 351std 43, 349unbenannter 351verschachteln 349
Namenskonflikt 345namespace 345narrow() 637new 145, 147, 757
klassenspezifisch überladen 219überladen 215
New-Handler 153, 167, 215temporärer 153
next_permutation( ) 712next-Zeiger 640NICHT 587
boolsches 59noboolalpha 639none( ) 694Norm
ISO/IEC- 572norm() 722noshowbase 522, 639noshowpoint 639noshowpos 522, 639noskipws 639Notation
exponentielle 577Präfix-/Postfix- 586
nouppercase 522, 639npos 477, 613nth_element( ) 711NULL 599numeric_limits 747
OObjekt 21, 23, 103
abgeleiteter Klasse 267Adresse 129als Argument 127, 129als Klassenelement 177als Return-Wert 131
const- 123degeneriertes 743dynamisch erzeugen 151Fehler- 421Funktions- 662konstantes 81persistent 554Read-Only 75, 123-sammlung 655temporäres 238vollständiges 486Wide-Stream- 391
Objektdatei 33objektorientiert 21oct 60, 520, 522, 632, 639ODER 587
boolsches 59exklusiv 588
ofstream 391, 505, 543, 629oktal
Konstante 576Oktalzahl 576omanip 533OOP 21open() 542, 650, 651, 652openmode 634Operand 586Operationen
für Listen 677Splice- 677
Operator 51, 261, 267, 586- 723, 735- (unär) 724, 732! 59, 635, 732!= 59, 497, 625, 723, 736% 735%= 733& 81, 735&& 59, 736&= 733( ) 209* 723, 735*= 720, 733+ 465, 624, 723, 735+ (unär) 724, 732+= 475, 623, 720, 733. 105.* 191, 202
Index
/ 723, 735/= 720, 733< 59, 465, 625, 736<< 45, 211, 465, 509, 624, 644, 722, 735<<= 733<= 59, 465, 625, 736-= 720, 733= 163, 209, 615, 720, 732== 59, 497, 625, 723, 736-> 105, 209> 59, 465, 625, 736->* 191>= 59, 465, 625, 736>> 47, 211, 465, 511, 624, 648, 722, 735>>= 733^ 735^= 733| 735|= 733|| 59, 736~ 732Adress- 598arithmetischer 586Auswahl 757Auswahl- 589Bereichs- 51, 757Bit- 588, 756Bitset- 697bool() 643Cast- 237, 589, 756Dekrement 586Dekrement- 756delete 145, 151, 612, 757dynamic_cast 489-Funktion 205Index- 213, 757Inkrement- 586, 756Komma 589Komma- 757logischer 587, 756new 145, 151, 612, 757NICHT 588NICHT- 695ODER 588Pfeil- 105, 603, 757Punkt- 105, 603, 757reinterpret_cast 495Sequenz 589
Shift- 588, 696, 756sizeof 202, 757sizeof() 589, 597static_cast 493typeid() 497, 757überladen 203-Überladung 85UND 588Vergleichs- 59, 587, 756Verweis- 598, 757Vorrangtabelle 758Vorzeichen 586Zugriffs- 191, 757Zuweisungs- 163, 587, 756
operator 241Operatorenübersicht 756Operatorfunktion
virtuelle 307optimal
Baum 478ostream 391, 505, 509, 515, 629, 630ostringstream 391, 505, 549, 629ostrstream 549out 542, 634out_of_range 471, 473, 612OutOfRange 431Output-Iterator 660Overhead 297Overloading 73
Ppair<T1, T2> 687Paradigmen
der OOP 21Parameter 594
const- 601konstanter 79von Funktions-Templates 369von Klassen-Templates 399
partial_ sort( ) 710partial_ sort_copy( ) 710partition( ) 711Partitionierung 711peek() 647Permutationen 712Persistenz
von Objekten 554
Index 779
780
Pfeiloperator 105, 603, 757Plazierung
von Deklarationen 51Pointer 598
FILE- 606polar() 722Polarkoordinaten 722Polymorphie 21, 27, 99, 289, 297pop( ) 407, 683, 684pop_back( ) 672, 677, 681pop_front( ) 672, 677pop_heap( ) 715Position
in Datei 547Zugriff 665
Positionierenabsolutes 547ios-Funktionen 547relatives 547
Postfix-Notation 586pow() 724, 738Präprozessor 55Präfix-Notation 586Präprozessor 573precision() 525, 636Predicate 678prev_permutation( ) 712printf() 43, 580Priorität 586Priority Queue 684, 715
Container 657priority_queue<T> 659, 684private 25, 99, 259, 271, 323Programmiersprache
C 572Programmierung
modulare 101objektorientierte 21prozedurale 21
protected 269, 271, 323Prototyp 53, 573
von Funktions-Templates 373pubimbue() 642public 25, 99, 255, 271, 323
-Interface 257pubseekoff() 640pubseekpos() 640pubsetbuf() 640
pubsync() 640Puffer 640
basic_filebuf 629basic_streambuf 628, 629basic_stringbuf 629-verwaltung 507Zeilen- 584
Punktoperator 105, 603, 757push( ) 407, 683, 684push_back( ) 667, 671, 676, 681push_front( ) 671, 676push_heap( ) 715put() 515, 545, 643putback() 512, 647putc() 607putchar() 585puts() 585put-Zeiger 545
Qqsort() 357Quadratwurzel 724Quelldatei 33
C 572Queue 393
Container 657queue<T> 659, 680Quick-Sort-Algorithmus 357quiet_NaN() 752
Rradix 749random_shuffle( ) 708Random-Access
-Iterator 660rbegin( ) 665, 670, 675, 685, 689rdbuf() 542, 638, 651, 652, 654rdstate() 516, 519, 635read() 512, 646Read-Only
-Bezeichner 81Methode 123Objekt 75, 123
readsome() 512, 646real() 720, 722realloc() 604Realteil 720
Index
rechtbündigAusgabe 527
Rechts-Shift 709Redefinition
virtueller Funktionen 291von Klassenelementen 261von Methoden 257, 261
Referenz 81als Parameter 83, 127als Return-Wert 85auf abstrakte Klasse 303auf Basisklasse 287auf ein konstantes Objekt 127-Parameter 83und Zeiger 81
Reihenfolgevon Konstruktor-Aufrufen 329
rein virtuellFunktion 301
ReinitialisierungSchleife 591
reinterpret_cast 495, 756rekursiv 595remove( ) 678, 708remove_copy( ) 705remove_if( ) 678, 708rend( ) 665, 670, 675, 685, 689replace( ) 477, 618, 707replace_copy( ) 705replace_if( ) 707reserve( ) 469, 615, 666reset( ) 694resetiosflags() 639resize( ) 469, 615, 666, 670, 675, 734return 574, 594Return-Wert 595
const-Zeiger 79reverse( ) 678, 706reverse_copy( ) 704reverse_iterator 660rewind() 610rfind() 477, 619Richie, Dennis 572right 526, 633, 639Ring 395Ring-Shift 709rotate( ) 709rotate_copy( ) 709
round_error() 752round_indeterminate 751round_style 751round_to_infinity 751round_to_nearest 751round_toward_neg_infinity 751round_toward_zero 751RTTI 488Rückgabe
in Kopie 131von Referenzen 131
Run Time-Check 489-Type Information 488
Runden 751Rundungsfehler 752runtime_error 447rvalue 493R-Wert 493
Ssbumpc() 641scanf() 47, 583Schablone 367Schleife 590
Endlos- 591for 590
Schleifenrumpf 590Schlüssel 479, 553Schlüsselwort
catch 423class 99const 75, 181enum 57explicit 243extern 353friend 187inline 55, 119, 371namespace 345operator 241operator@ 205protected 269public 255static 183struct 99template 369, 393this 125
Index 781
782
throw 421try 423using 347virtual 289580
Schlüsselworte 759Schnittmenge 714Schnittstelle
öffentliche 99polymorphe 303von Manipulator-Funktionen 531
Schreib-Zeiger 545
Schreibenblockweises 545in Dateien 543in String-Streams 551unformatiertes 515
scientific 524, 633, 639search( ) 703search_n( ) 702second 687Secret Key
Verschlüsselungsverfahren 553Seek
-Zeiger 609seekdir 547, 635Seek-Funktionen 547seekg() 547, 645seekp() 547, 643Seiteneffekt 55Sekans 724Selection Sort Algorithmus 371Semikolon 575sentry 643, 645sequentiell
Dateizugriff 545Sequenzoperator 589Set 685
Container 657set( ) 694set<T> 659, 685set_difference( ) 714set_intersection( ) 714set_new_handler() 153set_symmetric_difference() 714set_terminate() 455set_unexpected() 453, 455
set_union( ) 714setbase() 529, 639setf() 60, 520, 521, 636setfill() 60, 529, 639setiosflags() 639setprecision() 60, 529, 639setstate() 516, 519, 635setw() 60, 61, 529, 639sgetc() 641sgetn() 641Shift
arithmetischer 589logischer 589Operator 589
shift() 734Shiften 709Shift-Operator
<< 45>> 47überladen 211
Shift-Operatoren 756short 575showbase 522, 634, 639showpoint 524, 634, 639
ios-Flag 524showpos 522, 634, 639SHRT_MAX 753SHRT_MIN 753signaling_NaN() 752Signatur 73
virtueller Funktionen 291virtueller Operatorfunktionen 307von const-Methoden 123von Konstruktoren 107
Simula67 29sin() 724, 738sinh() 725, 739Sinus 724, 739
Hyperbolicus 725, 739size( ) 469, 614, 665, 670, 675, 680, 682, 684, 686, 690, 694, 734
size_t 469, 589size_type 469, 661sizeof() 589, 597sizeof-Operator 202, 757Skalar 720, 732skipws 529, 633, 639slice 741
Index
slice_array 744, 745Smalltalk 31smanip 533snextc() 641Software-Entwicklung 21sort( ) 678, 710sort_heap( ) 715Sortieralgorithmus 367Sortieren 710
durch Austauschen 381durch Auswählen 371durch Zerlegen 357mit Heaps 715von Listen 678
Source-Datei 33Speicher
dynamischer 604freigeben 149, 605reservieren 145
Speicherklasse 51Speichermanagement 215, 223Speicherplatz
für Datentypen 575Speicherreservierung
für Vektoren 147Speicherverwaltung
dynamische 145für Klassen 151
Spezialisierungvon Template-Funktionen 375, 377
SpezifikationException- 451virtueller Funktionen 457
splice( ) 677Splice-Operation 677Sprachelemente
OOP-unabhängige 69Sprung
goto 593sputbackc() 641sputc() 642sputn() 642sqrt() 574, 724, 737sstream 630stable_ sort( ) 710stable_partition( ) 711Stack 407, 682
Container 657
-Unwinding 425, 429stack<T > 659stack<T> 682Stack-Unwinding 431Standard
ANSI 29ANSI- 243-Exceptions 449Header-Datei 596ISO 29K&R- 572-Kopierkonstruktor 161-Manipulator 529-Methoden 163-Streams 511-Zuweisung 163
Standard-Template-Library 656
Standardausgabe 43Standardbibliothek
C 572Standardeingabe 43Standardfehlerausgabe 43, 45Standardisierung
von C++ 29Standard-Klasse
failure 507filebuf 650fstream 652gslice 742ifstream 651ios 507, 632iostream 649istream 511, 513, 645istringstream 549, 654istrstream 549locale 637ofstream 651ostream 509, 515, 643ostringstream 549ostrstream 549sentry 643, 645slice 741streambuf 507string 465, 613stringbuf 549, 653stringstream 549strstreambuf 549
Index 783
784
type_info 497wstring 465
Standard-Streams 631Standardwert 71Stapel 407Startup-Code 33static 183static_cast 493statisch
Bindung 295Cast 493
Status-Flag 509, 517, 632von ios-Flags abfragen 519von ios-Flags ändern 519von Streams 517-Wort 517
Statusinformation 183std 43, 349stddef.h 599stderr 43, 607, 608stdexcept 449, 453stdin 43, 607stdio.h 584, 599stdiobuf 507stdout 43, 607Steuerzeichen 577, 607STL 656str() 653, 654strcat() 87strcpy() 87Stream 43, 605
cerr 511clog 511cout 509I/O- 505-Klassen 391, 627-Puffer 628, 640Standard- 511String- 549synchronisieren 515verbinden 515
streambuf 507, 630, 640String 155, 577
Ausgabe 582ausgeben 585-Bibliothek 465C- 465, 597
Ein-/Ausgabe 465Einfügen 475einlesen 584Endezeichen 584Ersetzen 477Erzeugen 467Exception Handling 471Kapazität 469konstanter 473Länge 469leerer 577-Literal 577Löschen 475-Stream 549Suche 477Teil- 471Typumwandlung 471Vergleich 465Verkettung 465
string 465, 612string_char_traits 612String-Bibliothek 611stringbuf 507, 549, 630, 653stringstream 391, 505, 549, 629strlen() 87strncpy() 87Stroustrup, Bjarne 29strstreambuf 549strtol() 436struct 41, 99, 602Struktur 41
Komponente 603-Variable 602Zuweisung 602
substr() 471, 618Subtraktion 756Suchalgorithmus 367Suche
binäre 381, 713Handler- 427in Maps 691in Sets 687in Strings 477Maximum 709Minimum 709Namens- 349obere/untere Schranke 713Versions- 375
Index
Suchverfahren 701binäres 357, 381, 713
Suffix 576sum() 734sungetc() 641swap( ) 477, 618, 625, 667, 668, 672, 673, 674, 679, 686, 688, 691, 692, 706
swap_ranges( ) 706switch 592symbolisch
Konstante 574Symmetrie
von Argumenten 207symmetrisch
Differenzmenge 714sync() 647sync_with_stdio() 638Synchronisierung
von I/O-Operationen 515
TTabulator 578tan() 724, 738Tangens 724, 739, 740
Hyperbolicus 725, 739tanh() 725, 739Tauschen 706
von Deques 672von Listen 674von Maps 691von Sets 686von Vektoren 667
Teilergrößter gemeinsamer 245
Teilmenge 714Teilobjekt 177, 255, 487Teilvektor 741tellg() 547, 645tellp() 547, 643Template
-Argument 379, 401Default-Argumente 403-Funktion 371Funktions- 367Hilfs- 744Klassen- 391-Parameter 369, 399
template 369, 393Template-Klasse
complex<double> 727complex<float> 726complex<long double> 728Instantiierung 397
Template-Library 656Templates
und Module 373terminate() 423, 429, 453, 455terminate_handler 455test( ) 694Textmodus 607this 125throw 421tie() 515, 638tinyness_before 751to_string( ) 696to_ulong( ) 696Ton 578Toolbox 241top( ) 682, 684transform( ) 706Transformation 706traps 751true 59trunc 542, 634try 423Typ
Aufzählungs- 57bad_cast 489bad_typeid 497bool 59char 465charT 612enum 57failure 507fmtflags 521, 632ios_traits 628iostate 517, 632Klasse 99Modulo- 751openmode 634-Parameter von Funktions-Templates 369Referenz 81seekdir 547, 635size_t 356, 730size_type 469
Index 785
786
terminate_handler 455type_info 497wchar_t 391, 465
Typ Siehe DatentypTypanpassung
bei Funktions-Templates 373Type mismatch 239type_info 497Type-Cast 237typeid() 497, 757Typfeld 289Typinformation 497
zur Laufzeit 488Typkonvertierung 237Typsicherheit 505Typumwandlung 57, 235, 237, 285
bei Zuweisung 285explizit 243, 287für Klassen 237implizit 239, 285in Klassenhierarchien 487Mehrdeutigkeit 243von Strings 471
UÜbersetzungseinheit 574UCHAR_MAX 753Überladen
binärer Operatoren 209Indexoperator 213Shift-Operator 211unärer Operatoren 209von delete 215von Funktionen 73von Konstruktoren 107von new 215von Operatoren mit Methoden 209von Template-Funktionen 375
Überladungder Zuweisung 163globale 217klassenspezifische 219von Methoden 261von Operatoren 203von Operatoren mit friend-Funktionen 207
UINT_MAX 753
ULONG_MAX 753unär 586UND 587, 588
boolsches 59unexpected() 453unget() 512, 647unique( ) 678, 708unique_copy( ) 705unitbuf 529, 634UNIX 572unsetf() 520, 521, 636Unterprogramm 572, 594Up Cast 487, 493
fehlerhafter 489upper_bound( ) 687, 691, 713uppercase 522, 634, 639USHRT_MAX 753using 347
Vvalarray 718, 729value_type 689Variable
definieren 578global 579lokal 579Namen 580Struktur- 602
Variable, lokale 51vector<T> 658, 664Vektor
boolescher 668Container- 657eindimensionaler 596-Länge 133Länge 597mehrdimensionaler 597, 743Name 599numerischer 717von Objekten 133
Verbergenvon Namen 351
Vereinigungsmenge 714Vererbung 21, 27, 99, 253
dynamischer Komponenten 305einfache 255private 270
Index
protected 270public 255, 270
Vererbungsarten 323Vererbungsdiagramm 329Vergleich
Gleichheit 703lexikographischer 673, 711von Bitsets 695von Deques 673von Listen 679von Maps 692von Queues 681von Sets 688von Stacks 683von Vektoren 668von Zeigern 600
Vergleichsoperator 587Vergleichsoperatoren 59, 756Verschachteln
von Funktions-Templates 371von Namensbereichen 349von try-Blöcken 429
Verschlüsselung 553Version
virtueller Methoden 297von Funktionen 289von Template-Funktionen 375
Verteilungen 708Verweisoperator 598, 757Verzweigung
bedingte 591virtual 289
Basisklasse 327Methodentabelle 297rein 301
Virtual Method Table 297VMT 297
-Zeiger 297void pop_back( ) 667void*() 516, 635volatile 495, 497vollständig 486Vorrang 586Vorrangtabelle
für Operatoren 758Vorzeichen 575, 750Vorzeichenoperator 756VT 578
Wwahlfrei
Dateizugriff 547Warteschlange 393, 657, 680
mit Prioritäten 479, 657, 684wcerr 631wcin 631wclog 631wcout 631Wert
boolscher 59größter 752kleinster 752Return 595
Wertebereichfür Datentypen 575
wfilebuf 630wfstream 629what() 449, 507while 590Wide
-Stream-Objekt 391widen() 637width() 527, 637Wiederverwendbarkeit 27, 253wifstream 629wios 629wiostream 629wistream 629wistringstream 629wofstream 629wostream 629wostringstream 629write() 515, 643ws 529, 647wstreambuf 630wstring 465, 612wstringbuf 630wstringstream 629Wurzel
eines Baumes 479
ZZahl
komplexe 205, 717, 719Zahlensystem
kennzeichnen 523
Index 787
788
Zeichen 575Ausgabe 580ausgeben 585Backslash 577-Code 581Eingabe 583einlesen 584EOF 583form feed 578-Konstante 576Konstante 577Newline 577Steuer- 577Tabulator 578
Zeichenkette 597, 611Zeiger 598
als Parameter 129, 600-Arithmetik 599auf abstrakte Klasse 303auf konstante Objekte 77auf Methoden 191auf Puffer 640auf Struktur 603Element- 191get- 545konstanter 77konstanter auf Konstante 77next- 640Null- 599put- 545Return-Wert 601Seek- 609Subtraktion 600this 125, 185typenloser 604Vergleich 600VMT- 297
Zeileeinlesen 585
Zeilen-Puffer 584
Zerstörenvon Objekten 111, 299
Zugriffauf aktuelles Objekt 125auf Basisklasse 259auf Datenelemente 121auf Elemente von Namensbereichen 347auf Format-Flags 521auf Klassenelemente 101, 105, 269auf Namensbereiche 349auf statische Elemente 185auf Status-Flags 517auf Stringelemente 473expliziter 125sequentieller Datei- 545wahlfreier Datei- 547
Zugriffrecht 271Zugriffs
-Deklaration 271Zugriffsart 605Zugriffsmethode 121, 259Zugriffsoperatoren 757Zugriffsrecht 187, 293, 606
abgeleiteter Klassen 255Zuweisung 163, 237, 587
abgeleiteter Klassen 305abstrakter Klassen 305einfache 587, 756für Bitsets 695mehrfache 587Standard- 307überladen 163virtuelle 305, 307von Deques 671von Listen 676von Maps 690von Objekten 285von Strings 467von Vektoren 666, 733zusammengesetzte 756
Zuweisungsoperator 587Zwischenraumzeichen
entfernen 528, 647überlesen 529
Zwischenspeicher 183
Index
C/C++, Softwareentwicklung
www.galileocomputing.de
Jürgen WolfC von A bis Z
920 S., 2003, 39,90 EuroISBN 3-89842-392-1
Krüger/Seelmann-EggebertIT-Architektur-Engineering
483 S., 2003, 49,90 Euro ISBN 3-89842-327-1
Arnold WillemerEinstieg in C++
ca. 500 S., 2003, ca. 20,00 EuroISBN 3-89842-397-2
Manfred RätzmannSoftware-Testing
281 S., 2002, 39,90 EuroISBN 3-89842-271-2
Bernhard VolzEinstieg in C#
528 S., 2002, 24,90 EuroISBN 3-89842-265-8
Grässle/Baumann/BaumannUML projektorientiert
288 S., 2003, 29,90 EuroISBN 3-89842-374-3
Kaiser/KecherC/C++
1368 S., 2002, 44,90 EuroISBN 3-89842-273-9
Aktuelle Computing-Bücherim Überblick
www.galileocomputing.de
C/C++ & Software-entwicklung
Ulrich KaiserSpieleprogrammierung in C++
U. Kaiser, Ch. Kecher
C/C++
Jürgen Wolf
C von A bis Z
Manfred Rätzmann
Software-Testing
Georg Erwin ThallerSoftwareentwicklung im Team
Krüger, Seelmann-EggebertIT-Architektur-Engineering
Alf Borrmann u.a.Rational Rose und UML
P. Grässle, H. u. P. BaumannUML projektorientiert
Internet & Scripting
Martin KästnerPerl fürs Web
Kai LaborenzCSS-Praxis
Marcus Throll
MySQL 4
Mark LubkowitzWebseiten programmieren und gestalten
Thomas TheisEinstieg in Python
Christian WenzHandbuch JavaScript
Michael HilscherDer eigene Webserver
Axel SchembergPC-Netzwerke
Java
Christian UllenboomJava ist auch eine Insel
Bernhard SteppanEinstieg in Java
MS,.NET
Stefan FellnerVB.NET und Datenbanken
Andreas KühnelVisual C#
Andreas KühnelVB.NET
Hans Willi KremerSELECT * FROM SQL Server 2000
Ulrich SchlüterIntegrationshandbuch Microsoft-Netzwerk
UNIX, XML
Matthias WarkusGNOME 2.0
Arnold WillemerWie werde ich ein UNIX-Guru?
Helmut VonhoegenEinstieg in XML
