Grundkurs C++

Inhalt
1
2
Einstieg in die Welt von C++ ....................................
15
1.1
1.2
1.3
1.4
1.5
1.6
1.7
Die (Kurz-)Geschichte von C++ ..............................
Der ANSI-C++-Standard .........................................
Was benötige ich für C++? .....................................
Welches Betriebssystem ...? ...................................
Was kann ich von dem Buch erwarten? ..................
Listings zum Buch ..................................................
Aufgaben im Buch ..................................................
1.7.1 Level 1 ......................................................
1.7.2 Level 2 ......................................................
1.7.3 Level 3 ......................................................
15
17
18
20
20
20
20
21
21
21
Verwendung der Basisdatentypen in C++ ................
22
2.1
2.2
22
24
24
25
27
27
29
29
29
31
32
2.3
2.4
Das erste Programm in C++ ....................................
Die Standard-Eingabe- und -Ausgabestreams .........
2.2.1 Die Streams von C++ .................................
2.2.2 Ausgabe mit »cout« ...................................
2.2.3 Ausgabe mit »cerr« oder »clog« .................
2.2.4 Eingabe mit »cin« ......................................
Einige Symbole von C++ ........................................
2.3.1 Bezeichner ................................................
2.3.2 Literale ......................................................
2.3.3 Kommentare .............................................
Grundlagen zu den Basisdatentypen .......................
2.4.1 Deklaration und Definition von
Variablen ...................................................
2.4.2 Initialisieren einer Variablen .......................
2.4.3 Vereinheitlichte Initialisierung
mit C++11 .................................................
2.4.4 Ganzzahltypen ...........................................
2.4.5 Vorzeichenlos und vorzeichenbehaftet ......
2.4.6 Fließkommazahlentypen ............................
2.4.7 Limits für die Basisdatentypen ...................
32
34
35
36
47
48
50
5
Inhalt
2.4.8
2.5
2.6
2.7
2.8
2.9
2.10
3
Kontrollstrukturen, Funktionen und
Präprozessor-Direktiven ...........................................
3.1
6
Die Byte-Größe mit dem »sizeof«Operator ...................................................
2.4.9 Sicherheit beim Kompilieren mit
»static_assert« (C++11) ..............................
»auto«-Typ (C++11) ...............................................
Rechnen mit Zahlen ...............................................
2.6.1 Arithmetische Operatoren .........................
2.6.2 Ungenaue Fließkommazahlen ....................
2.6.3 Erweiterte Darstellung arithmetischer
Operatoren ...............................................
2.6.4 Inkrement- und Dekrementoperator ..........
Zufallszahlen (C++11) .............................................
Typumwandlung ....................................................
2.8.1 Implizite Umwandlung durch den
Compiler ...................................................
2.8.2 Automatische Typumwandlung
beschränken (C++11) ................................
2.8.3 Explizite Typumwandlung ..........................
2.8.4 C++-Typumwandlungs-Operatoren ............
2.8.5 Gefährliche Typumwandlung mit den
alten C-Casts .............................................
Konstanten ............................................................
Aufgaben ...............................................................
2.10.1 Level 1 ......................................................
2.10.2 Level 2 ......................................................
2.10.3 Level 3 ......................................................
Kontrollstrukturen ..................................................
3.1.1 Anweisungen und Anweisungsblöcke ........
3.1.2 Verzweigungen ..........................................
3.1.3 Der Bedingungsoperator ?: ........................
3.1.4 Logische Operatoren .................................
52
52
53
54
55
57
59
59
61
62
63
66
67
67
70
71
72
72
72
73
74
74
74
75
83
84
Inhalt
3.2
3.3
3.4
4
3.1.5 Die Fallunterscheidung – »switch« .............
3.1.6 Schleifen ...................................................
Funktionen ............................................................
3.2.1 Funktionen definieren ...............................
3.2.2 Funktionen aufrufen ..................................
3.2.3 Funktionen deklarieren ..............................
3.2.4 Funktionsparameter (Call-by-Value) ...........
3.2.5 Standardparameter ....................................
3.2.6 Rückgabewert von Funktionen ..................
3.2.7 Funktionen überladen ...............................
3.2.8 Gültigkeitsbereich von lokalen und
globalen Variablen .....................................
3.2.9 Inline-Funktionen ......................................
3.2.10 Die »main«-Funktion .................................
3.2.11 Programmende ..........................................
Präprozessor-Direktiven .........................................
3.3.1 Die »#include«-Direktive ...........................
3.3.2 Die »#define«-Direktive .............................
3.3.3 Bedingte Kompilierung ..............................
3.3.4 Weitere Präprozessor-Direktiven ...............
Aufgaben ...............................................................
3.4.1 Level 1 ......................................................
3.4.2 Level 2 ......................................................
3.4.3 Level 3 ......................................................
87
90
100
101
102
103
104
105
107
109
111
113
115
116
117
118
119
121
123
124
124
124
126
Höhere und fortgeschrittene Datentypen ................ 127
4.1
4.2
4.3
Zeiger ....................................................................
4.1.1 Zeiger deklarieren ......................................
4.1.2 Adresse im Zeiger speichern ......................
4.1.3 Zeiger dereferenzieren ...............................
4.1.4 Speichergröße von Zeigern ........................
4.1.5 Zeigerarithmetik ........................................
Referenzen .............................................................
Arrays ....................................................................
4.3.1 Der C++-Container »vector« ......................
4.3.2 C-Arrays ....................................................
127
128
129
131
134
134
135
137
138
142
7
Inhalt
4.4
4.5
4.6
4.7
4.8
4.9
4.10
4.11
5
146
146
148
150
153
153
155
157
158
160
163
164
165
166
168
169
170
171
173
173
177
178
181
182
183
183
185
Modularisierung ....................................................... 186
5.1
8
Zeichenketten verwenden ......................................
4.4.1 Der C++-Container »string« .......................
4.4.2 Unterstützung von Unicode (C++11) .........
4.4.3 C-Zeichenketten ........................................
Höhere Datentypen bei Funktionen verwenden .....
4.5.1 Zeiger als Funktionsparameter ...................
4.5.2 Zeiger als Rückgabewert ............................
4.5.3 Referenzen als Funktionsparameter ...........
4.5.4 Referenzen als Rückgabewert ....................
4.5.5 C-Arrays oder C-Strings als
Funktionsparameter ...................................
Dynamische Speicherobjekte ..................................
4.6.1 Dynamisch Objekte mit »new« anlegen .....
4.6.2 Fehler bei der Speicheranforderung
abfangen ...................................................
4.6.3 Speicher mit »delete« wieder freigeben .....
Strukturen ..............................................................
4.7.1 Strukturen deklarieren ...............................
4.7.2 Zugriff auf die Strukturelemente ................
4.7.3 Zugriff auf die Elemente über
Strukturzeiger ............................................
4.7.4 Strukturen vergleichen ...............................
4.7.5 Dynamische Datenstrukturen mit
Strukturen .................................................
Union .....................................................................
Aufzählungstyp »enum« .........................................
Eigene Namen mit »typedef« .................................
Aufgaben ...............................................................
4.11.1 Level 1 ......................................................
4.11.2 Level 2 ......................................................
4.11.3 Level 3 ......................................................
Namensräume ........................................................ 186
5.1.1 Neuen Namensbereich deklarieren ............ 186
5.1.2 Namensbereich verschachteln ................... 189
Inhalt
5.1.3
5.2
5.3
5.4
5.5
5.6
6
Namensbereich ist ein eigener
Gültigkeitsbereich ......................................
5.1.4 Namensbereich mit »using« importieren ....
5.1.5 Einzelne Bezeichner mit »using«
importieren ...............................................
5.1.6 Aliasse für Namensbereiche .......................
5.1.7 Namensraum »std« ....................................
Speicherklassenattribute .........................................
5.2.1 Schlüsselwort »extern« ..............................
5.2.2 Schlüsselwort »static« ................................
Typqualifikatoren ...................................................
5.3.1 Schlüsselwort »const« ................................
5.3.2 Schlüsselwort »volatile« .............................
Weitere Attribute ...................................................
Modulare Programmierung ....................................
5.5.1 Aufteilung .................................................
5.5.2 Die öffentliche Schnittstelle
(Headerdatei) ...........................................
5.5.3 Private Datei(en) .......................................
5.5.4 Die Client-Datei ........................................
5.5.5 Nur Objektcode oder Bibliothek
vorhanden .................................................
Aufgaben ...............................................................
5.6.1 Level 1 ......................................................
5.6.2 Level 2 ......................................................
189
192
192
193
193
195
195
196
199
199
200
201
201
203
204
206
206
207
207
208
208
Klassen ..................................................................... 210
6.1
6.2
Abstraktionsmechanismus ......................................
Klassen ..................................................................
6.2.1 Klassendefinition .......................................
6.2.2 Elementfunktionen definieren ...................
6.2.3 Zugriffskontrolle mit »public« und
»private« ...................................................
6.2.4 Zugriff auf die Daten innerhalb einer
Klasse ........................................................
210
211
211
213
215
217
9
Inhalt
6.3
6.4
6.5
6.6
7
218
223
224
225
227
229
231
232
234
236
236
237
240
240
243
245
246
247
247
248
Objekte und Klassenelemente ................................. 249
7.1
7.2
7.3
10
6.2.5 Objekte erzeugen und benutzen ................
Konstruktoren ........................................................
6.3.1 Konstruktoren deklarieren .........................
6.3.2 Konstruktoren definieren ...........................
6.3.3 Implizite Konvertierungen verhindern –
»explicit« ...................................................
6.3.4 Konstruktoren delegieren (C++11) .............
6.3.5 Standardkonstruktor (DefaultKonstruktor) ..............................................
6.3.6 Kopierkonstruktor .....................................
6.3.7 Move-Konstruktor (C++11) .......................
Destruktoren ..........................................................
6.4.1 Destruktor deklarieren ...............................
6.4.2 Destruktor definieren ................................
Elementfunktionen .................................................
6.5.1 Inline-Elementfunktionen ..........................
6.5.2 Konstante Elementfunktionen
(read-only) ................................................
6.5.3 »this«-Zeiger ..............................................
Aufgaben ...............................................................
6.6.1 Level 1 ......................................................
6.6.2 Level 2 ......................................................
6.6.3 Level 3 ......................................................
Konstante Objekte .................................................
Objekte als (Element-)Funktionsargumente ............
7.2.1 Hilfsfunktionen ..........................................
7.2.2 Wertübergabe als Kopie (Call-by-Value) ....
7.2.3 Wertübergabe als Zeiger ............................
7.2.4 Wertübergabe als Referenz ........................
7.2.5 Wertübergabe bei Elementfunktionen .......
7.2.6 »this«-Zeiger ..............................................
Objekte als Rückgabewerte ....................................
249
250
250
251
253
255
256
257
260
Inhalt
7.4
7.5
7.6
7.7
7.8
7.9
7.10
8
Arrays von Objekten ..............................................
Dynamische Objekte ..............................................
Mehr zu den Klassenelementen ..............................
7.6.1 Dynamische Klassenelemente ....................
7.6.2 Statische Klassenelemente .........................
7.6.3 Konstante Klassenelemente .......................
Andere Klassenobjekte als Datenelement
einer Klasse ............................................................
Elementinitialisierer ................................................
Gute Freunde (»friend«) .........................................
Aufgaben ...............................................................
7.10.1 Level 1 ......................................................
7.10.2 Level 2 ......................................................
7.10.3 Level 3 ......................................................
262
263
265
265
273
276
277
283
285
287
288
288
289
Operatoren überladen .............................................. 290
8.1
8.2
8.3
8.4
8.5
8.6
8.7
Schlüsselwort »operator« .......................................
Zweistellige (arithmetische) Operatoren
überladen ..............................................................
8.2.1 Operatorüberladung als Elementfunktion
einer Klasse ...............................................
8.2.2 Operatorüberladung als globale
Hilfsfunktion ..............................................
8.2.3 Zweistellige Operatoren
zusammengefasst ......................................
Einstellige Operatoren überladen ...........................
Zuweisungsoperator überladen ..............................
Ein-/Ausgabeoperator überladen ............................
8.5.1 Eingabeoperator >> überladen ...................
8.5.2 Ausgabeoperator << überladen ..................
Weitere Operatorüberladungen .............................
Konvertierungsoperatoren ......................................
8.7.1 Konvertierungskonstruktor ........................
8.7.2 Globale Konvertierungsfunktion ................
291
293
294
297
299
299
303
305
306
307
308
309
310
311
11
Inhalt
8.8
9
Aufgaben ...............................................................
8.8.1 Level 1 ......................................................
8.8.2 Level 2 ......................................................
8.8.3 Level 3 ......................................................
314
314
314
315
Vererbung (Abgeleitete Klassen) ............................. 316
9.1
9.2
9.3
9.4
9.5
Die Vorbereitung ...................................................
Die Ableitung einer Klasse ......................................
9.2.1 »public«-Zugriffsrechte einer abgeleiteten
Klasse ........................................................
9.2.2 Erben und erweitern ..................................
9.2.3 Zugriff auf die Daten ..................................
9.2.4 Redefinition von Elementfunktionen ..........
9.2.5 Konstruktoren ...........................................
9.2.6 Destruktor .................................................
9.2.7 Programmbeispiel ......................................
9.2.8 Zugriffsrecht »protected« ...........................
9.2.9 Zugriffsrechte bei der Vererbung von
Klassen ......................................................
9.2.10 Implizite Typumwandlung abgeleiteter
Klassen ......................................................
9.2.11 Konstruktoren vererben (C++11) ...............
Mehrfachvererbung ................................................
Virtuelle Vererbung ................................................
Aufgaben ...............................................................
9.5.1 Level 1 ......................................................
9.5.2 Level 2 ......................................................
9.5.3 Level 3 ......................................................
317
318
320
320
321
323
324
326
326
327
328
330
331
332
336
341
341
342
343
10 Templates ................................................................. 344
10.1
12
Funktions-Templates ..............................................
10.1.1 Funktions-Template definieren ..................
10.1.2 Typübereinstimmung .................................
10.1.3 Funktions-Templates über mehrere
Module .....................................................
10.1.4 Funktions-Template spezialisieren ..............
344
345
347
348
348
Inhalt
10.2
10.3
10.4
10.1.5 Templates mit verschiedenen
Parametern ................................................ 349
10.1.6 Explizite Template-Argumente ................... 351
Klassen-Templates .................................................. 352
10.2.1 Klassen-Template definieren ...................... 353
10.2.2 Elementfunktionen von KlassenTemplates definieren ................................. 354
10.2.3 Klassen-Template instantiieren .................. 357
Templates der Standardbibliothek .......................... 360
10.3.1 Container der Standardbibliothek .............. 361
10.3.2 Iteratoren .................................................. 365
10.3.3 Algorithmen .............................................. 365
Aufgaben ............................................................... 367
10.4.1 Level 1 ...................................................... 367
10.4.2 Level 2 ...................................................... 367
10.4.3 Level 3 ...................................................... 368
11 Exception-Handling (Fehlerbehandlung) ................. 370
11.1
11.2
11.3
11.4
11.5
11.6
11.7
Exception auslösen .................................................
Exception auffangen und behandeln .......................
11.2.1 »terminate«-Handler einrichten .................
11.2.2 Alternatives »catch (...)« ............................
11.2.3 Stack-Abwicklung ......................................
Ausnahme-Klassen (Fehlerklassen) .........................
Standard-Exceptions ..............................................
11.4.1 Virtuelle Methode »what()« .......................
11.4.2 Anwenden der Standard-Exceptions ..........
System-Exceptions .................................................
11.5.1 »bad_alloc« ...............................................
11.5.2 »bad_cast« ................................................
11.5.3 »bad_typeid« .............................................
11.5.4 »bad_exception« .......................................
»noexcept« (C++11) ...............................................
Aufgaben ...............................................................
11.7.1 Level 1 ......................................................
371
371
375
376
376
377
379
380
380
384
384
384
384
385
385
387
387
13
Inhalt
12 Weitere Neuigkeiten in C++11 ................................. 388
12.1
12.2
12.3
Grundsätzliche Neuerungen in der Kernsprache .....
12.1.1 Range-based »for«-Schleife ........................
12.1.2 Lambda-Funktionen ..................................
12.1.3 RValue (neue Move-Semantik) ..................
12.1.4 Generische Programmierung –
Variadic Templates ....................................
12.1.5 »decltype« und die neue
Rückgabesyntax .........................................
12.1.6 »constexpr« ...............................................
Standardbibliothek – neue Bibliotheken .................
12.2.1 Reguläre Ausdrücke ...................................
12.2.2 Zeitbibliothek ............................................
12.2.3 Smart Pointer ............................................
Multithreading .......................................................
12.3.1 Einfache Threads erzeugen ........................
12.3.2 Chaos vermeiden .......................................
388
388
389
390
391
393
396
397
397
399
403
406
407
409
Lösungen der Übungsaufgaben ..................................... 412
Lösungen zu Kapitel 2 .............................................................
Lösungen zu Kapitel 3 .............................................................
Lösungen zu Kapitel 4 .............................................................
Lösungen zu Kapitel 5 .............................................................
Lösungen zu Kapitel 6 .............................................................
Lösungen zu Kapitel 7 .............................................................
Lösungen zu Kapitel 8 .............................................................
Lösungen zu Kapitel 9 .............................................................
Lösungen zu Kapitel 10 ...........................................................
Lösungen zu Kapitel 11 ...........................................................
412
414
417
421
423
427
431
434
437
439
Index ...................................................................................... 441
14
3
Kontrollstrukturen, Funktionen und
Präprozessor-Direktiven
Nach dem Sie jetzt mit den Basisdatentypen vertraut sind, können Sie tiefer
in die C++-Programmierung eintauchen. Besonders wichtig für die Steuerung eines Programms sind die Kontrollstrukturen mit den Verzweigungen
und Schleifen. Auch die Funktionen sind unerlässlich für ernsthafte sinnvolle Programme, um Aufgaben in (mehrere) Teilaufgaben zu teilen. Zu guter
Letzt behandle ich in diesem Kapitel die Präprozessor-Direktiven und ihre
Verwendungen. Die Präprozessor-Direktiven sind die Zeilen im Programm,
die mit dem Hash-Zeichen beginnen (beispielsweise #include).
3.1
Kontrollstrukturen
Bisher sind die Programme immer nur sequentiell abgelaufen – also immer
Zeile für Zeile. In C++ haben Sie folgende drei Möglichkeiten, diesen sequentiellen Programmfluss zu verändern:
왘
Verzweigungen (oder auch Selektionen)
왘
Schleifen (oder auch Iterationen)
왘
Sprunganweisungen
3.1.1
Anweisungen und Anweisungsblöcke
Wenn Sie in C++ einen Ausdruck wie beispielsweise cout << "Hallo" oder
int i=1 mit einem Semikolon abschließen, spricht man von einer Anweisung. Mehrere solcher Anweisungen lassen sich in einem Anweisungsblock
zwischen geschweiften Klammern ({}) zusammenfassen, beispielsweise:
{
}
// Anweisungsblock – Anfang
Anweisung1;
Anweisung2;
...
AnweisungN;
// Anweisungsblock – Ende
Solche Anweisungsblöcke können Sie zwar auch ineinander verschachteln,
aber es empfiehlt sich, nur nach Bedarf davon Gebrauch zu machen, weil
74
3.1 Kontrollstrukturen
sonst die Strukturierung, und somit auch Lesbarkeit, des Programms erheblich leidet.
3.1.2
Verzweigungen
Mit Verzweigungen beeinflussen Sie den Ablauf des Programms, indem Sie
eine Bedingung definieren und damit entscheiden, an welcher Stelle das
Programm fortgesetzt werden soll. In C++ gibt es mit if und switch zwei
solcher Verzweigungen.
»if«-Verzweigung
Die Syntax einer einseitigen if-Verzweigung in C++ sieht wie folgt aus:
if( ausdruck ) {
anweisung1;
}
anweisung2;
Zuerst wird die Bedingung ausdruck ausgewertet. Je nachdem, ob ausdruck
wahr (true; ungleich 0) ist, wird die Anweisung anweisung1 im Anweisungsblock ausgeführt. Anschließend wird die Programmausführung mit der Anweisung anweisung2 fortgesetzt. Ist die Bedingung ausdruck allerdings
unwahr (false; gleich 0), werden die Anweisungen im Anweisungsblock
nicht ausgeführt, und das Programm fährt sofort mit der Anweisung
anweisung2 fort.
Logischer Ausdruck
Die runden Klammern hinter if müssen verwendet werden, weil es sich
um einen logischen Ausdruck handelt. Logisch heißt hier ganzzahlig. Der
Ausdruck der Bedingung kann einen beliebigen numerischen Wert annehmen, der nach bool konvertierbar sein muss. true (bzw. ungleich 0) wird
immer zurückgegeben, wenn der logische Ausdruck wahr ist. false (bzw.
gleich 0) wird zurückgegeben, wenn der logische Ausdruck falsch (also
unwahr) ist.
Abbildung 3.1 stellt diese einseitige if-Anweisung in einem Programmablaufplan schematisch dar.
75
3
Kontrollstrukturen, Funktionen und Präprozessor-Direktiven
ausdruck
wahr
Ja
Nein
anweisung1
anweisung2
Abbildung 3.1
Der Ablaufplan einer einseitigen »if«-Anweisung
Für die Praxis können Sie sich hierzu folgendes Programmbeispiel ansehen:
00
01
02
// listings/003/listing001.cpp
#include <iostream>
using namespace std;
03
04
05
06
07
08
09
10
11
12
13
int main() {
int ival=0;
cout << "Bitte eine Ganzzahl eingeben: ";
cin >> ival;
if( ival ) {
// Code, wenn ival wahr ist
cout << "Die Zahl ist nicht 0\n";
}
cout << "Nach der if-Verzweigung\n";
return 0;
}
Das Programm bei der Ausführung:
Bitte eine Ganzzahl eingeben: 100
Die Zahl ist nicht 0
Nach der if-Verzweigung
Bitte eine Ganzzahl eingeben: –10
Die Zahl ist nicht 0
Nach der if-Verzweigung
76
3.1 Kontrollstrukturen
Bitte eine Ganzzahl eingeben: 0
Nach der if-Verzweigung
In Zeile (05) werden Sie aufgefordert, eine Ganzzahl einzugeben. Diese Eingabe wird über cin in Zeile (06) eingelesen und in der Variablen ival (Zeile
(04)) gespeichert. In Zeile (07) wird die Bedingung (oder auch der Ausdruck)
daraufhin überprüft, ob der eingegebene Wert von ival wahr (= true) ist.
»Wahr« bedeutet hier: Es wurde ein Wert ungleich 0 eingegeben. Hat der
Anwender einen Wert größer oder kleiner als 0 eingegeben, wird die Ausgabe über cout mit Zeile (09) ausgeführt. Genauer: Es werden alle Anweisungen im Anweisungsblock zwischen den Zeilen (07) bis (10) ausgeführt.
Hat der Anwender hingegen den Wert 0 eingegeben, werden die Anweisungen in dem Anweisungsblock (Zeilen (07) bis (10)) nicht ausgeführt (da unwahr; also: false), und es wird gleich mit der Ausgabe über cout mit Zeile
(11) fortgefahren, die natürlich auch ausgeführt wird, wenn die Anweisungen im if-Anweisungsblock zwischen den Zeilen (07) bis (10) ausgeführt
wurden.
Vergleichsoperatoren
Ein Vergleich, der wie im Listing zuvor (listing001.cpp) in Zeile (07) verwendet wird, dürfte Sie vielleicht ein wenig irritieren, und Sie hätten hier
genauso gut Folgendes schreiben können:
07
08
09
10
if( ival != 0 ) {
// Code, wenn ival wahr ist
cout << "Die Zahl ist nicht 0\n";
}
Dieser Vergleich in Zeile (07) mit dem !=-Operator (Nicht-gleich-Operator; ein Vergleichsoperator), ob der Ausdruck zwischen den Klammern
von if nicht gleich 0 ist, entspricht demselben Ausdruck wie in Listing
listing001.cpp.
Bevor Sie weitere Verzweigungsmöglichkeiten kennenlernen, möchte ich
kurz auf die vorhandenen Vergleichsoperatoren eingehen. Alle in Tabelle
3.1 aufgelisteten Vergleichsoperatoren vergleichen zwei Operanden und
liefern einen Wert vom Typ bool zurück. Ist der Vergleich wahr, geben die
Operatoren den Wert true zurück, und wenn der Vergleich unwahr ist,
wird false zurückgegeben. Folgende Operatoren stehen Ihnen zur Verfügung:
77
3
Kontrollstrukturen, Funktionen und Präprozessor-Direktiven
Operator
Bedeutung
Beispiel
Rückgabewert
<
kleiner
a<b
true, wenn a kleiner als b,
ansonsten false
<=
kleiner oder gleich
a <= b
true, wenn a kleiner als oder
gleich b, ansonsten false
>
größer
a>b
true, wenn a größer als b,
ansonsten false
>=
größer oder gleich
a >= b
true, wenn a größer als oder
gleich b, ansonsten false
==
gleich
a == b
true, wenn a gleich ist wie b,
ansonsten false
!=
ungleich
a != b
true, wenn a ungleich b ist,
ansonsten false
Tabelle 3.1
Übersicht zu den Vergleichsoperatoren
Alternative »else«-Verzweigung
In der Praxis folgt gewöhnlich nach einer oder mehreren if-Anweisung(en)
eine optionale und alternative Verzweigung, die auf jeden Fall ausgeführt
wird, wenn keine Bedingung erfüllt wird, also wahr zurückgibt. Realisiert
wird dies mit einer alternativen else-Verzweigung, die folgende Syntax besitzt:
if( ausdruck ) {
anweisung1;
}
else {
anweisung2;
}
anweisung3;
Hierbei wird ebenfalls zuerst die Bedingung ausdruck ausgewertet. Je nachdem, ob ausdruck wahr (true; ungleich 0) ist, wird die Anweisung
anweisung1 im Anweisungsblock ausgeführt. Anschließend wird die Programmausführung mit der Anweisung anweisung3 fortgesetzt. Ist die Bedingung ausdruck allerdings unwahr (false; gleich 0), wird die Anweisung
anweisung2 im alternativen else-Anweisungsblock ausgeführt, und anschließend fährt das Programm mit der Anweisung anweisung3 fort.
78
Index
! (logisches NICHT) 84
!=-Operator (Vergleich) 78
#define 119
#elif 121
#else 121
#endif 121
#error 123
#if 121
#if defined 121
#ifdef 121
#ifndef 121
#include 118
#line 123
#pragma 123
#undef 120
%-Operator (Modulo) 55
& (Adressoperator) 129
&& (logisches UND) 84
&&-Referenz 390
* (Indirektionsoperator) 131
*-Operator (multiplizieren) 55
*this 257
++-Operator 59
---Operator 59
+-Operator 55
--Operator (minus) 55
... 391
/-Operator (dividieren) 55
<< überladen 307
<=-Operator (Vergleich) 78
<cfloat> 52
<climits> 52
<limits> 50
<memory> 403
<-Operator (Vergleich) 78
<regex> 397
<thread> 407
==-Operator (Vergleich) 78
>=-Operator (Vergleich) 78
>> überladen 306
>-Operator (Vergleich) 78
?:-Operator (Bedingung) 83
{} (Initialisierung) 36
|| (logisches ODER) 84
64 Bit 45
A
Abgeleitete Klasse 316
implizite Typumwandlung 330
Konstruktor 324
Mehrfachvererbung 332
protected 327
Redefinition 323
virtual (Schlüsselwort) 340
Zugriffsrechte vererben 328
Abgeleitete Klasse 씮 Vererbung
abort() 116
Abstrakter Datentyp 210
Ada 15
Adressoperator 129
Algol68 15
ANSI-C++ 17
Anweisung 74
Anweisungsblock 74
Arithmetik
Zeiger 134
Arithmetischer Operator 55
Array
C-Array 142
vector 138
array 138
Array 씮 Feld
Array 씮 Vektor
441
Index
atexit() 117
Aufzählungstyp, enum 178
Ausgabe, cout 25
Ausnahmebehandlung 씮 ExceptionHandling
Ausnahme-Klasse 377
auto 53
auto_ptr 403
B
bad_alloc 165
Basisdatentyp 26, 28, 32
initialisieren 34
Basisdatentyp 씮 Datentyp
BCPL 15
Bedingte Kompilierung 121
Bedingungsoperator 83
Bezeichner 29
bool 37
Bool-Typumwandlung 66
break 87
break-Anweisung 98
Breite Zeichen 41
C
C mit Klassen 16
C++ 16
Entstehung 15
Geschichte 15
C++11 388
auto 53
char16_t 43
char32_t 43
constexpr 396
decltype 393
delete 250
enum 179
final 201
442
C++11 (Forts.)
for 141, 144, 388
Klassenelemente initialisieren 228
Konstruktor delegieren 229
Konstruktoren vererben 331
long long 45
Multithreading 406
noexcept 385
override 201
Raw String 399
register 198
regulärer Ausdruck 397
shared_ptr 403
Smart Pointer 403
static_assert 52
Typenumwandlung beschränken 66
unique_ptr 167, 223, 405
using 182
Variadic Template 391
vereinheitlichte Initialisierung 35
weak_ptr 404
Zeitbibliothek 399
Zufallszahlen 61
Call-by-Reference 153
Call-by-Value 104
C-Array 142, 262
Initialisierungsliste 144
case-Marke 87
catch 372
alternatives 376
C-Cast 70
cerr 27
char 37
char16_t 43
char32_t 43
cin 27
class 211
clog 27
Compiler 18
const 71, 249
Index
const (Schlüsselwort) 120, 199
const_cast 68
constexpr 396
Container 361
continue-Anweisung 100
cout 25
C-String 150
C-Zeichenkette 씮 C-String
D
Datenkapsel 210
Datenstruktur, dynamische 170
Datentyp 32
abstrakter 210
decltype 393
Default-Konstruktor 231
default-Marke 87
define 119
Definition 32
Deklaration 32
Dekrementoperator 59
delete 166, 250
deprecated, register 198
Dereferenzierung 131
Destruktor 236
abgeleitete Klasse 326
double 48
do-while-Anweisung 92
dynamic_cast 70
Dynamische Datenstruktur 170, 173
Dynamisches Objekt 263
Dynamisches Speicherobjekt 163
E
Eingabe, cin 27
Elementfunktion 213, 240
friend 286
Inline- 240
Elementfunktion (Forts.)
konstante 243
Wertübergabe 256
Elementfunktion 씮 Methode
Elementinitialisierer 283
abgeleitete Klasse 325
elif 121
else 121
else if-Verzweigung 80
else-Verzweigung 78
endif 121
Endlosschleife 92
Entwicklungsumgebung 18
enum 178
error 123
Escape-Zeichen 39
Exception
auslösen 371
behandeln 371
Fehlerklasse 377
Stack-Abwicklung 376
Standard- 379
System- 384
Exception-Handling 370
exit() 116
explicit 227, 228
explicit (Funktionsattribut) 201
Explizite Typumwandlung 67
extern (Schlüsselwort) 195
F
Feld 137
Fließkomma-Arithmetik 57
Fließkommazahl 30, 48
float 48
for
C++11 141, 388
for 씮 foreach
for-Anweisung 95
443
Index
foreach 142
friend 285
Funktion
aufrufen 102
Call-by-Reference 153
definieren 101
friend 286
inline 113
Lambda 389
main 115
Parameter 104
Referenz 157
Rückgabewert 107
Scope-Operator 113
Standardparameter 105
überladen 109
Vorwärtsdeklaration 103
Zeiger als Parameter 153
Zeiger als Rückgabe 155
Funktions-Template 344
ifndef 121
if-Verzweigung 75
Implizite Typumwandlung 63
abgeleitete Klasse 330
Indirektionsoperator 131
Initialisierung
C++11 35
Inkrementoperator 59
inline 113, 241
inline (Funktionsattribut) 201
Instanz 218
int 37, 45
Integer 45
Integral-Gleitkomma-Typumwandlung 65
Integral-Promotion 63
Integral-Typumwandlung 64
Iterator 365
G
Klasse 210
abgeleitete 씮 Abgeleitete Klasse
Call-by-Reference 253
Call-by-Value 251
Elementfunktion 213
friend 287
Hilfsfunktion 250
indirekter Zugriff 221
Mehrfachvererbung 332
Punktoperator 219
Referenz 255
Vererbung 316
virtual (Schlüsselwort) 340
virtuelle Vererbung 336
Zugriff 217
Zugriffskontrolle 215
Klassendefinition 211
Klassenelement
dynamisches 265
Ganzzahl 30
Ganzzahltypen 36
getline() 148
Gleitkomma-Promotion 64
Gleitkomma-Typumwandlung 65
Gültigkeitsbereich 111
Namensraum 189
H
Hilfsfunktion 250
I
if 121
if defined 121
ifdef 121
444
K
Index
Klassenelement (Forts.)
konstantes 276
statisches 273
Klassen-Template 352
Kommentar 31
Kompilierung, bedingte 121
Konstante 71
Konstruktor 223
abgeleitete Klasse 324
delegieren 229
Konvertierungs- 310
Kopier- 232
Standard- 231
vererben 331
Kontrollstrukturen 74
Konvertierungsfunktion 311
Konvertierungskonstruktor 227, 310
Konvertierungsoperator 309
Kopierkonstruktor 232, 271
Zuweisungsoperator überladen 303
L
Lambda-Funktion 389
limits 50
line 123
Linker 18
Literal 29
Logische Operatoren 84
long 37, 45
long double 49
long long 37, 45
M
main-Funktion 23
Mehrfachvererbung 332
Memory Leak 164
Methode 213
Elementfunktion 240
Modularisierung 186
Move-Semantik 390
Multithreading 406
N
Namensraum 186
deklarieren 186
Gültigkeitsbereich 189
importieren 192
std 25
namespace
std 193
Namespace 씮 Namensraum
new 164
noexcecpt 385
nullptr 133
Null-Zeiger 132
numeric_limits 50
O
Objekt 218
dynamisches 263
konstantes 249
Rückgabewert 260
Operator
arithmetischer 55
logischer 84
überladen 290
überladen als Elementfunktion 294
überladen als globale Funktion 297
operator (Schlüsselwort) 291
P
Parameter-Pack 391
Pointer 씮 Zeiger
pragma 123
Präprozessor-Direktive 117
445
Index
private 215, 327
Programmende 116
protected 327
ptrdiff_t 135
public 215, 327
Vererbung 320
R
Range-based for 388
Range-for 141
RAW-String-Literal 399
Rechnen 54
Redefinition 323
Referenz 135
Funktionsparameter 157
Klasse 255
Rückgabe aus Funktion 158
Struktur 172
register 198
Regulärer Ausdruck 397
reinterpret_cast 69
return 108
RValue 390
S
Schablone 씮 Template
Schleife 90
Semikolon 24
shared_ptr 403
short 37, 45
signed 47
Simula 15
size_t 141
sizeof 52
Zeiger 134
Smart Pointer 403
Speicherklassenattribut 195
Speicherloch 164
446
Speicherobjekt, dynamisches 163
Sprunganweisung, kontrollierte 98
Stack-Abwicklung, Exception 376
Standard-Exceptions 379
Standardkonstruktor 231
static 196, 273
static_assert 52
static_cast 68
std 25, 193
std:: 194
Steuerzeichen 39
STL
Algorithmus 365
Elementfunktion 364
Iterator 365
Stream 24
Ausgabe- 25
Eingabe- 27
String 146
Raw 399
string (Klasse) 146
String-Ende-Zeichen 150
Stroustrup, Bjarne 15
struct 168
Struktur 168
deklarieren 169
dynamische 173
Referenz 172
typedef 182
Zugriff 170
Strukturzeiger 171
switch-Fallunterscheidung 87
Symbol 29
System-Exception 384
T
Template 344
Funktions- 344
Klassen- 352
Index
Template (Forts.)
Variadic 391
terminate() 116, 375
this-Zeiger 245
thread 407
throw 371
try 372
tuple 393
typedef 181
Struktur 182
Typenqualifikator 199
Typinferenz 54
Typumwandlung 62
explizite 67
implizite 63
Vergleichsoperator 77
Verzweigung 75
virtual (Funktionsattribut) 201
virtual (Schlüsselwort) 340
void 46
volatile 200
Vorzeichenbehaftet 47
Vorzeichenlos 47
W
wchar_t 41
weak_ptr 404
what() 380
while-Anweisung 90
U
Z
Überladen
Operator 290
Zuweisungsoperator 303
Unicode 42
unique_ptr 167, 223, 405
unsigned 47
using 192
using-Synome 182
UTF-8 44
Zeichen 31
breites 41
Zeichenkette 31
Zeichenkette 씮 String
Zeiger 127
*this 257
Arithmetik 134
deklarieren 128
Dereferenzierung 131
Funktionsparameter 153
Klassenelement 265
Null- 132
Rückgabe aus Funktion 155
sizeof 134
Speichergröße 134
Struktur 171
this 245
Zeilenende 40
Zeitbibliothek 399
Zufallszahlen 61
Zuweisungsoperator, überladen 303
V
Variable 33
Gültigkeitsbereich 111
Variadic Template 391
vector 138
vector (Klasse) 262
Vektor 137
Vererbung 316
public 320
Redefinition 323
virtuelle 336
447