C++ – Lernen und professionell anwenden - mitp.de · ten Programmiersprache C++. Außerdem werden die Schritte vorgestellt, die zur Erstellung eines lauffähigen C++-Programms erforderlich

7

Inhaltsverzeichnis

Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

1 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

Entwicklung und Eigenschaften von C++ . . . . . . . . . . . . . . . . . . . . . 24

Objektorientierte Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . 26

Erstellen eines C++-Programms . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

Ein erstes C++-Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

Struktur einfacher C++-Programme. . . . . . . . . . . . . . . . . . . . . . . . . 32

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

2 Elementare Datentypen, Konstanten und Variablen . . 37

Elementare Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

Konstanten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

Escape-Sequenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

Namen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

Die Schlüsselworte const und volatile . . . . . . . . . . . . . . . . . . . . . . . . 54

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

3 Verwenden von Funktionen und Klassen . . . . . . . . . . . 61

Deklaration von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

Aufruf von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

Der Typ void für Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

Header-Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

Standard-Header-Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

Verwenden von Standardklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028

C++ Lernen und professionell anwenden

8

4 Ein- und Ausgaben mit Streams . . . . . . . . . . . . . . . . . 79

Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

Formatierung und Manipulatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

Formatierte Ausgabe von Ganzzahlen . . . . . . . . . . . . . . . . . . . . . . . 84

Formatierte Ausgabe von Gleitpunktzahlen. . . . . . . . . . . . . . . . . . . . 86

Ausgabe in Felder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

Ausgabe von Zeichen, Strings und booleschen Werten . . . . . . . . . . . 90

Formatierte Eingabe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

Formatierte Eingabe von Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

Unformatierte Ein-/Ausgabe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

5 Operatoren für elementare Datentypen . . . . . . . . . . 103

Binäre arithmetische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . 104

Unäre arithmetische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . 106

Zuweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

Vergleichsoperatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

Logische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

6 Kontrollstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

Die while-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

Die for-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

Die do-while-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

Verzweigungen mit if-else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

else-if-Ketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

Bedingte Bewertung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130

Auswahl mit switch. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

Sprünge mit break, continue und goto . . . . . . . . . . . . . . . . . . . . . . 134

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138


Inhaltsverzeichnis

9

7 Symbolische Konstanten und Makros . . . . . . . . . . . . 141

Makros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142

Makros mit Parametern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

Arbeiten mit der #define-Direktive . . . . . . . . . . . . . . . . . . . . . . . . . 146

Bedingte Kompilierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148

Standardmakros zur Behandlung von Zeichen. . . . . . . . . . . . . . . . . 150

Umlenken von Standardeingabe und -ausgabe. . . . . . . . . . . . . . . . 152

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156

8 Umwandlung arithmetischer Datentypen . . . . . . . . . 161

Implizite Typumwandlungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162

Verfahren bei arithmetischen Typumwandlungen . . . . . . . . . . . . . . 164

Implizite Typumwandlungen bei Zuweisungen . . . . . . . . . . . . . . . . 166

Weitere Typumwandlungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172

9 Die Standardklasse string . . . . . . . . . . . . . . . . . . . . . 175

Definition und Zuweisung von Strings . . . . . . . . . . . . . . . . . . . . . . . 176

Verketten von Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178

Strings vergleichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180

Einfügen und Löschen in Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

Suchen und Ersetzen in Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184

Zugriff auf Zeichen in Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190

10 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193

Bedeutung von Funktionen in C++ . . . . . . . . . . . . . . . . . . . . . . . . 194

Erstellen eigener Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

Return-Wert von Funktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198

Übergabe von Argumenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200



10

inline-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202

Default-Argumente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204

Überladen von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206

Rekursive Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

Platzhalter auto für Return-Typen . . . . . . . . . . . . . . . . . . . . . . . . . . 210

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215

11 Speicherklassen und Namensbereiche . . . . . . . . . . . 221

Speicherklasse von Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222

Der Speicherklassen-Spezifizierer extern . . . . . . . . . . . . . . . . . . . . . 224

Der Speicherklassen-Spezifizierer static. . . . . . . . . . . . . . . . . . . . . . 226

Die Speicherklassen-Spezifizierer auto und register. . . . . . . . . . . . . 228

Speicherklassen-Spezifizierer von Funktionen . . . . . . . . . . . . . . . . . 230

Namensbereiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232

Das Schlüsselwort using . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240

12 Referenzen und Zeiger . . . . . . . . . . . . . . . . . . . . . . . 245

Definition von Referenzen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246

Referenzen als Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248

Referenzen als Return-Wert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250

Ausdrücke mit Referenztyp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252

Definition von Zeigern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254

Der Verweisoperator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256

Zeiger als Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262

13 Definition von Klassen . . . . . . . . . . . . . . . . . . . . . . . . 267

Klassen-Konzept. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268

Definition von Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270


Inhaltsverzeichnis

11

Definition von Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272

Definition von Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274

Verwendung von Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276

Zeiger auf Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

Structs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280

Unions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284

Lösung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286

14 Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289

Konstruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290

Aufruf von Konstruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292

Mehr Initialisierungsmöglichkeiten . . . . . . . . . . . . . . . . . . . . . . . . . 294

Destruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296

Inline-Methoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298

Zugriffsmethoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300

const-Objekte und -Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302

Standardmethoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304

Standardmethoden kontrollieren . . . . . . . . . . . . . . . . . . . . . . . . . . 306

Der this-Zeiger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308

Übergabe von Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310

Objekte als Return-Wert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318

15 Teilobjekte und statische Elemente . . . . . . . . . . . . . . 325

Klassen mit Teilobjekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326

Elementinitialisierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328

Konstante Teilobjekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330

Statische Datenelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332

Zugriff auf statische Datenelemente . . . . . . . . . . . . . . . . . . . . . . . . 334

Aufzählungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342



12

16 Vektoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349

Vektoren definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350

Initialisierung von Vektoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352

C-Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354

Klassen-Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356

Mehrdimensionale Vektoren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358

Vektoren als Datenelemente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366

17 Zeiger und Vektoren . . . . . . . . . . . . . . . . . . . . . . . . . 377

Vektoren und Zeiger (1) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378

Vektoren und Zeiger (2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380

Zeigerarithmetik. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382

Vektoren als Argumente von Funktionen. . . . . . . . . . . . . . . . . . . . . 384

Zeigerversion von Funktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386

Read-Only-Zeiger. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388

Zeiger als Return-Wert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390

Zeigervektoren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392

Argumente aus der Kommandozeile . . . . . . . . . . . . . . . . . . . . . . . . 394

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400

18 Grundlagen der Dateiverarbeitung . . . . . . . . . . . . . . 407

Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408

File-Stream-Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410

File-Streams anlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412

Eröffnungsmodus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414

Schließen von Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416

Blockweises Schreiben und Lesen . . . . . . . . . . . . . . . . . . . . . . . . . . 418

Persistenz von Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426


Inhaltsverzeichnis

13

19 Operatoren überladen . . . . . . . . . . . . . . . . . . . . . . . 441

Allgemeines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442

Operatorfunktionen (1) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444

Operatorfunktionen (2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446

Überladene Operatoren verwenden . . . . . . . . . . . . . . . . . . . . . . . . 448

Globale Operatorfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450

friend-Funktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452

friend-Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454

Index-Operator überladen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456

Shift-Operatoren für die Ein-/Ausgabe überladen . . . . . . . . . . . . . . 458

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 460

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462

20 Typumwandlungen für Klassen . . . . . . . . . . . . . . . . . 471

Konvertierungskonstruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472

Konvertierungsfunktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474

Mehrdeutigkeit bei Typumwandlungen . . . . . . . . . . . . . . . . . . . . . . 476

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480

21 Speicherreservierung zur Laufzeit . . . . . . . . . . . . . . . 483

Der Operator new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484

Der Operator delete. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486

Dynamischer Speicher für Klassen . . . . . . . . . . . . . . . . . . . . . . . . . 488

Dynamischer Speicher für Vektoren . . . . . . . . . . . . . . . . . . . . . . . . 490

Anwendung: Einfach verkettete Listen. . . . . . . . . . . . . . . . . . . . . . . 492

Darstellung einer einfach verketteten Liste . . . . . . . . . . . . . . . . . . . 494

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498

22 Dynamische Elemente . . . . . . . . . . . . . . . . . . . . . . . . 507

Datenfelder variabler Länge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508

Eine Klasse mit dynamischem Element . . . . . . . . . . . . . . . . . . . . . . 510

Auf- und Abbau eines Objekts . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512



14

Die Implementierung der Methoden . . . . . . . . . . . . . . . . . . . . . . . . 514

Kopierkonstruktor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516

Zuweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518

Verschieben von R-Werten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520

Move-Konstruktor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522

Move-Zuweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528

23 Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537

Konzept der Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538

Abgeleitete Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 540

Elemente abgeleiteter Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542

Elementzugriff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544

Redefinition von Elementen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546

Auf- und Abbau abgeleiteter Klassen . . . . . . . . . . . . . . . . . . . . . . . 548

Objekte abgeleiteter Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550

protected-Deklarationen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552

Weitere Zugriffseinschränkungen . . . . . . . . . . . . . . . . . . . . . . . . . . 554

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 560

24 Typumwandlung in Klassenhierarchien . . . . . . . . . . . 569

Konvertierung in Basisklassen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 570

Typumwandlung bei Zuweisungen . . . . . . . . . . . . . . . . . . . . . . . . . 572

Konvertierung von Referenzen und Zeigern. . . . . . . . . . . . . . . . . . . 574

Explizite Typumwandlungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 576

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 578

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 580

25 Polymorphe Klassen . . . . . . . . . . . . . . . . . . . . . . . . . 583

Polymorphie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584

Virtuelle Methoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586

Abbau dynamischer Objekte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588


Inhaltsverzeichnis

15

Virtuelle Methodentabelle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590

Dynamische Casts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 598

26 Abstrakte Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . 605

Rein virtuelle Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606

Abstrakte und konkrete Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . 608

Zeiger und Referenzen auf abstrakte Klassen . . . . . . . . . . . . . . . . . 610

Virtuelle Zuweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 612

Anwendung: Inhomogene Listen. . . . . . . . . . . . . . . . . . . . . . . . . . . 614

Implementierung einer inhomogenen Liste . . . . . . . . . . . . . . . . . . . 616

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620

27 Mehrfachvererbung . . . . . . . . . . . . . . . . . . . . . . . . . . 627

Mehrfach abgeleitete Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 628

Mehrfache indirekte Basisklassen . . . . . . . . . . . . . . . . . . . . . . . . . . 630

Virtuelle Basisklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632

Aufrufe von Konstruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 634

Initialisierung virtueller Basisklassen . . . . . . . . . . . . . . . . . . . . . . . . 636

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642

28 Ausnahmebehandlung . . . . . . . . . . . . . . . . . . . . . . . 647

Traditionelle Fehlerbehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . 648

Exception-Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 650

Exception-Handler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652

Auslösen und Auffangen von Exceptions . . . . . . . . . . . . . . . . . . . . . 654

Schachteln von Ausnahmebehandlungen . . . . . . . . . . . . . . . . . . . . 656

Definition eigener Fehlerklassen. . . . . . . . . . . . . . . . . . . . . . . . . . . 658

Standardfehlerklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 660

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 662

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 666



16

29 Mehr über Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . 677

Dateien für wahlfreien Zugriff öffnen . . . . . . . . . . . . . . . . . . . . . . . 678

Wahlfreies Positionieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 680

Wahlfreies Positionieren (Fortsetzung). . . . . . . . . . . . . . . . . . . . . . . 682

Dateistatus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 684

Exception-Handling für Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . 686

Persistenz von polymorphen Objekten . . . . . . . . . . . . . . . . . . . . . . 688

Persistenz von Objekten (Fortsetzung) . . . . . . . . . . . . . . . . . . . . . . . 690

Anwendung: Indexdateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 692

Implementierung eines Index-Dateisystems. . . . . . . . . . . . . . . . . . . 694

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 696

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 700

30 Mehr über Zeiger . . . . . . . . . . . . . . . . . . . . . . . . . . . 721

Zeiger auf Zeiger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 722

Variable Anzahl von Argumenten . . . . . . . . . . . . . . . . . . . . . . . . . . 724

Zeiger auf Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 728

Komplexe Deklarationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 730

Definition von Typnamen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 732

Matrizen als Argumente von Funktionen . . . . . . . . . . . . . . . . . . . . . 734

Anwendung: Dynamische Matrizen. . . . . . . . . . . . . . . . . . . . . . . . . 736

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 738

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 740

31 Bitmanipulationen . . . . . . . . . . . . . . . . . . . . . . . . . . . 749

Logische Bitoperatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 750

Shift-Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 752

Bitmasken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 754

Verwenden von Bitmasken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 756

Bitfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 758

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 760

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 762


Inhaltsverzeichnis

17

32 Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 767

Funktions- und Klassen-Templates . . . . . . . . . . . . . . . . . . . . . . . . . 768

Definition von Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 770

Instantiierung von Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 772

Template-Parameter. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 774

Template-Argumente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 776

Spezialisierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 778

Default-Argumente von Templates . . . . . . . . . . . . . . . . . . . . . . . . . 780

Explizite Instantiierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 782

Variable Anzahl von Parametern. . . . . . . . . . . . . . . . . . . . . . . . . . . 784

Standard-Templates für Bitsets . . . . . . . . . . . . . . . . . . . . . . . . . . . . 786

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 790

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 794

33 Container . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 801

Arten von Containern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 802

Sequenzielle Container-Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . 804

Iteratoren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 806

Vereinbarung sequenzieller Container . . . . . . . . . . . . . . . . . . . . . . 808

Einfügen in sequenziellen Containern. . . . . . . . . . . . . . . . . . . . . . . 810

Elementzugriff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 812

Größe von Containern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 814

Löschen in sequenziellen Containern . . . . . . . . . . . . . . . . . . . . . . . 816

Listenoperationen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 818

Assoziative Container . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 820

Sets und Multisets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 822

Maps und Multimaps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 824

Initialisierungslisten und Range-for-Schleifen . . . . . . . . . . . . . . . . . 826

Hash-Tabellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 828

Ungeordnete assoziative Container . . . . . . . . . . . . . . . . . . . . . . . . 830

Hash-Tabellen für selbstdefinierte Typen. . . . . . . . . . . . . . . . . . . . . 832

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 834

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 838



18

34 Smart Pointer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 847

Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 848

Die Smart Pointer der Standardbibliothek . . . . . . . . . . . . . . . . . . . . 850

Smart Pointer vom Typ unique_ptr<T> einsetzen . . . . . . . . . . . . . . 852

Smart Pointer vom Typ unique_ptr<T> einsetzen (2) . . . . . . . . . . . . 854

Das Klassen-Template shared_ptr . . . . . . . . . . . . . . . . . . . . . . . . . . 856

Das Klassen-Template shared_ptr (2) . . . . . . . . . . . . . . . . . . . . . . . 858

Das Klassen-Template shared_ptr (3) . . . . . . . . . . . . . . . . . . . . . . . 860

Das Klassen-Template weak_ptr . . . . . . . . . . . . . . . . . . . . . . . . . . . 862

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 864

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 868

35 Multithreading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 879

Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 880

Erzeugen und Ausführen von Threads . . . . . . . . . . . . . . . . . . . . . . . 882

Initialisierung und Zuweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 884

Konkurrierende Speicherzugriffe. . . . . . . . . . . . . . . . . . . . . . . . . . . 886

Thread-ID . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 888

Locks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 890

Bedingungsvariablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 892

Bedingungsvariablen (Fortsetzung) . . . . . . . . . . . . . . . . . . . . . . . . . 894

Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 896

Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 900

36 Algorithmen der Standardbibliothek . . . . . . . . . . . . . 907

Algorithmen: Grundlagen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 908

Funktionsobjekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 910

Lambda-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 914

Algorithmen und Iteratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 916

Vordefinierte Iteratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 918

Nicht-modifizierende Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . 920

Modifizierende Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 924

Mutierende Algorithmen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 928

Sortieren und verwandte Operationen . . . . . . . . . . . . . . . . . . . . . . 930


Inhaltsverzeichnis

19

37 Numerische Bibliothek . . . . . . . . . . . . . . . . . . . . . . . . 935

Komplexe Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 936

Das Klassen-Template complex<T> . . . . . . . . . . . . . . . . . . . . . . . . 938

Methoden von complex<T> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 940

Komplexe Funktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 942

Das Klassen-Template valarray<T> . . . . . . . . . . . . . . . . . . . . . . . . 944

Zuweisung numerischer Vektoren . . . . . . . . . . . . . . . . . . . . . . . . . . 946

Arithmetische Operationen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 948

Weitere Operationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 950

Selektive Indizierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 952

Verallgemeinerte selektive Indizierung . . . . . . . . . . . . . . . . . . . . . . 954

Verallgemeinerte selektive Indizierung (Forts.) . . . . . . . . . . . . . . . . 956

Indirekte und maskierte Indizierung . . . . . . . . . . . . . . . . . . . . . . . . 958

Anhang A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 961

Binäre Zahlendarstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 962

Präprozessor-Direktiven . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 965

Vordefinierte Standardmakros . . . . . . . . . . . . . . . . . . . . . . . . . . . . 971

Einbinden von C-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 972

Operatorenübersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 974

Vorrangtabelle für Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . 976

ASCII-Code-Tabelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 977

Bildschirmsteuerzeichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 979

Compiler, Beispiele und Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . 980

Anhang B . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 983

Glossar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 983

Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . 1003


23

Kapitel 1

Grundlagen

Dieses Kapitel beschreibt die grundlegenden Eigenschaften der objektorientier-ten Programmiersprache C++. Außerdem werden die Schritte vorgestellt, diezur Erstellung eines lauffähigen C++-Programms erforderlich sind. DieseSchritte können Sie auf Ihrem System anhand von einführenden Beispielennachvollziehen. Die Beispiele dienen auch dazu, die grundlegende Struktureines C++-Programms darzustellen.


Kapitel 1 C++ Lernen und professionell anwenden

24

Entwicklung und Eigenschaften von C++

Charakteristische Eigenschaften


Grundlagen

25

Historisches

Die Programmiersprache C++ wurde von Bjarne Stroustrup und seinen Mitar-beitern in den Bell Laboratories (AT&T, USA) entwickelt, um Simulationspro-jekte objektorientiert und effizient implementieren zu können. Frühe Versionen,die zunächst als „C mit Klassen“ bezeichnet wurden, gibt es seit 1980. Der NameC++ weist darauf hin, dass C++ aus der Programmiersprache C hervorgegangenist: ++ ist der Inkrementoperator von C.

Schon 1989 wurde ein ANSI-Komitee (American National Standards Institute)gebildet, um die Programmiersprache C++ zu standardisieren. Hierbei geht esdarum, dass möglichst viele Compilerbauer und Software-Entwickler sich aufeine einheitliche Sprachbeschreibung einigen, um die Bildung von Dialektenund „Sprachverwirrungen“ zu vermeiden.

Anfang 1998 wurde von der ISO (International Organization for Standardiza-tion) der Standard für C++ (14882) verabschiedet, der 2003 erweitert und imOktober 2011 wesentlich ergänzt wurde. Der neueste Standard von 2011 wirdauch kurz mit C++11 bezeichnet.

Eigenschaften von C++

C++ ist keine rein objektorientierte Sprache, sondern eine Hybridsprache(= „Mischsprache“): Sie enthält die Programmiersprache C als Teilmenge. Damithat man zunächst alle Möglichkeiten, die auch C bietet:

● universell einsetzbare, modulare Programme

● effiziente, maschinennahe Programmierung

● Portabilität, d.h. Übertragbarkeit von Programmen auf verschiedene Rechner

Insbesondere kann die umfangreiche in C entwickelte Software auch in C++-Programmen verwendet werden.

C++ unterstützt die Konzepte der objektorientierten Programmierung, nämlich:

● Datenabstraktion, d.h. Bildung von Klassen zur Beschreibung von Objekten

● Datenkapselung für den kontrollierten Zugriff auf die Daten von Objekten

● Vererbung durch Bildung abgeleiteter Klassen (auch mehrfach)

● Polymorphie (griech. „Vielgestaltigkeit“), d.h. die Implementierung vonAnweisungen, die zur Laufzeit verschiedene Wirkungen haben können

C++ wurde um zusätzliche Sprachelemente erweitert, wie z.B. Referenzen, Tem-plates und Ausnahmebehandlung (engl. Exception Handling). Auch wenn dieseSprachelemente keinen direkten Bezug zur Objektorientierung haben, sind siefür deren effiziente Implementierung wichtig.



26

Objektorientierte Programmierung

Traditionelles Konzept

Objektorientiertes Konzept


Grundlagen

27

Klassische, prozedurale Programmierung

Die traditionelle, prozedurale Programmierung trennt Daten und Funktionen(= Unterprogramme, Prozeduren), die diese Daten bearbeiten. Dies hat wichtigeKonsequenzen für den Umgang mit den Daten in einem Programm:

● Der Programmierer muss selbst dafür sorgen, dass Daten vor ihrer Verwen-dung mit geeigneten Anfangswerten versehen sind und dass beim Aufrufeiner Funktion korrekte Daten übergeben werden.

● Wird die Darstellung der Daten geändert, z.B. ein Datensatz erweitert, somüssen auch die zugehörigen Funktionen entsprechend angepasst werden.

Beides ist natürlich fehleranfällig und nicht besonders wartungsfreundlich.

Objekte

Die objektorientierte Programmierung (OOP) stellt die Objekte in den Mittel-punkt, d.h. die Dinge, um die es bei der jeweiligen Problemstellung geht. EinProgramm zur Verwaltung von Konten beispielsweise arbeitet mit Kontostän-den, Kreditlimits, Überweisungen, Zinsberechnungen usw. Ein Objekt, das einKonto in einem Programm darstellt, besitzt dann die Eigenschaften und Fähig-keiten, die für die Kontoverwaltung wichtig sind.

Die Objekte in der OOP bilden eine Einheit aus Daten (= Eigenschaften) undFunktionen (= Fähigkeiten). Mit einer Klasse wird ein Objekt-Typ definiert, dersowohl die Eigenschaften als auch die Fähigkeiten von Objekten dieses Typsfestlegt. Die Kommunikation zwischen Objekten erfolgt dann durch „Nachrich-ten“, die die Fähigkeiten von Objekten aktivieren.

Vorteile der OOP

Für die Software-Entwicklung hat die objektorientierte Programmierungwesentliche Vorteile:

● geringere Fehleranfälligkeit: Ein Objekt kontrolliert den Zugriff auf seineDaten selbst. Insbesondere kann es fehlerhafte Zugriffe abwehren.

● gute Wiederverwendbarkeit: Ein Objekt verwaltet sich selbst. Es kann des-halb wie ein Baustein in beliebigen Programmen eingesetzt werden.

● geringer Wartungsaufwand: Ein Objekt kann die interne Darstellung seinerDaten an neue Anforderungen anpassen, ohne dass ein Anwendungspro-gramm etwas davon merkt.



28

Erstellen eines C++-Programms

Übersetzen eines C++-Programms


Grundlagen

29

Zum Erstellen und Übersetzen eines C++-Programms sind folgende drei Schrittenotwendig:

1. Das C++-Programm wird mit einem Texteditor in eine Datei eingegeben.Anders gesagt: Der Quellcode wird in einer Quelldatei abgelegt.

Bei größeren Projekten ist es üblich, modular zu programmieren. Dabei wirdder Quellcode auf mehrere Quelldateien verteilt, die getrennt bearbeitet undübersetzt werden.

2. Die Quelldatei wird dem Compiler zur Übersetzung gegeben. Geht alles gut,so erhält man eine Objektdatei, die den Maschinencode enthält. Eine Objektda-tei heißt auch Modul.

3. Schließlich bindet der Linker die Objektdatei mit anderen Modulen zu einerausführbaren Datei. Die Module bestehen aus Funktionen der Standardbiblio-thek oder selbsterstellten, schon früher übersetzten Programmteilen.

Im Namen der Quelldateien muss die richtige Endung angegeben werden. Diesehängt vom jeweiligen Compiler ab. Die gebräuchlichsten Endungen sind .cppund .cc.

Vor dem eigentlichen Kompiliervorgang können Header-Dateien, auch Include-Dateien genannt, in die Quelldatei kopiert werden. Header-Dateien sind Textda-teien mit Informationen, die in verschiedenen Quelldateien gebraucht werden,wie z.B. Typdefinitionen oder die Deklaration von Variablen und Funktionen.Die Namen von Header-Dateien enden entweder mit .h oder haben keineEndung.

Die C++-Standardbibliothek enthält fertige Funktionen und Klassen, die standar-disiert sind und die jeder Compiler zur Verfügung stellt.

Moderne Compiler bieten eine integrierte Entwicklungsumgebung, die die obigendrei Schritte zusammenfasst. Von einer einheitlichen Benutzeroberfläche auswird das Programm editiert, kompiliert, gelinkt und ausgeführt. Außerdemkönnen weitere Tools, wie z.B. ein Debugger, gestartet werden.

Wichtig: Enthält die Quelldatei auch nur einen Syntaxfehler, so zeigt dies derCompiler mit einer Fehlermeldung an. Darüber hinaus können weitere Fehlermel-dungen ausgegeben werden, die darauf beruhen, dass der Compiler versucht,trotz des Fehlers weiter zu übersetzen. Beginnen Sie also immer mit der Korrek-tur des ersten Fehlers in einem Programm.

Neben den eigentlichen Fehlermeldungen gibt der Compiler auch Warnungenaus. Eine Warnung zeigt keinen Syntaxfehler an, sondern ist lediglich ein Hin-weis auf einen möglichen logischen Fehler, wie beispielsweise die Verwendungeiner nicht initialisierten Variablen.



30

Ein erstes C++-Programm

Beispielprogramm

Bildschirmausgabe

Viel Spaß mit C++!

Die Struktur der Funktion main()

#include <iostream> using namespace std;

int main() { cout << "Viel Spaß mit C++!" << endl; return 0; }


Grundlagen

31

Ein C++-Programm besteht aus Objekten mit ihren Elementfunktionen und ausglobalen Funktionen, die zu keiner Klasse gehören. Jede Funktion löst einebestimmte Aufgabe und kann andere Funktionen aufrufen. Sie ist entwederselbsterstellt oder eine fertige Routine aus der Standardbibliothek. Die globaleFunktion main() muss immer selbst geschrieben werden und hat eine beson-dere Rolle: Sie bildet das Hauptprogramm.

Anhand des nebenstehenden kurzen Beispielprogramms lassen sich bereits diewichtigsten Elemente eines C++-Programms erkennen. Das Programm enthältnur die Funktion main() und gibt eine Meldung auf dem Bildschirm aus.

Die erste Zeile beginnt mit einem Doppelkreuz # und ist daher für den Präpro-zessor bestimmt. Der Präprozessor ist Teil der ersten Übersetzungsphase, in dernoch kein Objektcode erzeugt wird. Mit

#include <dateiname>

kopiert der Präprozessor die genannte Datei an diese Stelle in den Quellcode.Dadurch stehen dem Programm alle Informationen zur Verfügung, die in dieserDatei enthalten sind.

Die Header-Datei iostream enthält Vereinbarungen für die Ein-/Ausgabe mitStreams. Der Begriff Stream (dt. Strom) spiegelt die Situation wider, dass Zeichen-folgen wie ein Datenstrom behandelt werden.

Die in C++ vordefinierten Namen befinden sich im Namensbereich std (stan-dard). Die anschließende using-Direktive erlaubt, die Namen aus demNamensbereich (Namespace) std direkt zu verwenden.

Die Programmausführung beginnt mit der ersten Anweisung in der Funktionmain(), die daher in jedem C++-Programm vorhanden sein muss. Nebenste-hend ist die Struktur der Funktion dargestellt. Sie unterscheidet sich, abgesehenvom feststehenden Namen, nicht von der Struktur anderer Funktionen.

In unserem Beispiel enthält die Funktion main() zwei Anweisungen. Die erste

cout << "Viel Spaß mit C++!" << endl;

gibt den Text Viel Spaß mit C++! auf dem Bildschirm aus. Der Name cout(console output) bezeichnet ein Objekt, das die Ausgabe durchführt.

Die beiden Kleiner-Zeichen << deuten an, dass die Zeichen in den Ausgabe-strom „geschoben“ werden. Mit endl (end of line) wird anschließend ein Zei-lenvorschub ausgelöst. Die zweite Anweisung

return 0;

beendet die Funktion main() und damit das Programm. Dabei wird der Wert 0dem aufrufenden Programm als Exit-Code zurückgegeben. Es ist üblich, denExit-Code 0 zu verwenden, wenn das Programm korrekt abgelaufen ist.

Beachten Sie, dass die Anweisungen mit einem Semikolon enden. Die kürzesteAnweisung besteht übrigens nur aus einem Semikolon und bewirkt nichts.



32

Struktur einfacher C++-Programme

Ein C++-Programm mit mehreren Funktionen

Bildschirmausgabe

Hallo! Das Programm startet in main().------------------------------In der Funktion meldung().------------------------------Jetzt am Ende von main().

/****************************************************** Ein Programm mit mehreren Funktionen und Kommentaren ******************************************************/

#include <iostream>using namespace std;

void linie(), meldung(); // Prototypen

int main(){ cout << "Hallo! Das Programm startet in main()." << endl; linie(); meldung(); linie(); cout << "Jetzt am Ende von main()." << endl;

return 0;}

void linie() // Eine Linie ausgeben.{ cout << "--------------------------------" << endl;}

void meldung() // Eine Meldung ausgeben.{ cout << "In der Funktion meldung()." << endl;}


Grundlagen

33

Das nebenstehende Beispiel zeigt, wie ein C++-Programm strukturiert ist, dasaus mehreren Funktionen besteht. Die Reihenfolge, in der Funktionen definiertwerden, ist in C++ nicht vorgeschrieben. Zum Beispiel könnte auch zuerst dieFunktion meldung(), dann die Funktion linie() und schließlich die main-Funktion geschrieben werden.

Üblicherweise wird die Funktion main() zuerst angegeben, da sie den Pro-grammablauf steuert. Es werden also Funktionen aufgerufen, die erst späterdefiniert werden. Dies ist möglich, da der Compiler mit dem Prototyp einerFunktion die notwendigen Informationen erhält.

Neu in diesem Beispiel sind die Kommentare. Jede Zeichenfolge, die durch /* . . . */ eingeschlossen ist oder mit // beginnt, ist ein Kommentar.

Beispiele: /* Ich darf mehrere Zeilen lang sein */// Ich bin ein Einzeilen-Kommentar

Beim Einzeilen-Kommentar ignoriert der Compiler ab den Zeichen // alle Zei-chen bis zum Zeilenende. Kommentare, die sich über mehrere Zeilen erstrecken,sind bei der Fehlersuche nützlich, um ganze Programmteile auszublenden. Jededer beiden Kommentarformen kann auch benutzt werden, um die andere aus-zukommentieren.

Zum Layout einer Quelldatei: Der Compiler bearbeitet jede Quelldatei sequenzi-ell und zerlegt den Inhalt in „Token“ (kleinste Bestandteile), wie z.B. Funk-tionsnamen und Operatoren. Token können durch beliebig viele Zwischenraum-zeichen getrennt sein, also durch Leer-, Tabulator- oder Newline-Zeichen. Eskommt daher nur auf die Reihenfolge des Quellcodes an, nicht auf ein bestimm-tes Layout, wie etwa die Aufteilung in Zeilen und Spalten. Beispielsweise ist

void meldung ( ){ cout << "In der Funktion meldung()." <<endl;}

zwar eine schlecht lesbare, aber korrekte Definition der Funktion meldung().

Eine Ausnahme hinsichtlich des Layouts bilden die Präprozessor-Direktiven,die stets eine eigene Zeile einnehmen. Dem Doppelkreuz # zu Beginn einer Zeiledürfen nur Leer- und Tabulatorzeichen vorangehen.

Zur besseren Lesbarkeit von C++-Programmen ist es von Vorteil, einen einheitli-chen Stil in der Darstellung beizubehalten. Dabei sollten Einrückungen undLeerzeilen gemäß der Programmstruktur eingefügt werden. Außerdem ist einegroßzügige Kommentierung wichtig.



34

Übungen

Programm-Listing zur 3. Aufgabe

#include <iostream> using namespace std; void pause(); // Prototyp

int main() { cout << endl << "Lieber Leser, " << endl << "goennen Sie" << " sich jetzt eine "; pause(); cout << "!" << endl;

return 0; }

void pause() { cout << "PAUSE"; }


Grundlagen

35

1. Aufgabe

Erstellen Sie ein C++-Programm, das den folgenden Text auf dem Bildschirmausgibt:

Moegentaeten wir schon wollen,aber koennen haben wir uns nicht getraut!

Verwenden Sie den Manipulator endl an den entsprechenden Stellen.

2. Aufgabe

Das folgende Programm enthält lauter Fehler:

*/ Hier sollte man die Brille nicht vergessen //#include <stream>int main{ cout << "Wenn dieser Text", cout >> " auf Ihrem Bildschirm erscheint, "; cout << " endl;" cout << 'können Sie sich auf die Schulter ' << "klopfen!" << endl. return 0;)

Korrigieren Sie die Fehler, und testen Sie die Lauffähigkeit des Programms.

3. Aufgabe

Was gibt das nebenstehende C++-Programm auf dem Bildschirm aus?



36

Lösungen

Zur 1. Aufgabe:

// Auf geht's !

#include <iostream>using namespace std;

int main(){ cout << "Moegen " << endl; cout << "taeten wir schon wollen" << endl; cout << "aber koennen " << endl; cout << "haben wir uns nicht getraut!" << endl;

return 0;}

Zur 2. Aufgabe:

Die korrigierten Stellen sind unterstrichen.

/* Hier sollte man die Brille nicht vergessen */#include <iostream>

using namespace std;int main(){ cout << "Wenn dieser Text"; cout << " auf Ihrem Bildschirm erscheint, "; cout << endl; cout << "können Sie sich auf die Schulter " << "klopfen!" << endl; return 0;

}

Zur 3. Aufgabe:

Die Bildschirmausgabe des Programms beginnt in einer neuen Zeile:

Lieber Leser,goennen Sie sich jetzt eine PAUSE!


1003

Stichwortverzeichnis

AAbbau

dynamischer Objekte 589

von Objekten 297Ableitung

mehrfache 629abs() 941, 951Absolutwert 131, 963abstrakt

Klasse 609Abstraktion

durch Klassen 269acos() 951Adapterklasse 805Addition

von Zeigern 381Adresse 256

des aktuellen Objekts 309

Übergabe 249Vektor 385von Objekten 255, 279von Zeigern 255

Adressoperator 442Adressraum

von Hash-Dateien 698Änderungsfreundlichkeit

143Aktualisieren

von Dateien 415algorithm 70Algorithmus 909

binäre Suche 697, 812Bresenham- 789Bubble-Sort- 363Heap-Sort- 933Hot-Potatoe 835Misch- 497Mischen 814modifizierender 925mutierender 929Quick-Sort- 729, 739Selection-Sort- 397, 723,

739

Sieb des Eratosthenes 363

Splice- 497Aliasname 247allocate_shared() 861allocator 805Allokator-Klasse 805Alternative

auswählen 133Ampersand 247Analyse 269Anfangswert 53, 73, 291

eines Objekts 293von Objekten 275

Ansi.sys 979ANSI-Komitee 25Anweisung 31

abhängige 119break 133, 135continue 135goto- 135if else 127return() 199switch 133throw 651

AnwenderprogrammQuellcode 273

app 414Applikation 881apply() 951arg() 941argc 395argptr 725Argument 65, 197, 199

Kommandozeilen- 395komplexes 937Objekt als 311obligatorisches 725optionales 725Typumwandlung 169-Übergabe 201variable Anzahl 725Vektor als 385-Zeiger 725Zeigervektor 723

argv 395

Arithmetikmit Zeigern 381, 383

Array 351assoziativer 457-Klasse 456Klassen- 357

ASCII-Code 39Tabelle 977

asin() 951assert.h 70assoziativ

Array 457Container 803

Asynchronous Transfer Mode 759

at() 187, 813atan() 62, 951atan2() 62, 951ate 414ATM-Zelle 759Auflösung 787Aufruf

Exception-Handler 655Funktions- 199impliziter 297redefinierter Methoden

551von Destruktoren 297,

549von Funktionen 65von Konstruktoren 549

Aufzählung 337Ausdruck 105

boolescher 45komplexer 105logischer 113mit Referenztyp 253Typ 105Vergleichs- 111Wert 105

Ausgabe 31, 80dezimale 85hexadezimale 85linksbündig 89oktale 85rechtsbündig 89



1004

-Strom 83umlenken 153unformatierte 97von booleschen Werten

91von Strings 91von Zeichen 91

Ausgabefeld 89Ausnahmebehandlung 651

schachteln 657Ausrichtung 89

byteweise 970Auswahl 127, 133Auswahloperator 131auto 211, 229auto_ptr 850automatisch 223AVL-Baum 821

Bback() 813Backslash 49Backspace 93bad() 685bad_cast 593Basis 93, 964Basisinitialisierer 549, 635

bei Mehrfachvererbung 637

Basisklasse 539direkte 541indirekte 541mehrfache 633mehrfache indirekte 631virtuelle 633

Basisklassenzeiger 575Basistyp 255Baum 695

AVL- 821Rot-Schwarz- 821

Baumstruktur 803bedingt

Bewertung 131Kompilierung 149

Bedingungzusammengesetzte 113

Bedingungsvariable 893begin() 807, 833Begrenzungszeichen 97Belegungsfaktor 829BELL 125

Benutzeroberfläche 29Bereich

capture 915Iteratoren- 909private 271public 271

Bereichsoperator 233, 273, 333

Bereichsprüfung 187, 291, 301

Bewertungbedingte 131-Reihenfolge 113

Bezeichner 63, 233Read-Only 247

BeziehungHat- 539Ist- 539

Bias 964Bibliothek 195

iostream- 81numerische 935

bidirektionalIterator 807

BildschirmSteuerzeichen 145, 979-Treiber 979

binär 962Binärmodus 419, 679binär

Suche 933binary 414Bindung

dynamische 591späte 591statische 591

Bit-Codierung 751eof- 415fail- 415-Feld 759invertieren 755, 789löschen 755, 789Maske 755-Muster 85, 164, 755,

962, 964-Operation 751-Operator 751, 789Paritäts- 757Schreiben 789-Set 787

setzen 755, 789Vorzeichen- 962

Bitoperator 415bitset 70Block 119, 227

catch 653einer Funktion 197extern 972try- 653

blockorientiert 409blockweise

Schreiben/Lesen 419bool 39boolalpha 91break

Anweisung 133, 135Breite

eines Bitfelds 759Bresenham-Algorithmus

789Bruch

kürzen 479Rechenoperationen 460

Bubble-Sort 363Buchstabe

umwandeln 151Bucket 829Byte 41

Ausrichtung 970-Offset in Dateien 681-Position 409

CC

-Bibliotheken einbinden 972

-Funktion definieren 973

-Funktion einbinden 972-Header-Datei 71, 972-String 71

C++-Programm 29-Standardbibliothek 73,

195call by reference 201, 249,

311call by value 201, 249, 311case

Konstante 133Marke 133



1005

CastDown- 593dynamischer 593expliziter 577-Operator 169, 577statischer 577Up- 577

catch 653cctype 151cerr 80cfloat 43, 964char 39, 91

-Vektoren 355CHAR_MAX 41CHAR_MIN 41char16_t 39char32_t 39cin 80, 253class 271, 281clear() 92, 685, 817Client 897climits 41, 964clog 80close() 417cmath 63Code

von Funktionen 147Comparator

-Klasse 805Compare 805Compiler 29Compilierung

bedingte 967complex 70, 939COMSPEC 398condition_variable 893conio.h 154conj() 943const 55, 249

Methode 303-Objekt 303

const_iterator 807, 833Container

Arten 803-Bibliothek 803Kapazität 815-Klasse 805-Länge 815Löschen 817sequenziell 803ungeordneter 829

vereinbaren 809Zugriff 813

continue-Anweisung 135

Cooked Modus 414copy() 925cos() 62, 943cosh() 943count() 825cout 31, 80, 253cshift() 951cstdlib 67C-String 355ctime() 189ctype.h 70, 151Cursor 787

DDarstellung

binäre 962, 963dezimale 85exponentielle 87Festpunkt- 87-Format 962interne von Daten 269von Ganzzahlen 962von Gleitpunktzahlen

964Datei 409

aktuelle Position 409-Anfang 681ausführbare 29, 195-Ende 415, 681Geräte- 683Hash- 698Index- 693kopieren 417lesen 409-Name 413öffnen 413Pizza- 423Primär- 693-Puffer 409schließen 417schreiben 409-Status 685umlenken 153-Zugriff 409

Dateiende 150Dateiposition

ändern 679

Datenverschlüsseln 761

Datenabstraktion 25, 539Datenelement 73

abgeleiteter Klassen 543dynamisches 509konstantes 331Speicherplatz 273statisches 333variabler Länge 509von Klassen 269

Datenkapselung 25, 269, 281, 335, 455

Datenkommunikation 835Datensatz 281, 409Datensegment 227Datenstruktur

dynamische 493rekursive 495

Datentyp 39bool 39char 39const_iterator 807double 43elementarer 39float 43ganzzahliger 41-Hierarchie 163int 41ios 681iostate 685Klasse 269long 41long double 43short 41time_t 285void 43, 67, 199von Variablen 53wchar_t 39

DatenübertragungFehlererkennung 757

Datum 285, 317Deadlock 891dec 84Default

Argumente von Funk-tionen 205

-Konstruktor 293default

-Marke 133default_delete 851



1006

defined 968Definition

abgeleitete Klasse 540Funktion 197inline 203rekursiver Funktionen

209typedef 733virtueller Methoden 587von File-Streams 413von Klassen 271von Konstruktoren 291von Methoden 273von Objekten 275von Referenzen 247von Typnamen 733von Variablen 53von Vektoren 351

DeklarationException 653extern- 225, 972friend- 455komplexe 731protected 553using- 235von Funktionen 63von Konstruktoren 291von Variablen 225

Dekrement-Operator 107

delete 487, 489, 589Deleter 855, 861

selbstdefiniert 861deque 805dequeue 70Design

von Klassenhierarchien 633

Destruktor 297abgeleiteter Klassen 549Aufruf 297Default- 297für Vektorklasse 513inline 299Minimalversion 297virtueller 589

detach() 889dezimal 45Dezimalpunkt 86Diagramm

Vererbungs- 631, 635

Dimensionvon Vektoren 359

Direktive 31, 965#define 143, 147#elif 967#endif 149, 967#error 970#if 967#ifdef 149, 969#ifndef 149#include 63, 967#line 969#pragma 970#undef 149, 966using 71, 235

Division 105ganzzahlige 105mit Zweier-Potenzen

753domain_error 660Doppelpunkt 135DOS 153double 43do-while

-Schleife 125Down-Cast 577Download 980draw() 787Dreiecksmatrix 959dynamic_cast<> 593dynamisch

Bindung 591Datenelement 509Datenstruktur 493Matrix 737Speicherreservierung

485

EEinbinden

von C-Funktionen 972Einfügen

in Containern 811in Index-Datei 695in Strings 183in Maps 825

Eingabe 80fehlerhafte 95-Feld 93formatierte 92-Puffer 93Textzeile 97

umlenken 153unformatierte 97von Gleitpunktzahlen

95von Zahlen 94

Eingabepufferlöschen 92

Einheitimaginäre 937

Einheitswurzelkomlexe 953

Einlesen Siehe EingabeEinmaleins 137Element

abgeleiteter Klassen 543dynamisches 509eines Vektors 351-Zugriff 271

elementarOperation 493

Elementfunktion 31, 73, 269statische 335

Elementinitialisierer 329, 549

else-Zweig 127

else-if-Kette 129

emplace() 811, 823empty() 815end() 807, 833endl 83Endlosschleife 123Entpacken

rekursiv 785Entwicklungsumgebung

integrierte 29, 212, 273enum 337env 404Environment 399eof() 415, 685erase() 183, 817, 823Eratosthenes

Sieb des 363Eröffnungsmodus

-Flag 415für Dateien 413

errno.h 70Ersatztext 143, 965Ersetzen

in Strings 185



1007

Erweiterung 145Ganzzahl- 163, 753Null- 165Vorzeichen- 165

ESC 979Escape-Sequenz 49, 145Euler 943Exception 187

auffangen 653auslösen 651bad_cast 593-Deklaration 653-Handler 653-Handler genereller 655-Handling 651-Handling für Dateien

687-Spezifikation 657

exception 70exceptions() 687exit() 417Exit-Code 31Exklusiv ODER 751exp() 62, 943, 951explicit 477explizit

Cast 577inline 299

Exponent 214, 964Exponentialdarstellung

komplexer Zahlen 943exponentiell

Darstellung 87extend

sign- 165zero- 165

extern 231Speicherklasse 225

Ffail() 415, 685failbit 415Fakultät 213false 39, 111Fehler

-Behandlung traditio-nelle 649

-Code 417-Flag 649-Meldung 393-Nummer 393

-Objekt 651-Situation 649-Variable 649

Fehlerbehandlungfür Dateien 415für new 487

Fehlererkennungbei Datenübertragung

757Fehlerflag 95Fehlerklasse 651

bad_cast 593definieren 659domain_error 660exception 661invalid_argument 660length_error 660logic_error 661out_of_range 813overflow_error 660range_error 660runtime_error 661underflow_error 660

Fehlermeldung 29, 65, 303des Präprozessors 970

FeldBit- 759

Feldbreite 85, 89, 93Festplatte 409Festpunktdarstellung 87Festpunktzahl 86Fibonacci

-Quotient 353-Zahl 353

FIFO-Prinzip 803File-Stream

Definition 413-Klassen 411

fill() 88Filterprogramm 151, 153finale Klasse 541finale Methoden 586find() 185, 825, 921first 825fixed 86Flag 45, 415

Eröffnungsmodus- 414Fehler- 649ios 685Positionierungs- 681Status- 415, 685von ios 83

flip() 789float 43float.h 70floating point types 42for

-Schleife 121for_each() 913, 921Form

normalisierte 964Format

IEEE- 964Formatierung 83Formel

Eulersche 943Forward-Iterator 917Fourier-Transformierte 953Freispeicher 485Freund 455friend

-Deklaration 455-Funktion 453-Klasse 455-Konzept 453

front() 813fstream 70, 411Füllzeichen 89functional 70Funktion

Aufruf 65, 199Block 197definieren 197Deklaration 199externe 231friend- 453globale 31, 195, 311Hash- 698, 829inline- 203inverse trigonometri-

sche 951Kopf 197main() 31Merge- 497Name 197Operator 445Prototyp 197rekursive 209Return-Wert 199Signatur 207Speicherklasse 231Splice- 497static- 231



1008

transzendente 943trigonometrische 943Typ 197überladen 207Version 205Zeigerversion 387

Funktionsobjekt 911vordefiniertes 913

GGanzzahl 962

-Erweiterung 163, 753positive 962

Geltungsbereichglobal 225von Variablen 223

Genauigkeit 43, 87, 964Generator

Programm 969Gerade

zeichnen 789Geschwindigkeit 129

vergleichen 739get() 97get_id() 889getch() 154getline() 73, 97, 177, 421Gleichung

quadratische 260Gleitpunktdarstellung 43Gleitpunktdivision 443Gleitpunktkonstante 47Gleitpunkttyp 43Gleitpunktzahl 43, 47, 87

interne Darstellung 964global

Funktion 195Variable 53Vektor 353

good() 685goto

-Anweisung 135Grad 945Großbuchstabe 151

HHandler

Exception- 653Hash

Datei 698Funktion 698

Hashfunktion 829Hash-Tabelle 803, 829Hat-Beziehung 327, 539Hauptwert

komplexe Zahl 937Logarithmus 943

Headervon ATM-Zellen 758

Header-Datei 29, 69, 147, 149, 273, 964C- 972cctype 151cfloat 43, 964climits 41, 964complex 939conio.h 154cstdlib 67ctype.h 151deque 804fstream 411iostream 31, 69list 804map 820memory 850queue 804set 820stack 804stdlib.h 67string 71, 177Suche nach 967valarray 945vector 804

Heap 485, 933Heap-Sort-Algorithmus 933hex 84hexadezimal 45, 85Hierarchie

der Fehlerklassen 661von Datentypen 163

highvalue 172

Horner-Schema 947Hot-Potato-Algorithmus

835HUGE_VAL 214Hyperbelfunktion 943

IIdentifier 63IEEE 42IEEE-Format 964

if-else-Anweisung 127ifstream 411imag() 941imaginär

Einheit 937Imaginärteil 937Implementierung

von Klassen 301implizit

inline 299Typanpassung 163

in 414INCLUDE 967Include-Datei 29include-Verzeichnis 69Index 187, 683

-Datei 693-Operator 187, 813-Operator für Vektor-

klasse 515-Operator überladen

457-Überprüfung 187unzulässiger 187Vektor- 351-Version 387

Indizierungindirekte 959maskierte 959selektive 953

Inhaltvon Unions 283

inhomogenListe 615

Initialisierung- direkte 295explizite 489-Liste 299mit Konstruktoren 291statischer Objekte 227Vektor 353vereinheitlichte 827virtueller Basisklassen

637von const-Objekten 303von Datensätzen 281von Klassen-Arrays 357von Objekten 293von Referenzen 247von Strings 177von Teilobjekten 329von Variablen 53



1009

Initialisierungsliste 827Inititialisierung

von Objekten 275von Schleifen 121

InkonsistenzBetriebsmittel 887

Inkrement-Operator 107

inline 203-Methoden 299

input() 727insert() 183, 810, 823Insert-Iterator 919Instanz 73

von Klassen 275int 41INT_MAX 41INT_MIN 41integral

promotion 163integral types 42Interface

polymorphes 611internal 88Interpretation

von Bitmustern 165invalid_argument 660Invertieren

von Bits 755von Listen 819

iomanip 70, 87ios 70, 81, 83, 414ios::badbit 685ios::beg 681ios::cur 681ios::end 681ios::eofbit 685ios::failbit 685ios::goodbit 685ios::seekdir 681iosfwd 70iostate 685iostream 31, 69, 70, 81is_open() 417isalnum() 150isalpha() 150isdigit() 150islower() 150, 151iso646.h 70isprint() 150

isspace() 150Ist-Beziehung 539istream 70, 81isupper() 150Iterator 807, 917

bidirektionaler 807, 917Forward 917Input 917Insert 919Output 917Random-Access 807,

917Stream 917

iterator 70, 807, 833

Jjoin() 883

Kkbhit() 154Kellerstapel 803Kette

else-if- 129Key to Address Transfor-

mation 698Klammern 145Klasse

complex 939finale 541gslice 955HashEntry 699HashFile 699Index 685IndexEntry 683IndexFile 695KontoFile 691Polynom 945, 947slice 953thread 883valarray 945VekQueue<T> 835

Klasse Siehe auch Standard-klasse 445abgeleitete 539abstrakte 609Adapter- 805Ampel 337, 341Angestellter 611Arbeiter 609Array- 456

Artikel 315, 339Basis- 539Cell 615Comparator 805Container 805Datum 285, 317DayTime 445Definition 271Euro 447File-Stream- 411FloatVek 456, 509, 527Fraction 461friend- 455für Brüche 461für Vektoren 457GiroKonto 557InhomList 617iostream 81istream 81Kfz 539, 543Kombi 633konkrete 609Konto 271, 421Konzept 269Liste 495Lkw 557Matrix 737mehrfach abgeleitete

629MessStation 454Messwert 327, 454Mitarbeiter 607Mitglied 339ostream 81PackedFood 559Pkw 543polymorphe 585Product 559sortVec 809SparKonto 557StadtAuto 595Standard- 73TelList 361, 365, 425Transporter 641Typumwandlung 473UnpackedFood 559Wohnwagen 639Zeile 737zur Darstellung von

Vektoren 361



1010

Klassen-Array 357Klassenhierarchie

Design 633Typumwandlung 571

Klassenvariable 333Kleinbuchstabe 151Koeffizient 945Kollision

beim Hashing 698Kommando 153

-Interpreter 417-Zeile 212

KommandozeileArgumente 395

Kommaoperator 123, 442Kommentar 33Kompatibilität

zu C 281Kompilierung

bedingte 149Komplement

Zweier- 963komplex

Deklaration 731konkret 609Konstante 45

boolesche 45case- 133enum- 337Gleitpunkt- 47klassenspezifische 337numerische 45String- 47symbolische 141, 143,

965Zeichen- 47

Konstruktor 291abgeleiteter Klassen 549Aufruf 293Default- 293Definition 291Delegation 295explicit 477für Vektorklasse 513inline- 299Kopier- 305, 517Minimalversion 293Move- 521überladen 291

Konto 271Kontrollblock 857

KonventionNamens- 271

Konvertierungfür Klassen 473-Funktion 473in Basisklasse 571-Konstruktoren 472von Argumenten 169von Ganzzahlen 165von Referenzen 575von Smart Pointern 859von Zeigern 575

KopieRückgabe 313von Objekten 311

Kopier-Konstruktor 305, 517

Kürzenvon Brüchen 479

LLänge

von Strings 73, 177von Vektoren 385

Lambda-Ausdruck 914-Funktionen 914

Längenumerischer Vektor 945

Laufbedingung 119Laufzeit 203, 299Layout 129ldexp() 62Lebensdauer

automatisch 223statisch 223, 227von Variablen 223

left 88length() 73, 177length_error 660Lesbarkeit 143Lesen

aus Dateien 409blockweises 419

less 805lexikografisch 181LIFO-Prinzip 201, 803limits 70limits.h 70linear

Lösung beim Hashing 698

Linearisierung 955Linker 29, 195linksbündig 89list 70, 805Liste 527

Container 805doppelt verkettete 805einfach verkettete 493einfügen 617für Vektorelemente 353inhomogene 615, 859Initialisierungs- 281invertieren 819mischen 819Operationen 819Parameter 197sortieren 819verschweißen 819von Elementinitialisie-

rern 329von Exceptions 657

Listenelement 493Literal 45load factor 829locale 70locale.h 70localtime() 285lock() 887lock_guard 891Löschen

in Containern 817in Sets 823in Strings 183von Bits 755

Lösunglineare, beim Hashing

698log() 62, 943, 951log10() 62, 943, 951lokal 201, 223

Variable 53Vektor 353

long 41long double 43long long 41L-Wert 257

Mmain() 197

Parameter 395make_heap() 933



1011

make_shared() 861MAKE-Utility 195Makro 141, 143, 965

__cplusplus 971__DATE__ 971__FILE__ 971__LINE__ 971__STDC__ 971__TIME__ 971isalnum() 150isalpha() 150isdigit() 150islower() 150, 151isprint() 150isspace() 150isupper() 150, 151mit Parametern 145-Namen 143tolower() 151toupper() 151va_end() 727va_start() 725

Mandelbrot-Menge 940Manipulation

von Bits 789Manipulator 83Mantisse 964Map 803

Einfügen 825ungeordnete 831vereinbaren 825

map 70, 820Marke 135

case- 133default- 133private 271public 271

maschinenabhängig 964Maschinencode 29, 197

von Methoden 275Maschinenregister 41Maske

Bit- 755Massenspeicher 409math.h 70, 214Matrix 359, 955

dynamische 737max() 951max_size() 815Mehrdeutigkeit

bei Mehrfachvererbung 631

bei Typumwandlungen 207, 477

Mehrfachvererbung 629member 271memory 70, 850Menüauswahl 133merge() 497, 819, 931Methode 73, 269

Definition 273Dummy- 607finale 586inline 299Read-Only- 303Standard- 305statische 335virtuelle 585virtuelle definieren 587

min() 951Minor 957Mischen

von Listen 819von Vektoren 497

Modifizierer 41Modul 29, 195, 223, 273modulglobal 223, 227

Funktion 231Modulo

-Division 105Modus

Binär- 419Cooked 414Raw 414update- 415

move() 787Move-Konstruktor 521Move-Zuweisung 525Multimap 820, 821, 825

ungeordnete 831Multiplikation

mit Zweier-Potenzen 753

Multiset 820, 823ungeordnetes 831

Mutex 887rekursiv 891

NName 51, 233

Deklaration von 63Funktion 197, 729

Regeln für die Vergabe 271

Suche 545verdecken 547von Bitfeldern 759von Klassen 271von Konstruktoren 291von Makros 143von Vektoren 351, 379

Namensbereich 71, 223, 233Namenskonflikt 71, 233namespace 71, 233new 70, 485New-Handler 487Newline 73NICHT 751NICHT-Operator 113noboolalpha 91Norm

komplexer Zahl 943norm() 943noshowpoint 86noshowpos 84Not-any-thread 889Notation

exponentielle 87Postfix 107Präfix- 107

notify_one() 895nouppercase 84NULL 256Null-Erweiterung 165numeric 70numeric_limits 964

OObjekt 27, 53, 73

Abbau 297, 589abgeleiteter Klassen 551Adresse 309als Argument 311als Return-Wert 313auto- 229const- 303Definition 275degeneriertes 955Eigenschaften 269Fähigkeiten 269global 223in Datei speichern 421konstant 55



1012

lokal 201, 223modulglobal 223, 227Name 225persistent 689Persistenz 421Read-Only- 55statisches 227Typ 225-Übergabe 311Zeiger auf 279zuweisen 277

Objektdatei 29Objektsammlung 803obligatorisch

Argument 725oct 84ODER 751

exklusiv 750, 751ODER-Operator 113öffentlich 73

Schnittstelle 543, 555Öffnen

von Dateien 413ofstream 411oktal 45OOP Siehe Programmie-

rung, objektorientierteopen() 413openmode 414Operand 105

symmetrischer 449Operation 105

elementare 493für Container 803für Listen 819Invertieren 819Mischen 819Splice- 819

Operator 233, 273 939- 107, 939-- 107! 113!= 111, 939# 965## 966% 939& 751&& 113() 169* 257, 939

*= 947+ 107, 179, 939++ 107+= 179, 947, 123. 277/ 939/= 947:: 273, 333< 111<< 81, 253, 751<= 111-= 947= 109, 277== 111, 939-> 279> 111>= 111>> 81, 177, 253, 751, 939? 131^ 751| 415, 751|| 113~ 751arithmetischer 105Auswahl- 131Bereichs- 273, 333binärer 105Bit- 751boolescher 113Cast 169, 577defined 968Dekrement- 107delete 487, 489dynamic_cast<> 593-Funktion 445-Funktion als Methode

449Funktion globale 451Funktion virtuelle 613Index- 187, 813Inkrement- 107Komma- 123logischer 113logischer Bit- 751mit Referenztyp 253new 485, 489NICHT 113, 751nicht überladbarer 443ODER 113, 751Pfeil- 279

Punkt- 277Shift- 751, 753Shift- überladen 459sizeof 43überladbarer 442-Überladung 442unärer 105unärer arithmetischer

106UND 113, 751Vergleichs- 111Verweis- 257virtueller 613Vorzeichen 107Zuweisungs- 109, 277,

519operator-() 452operator*() 452operator+() 452operator+=() 446operator/() 452operator<<() 458, 459operator-=() 446operator>>() 458Operatoren

Übersicht 974Vorrangtabelle 976

optionalArgument 725

ostream 70, 81out 414out_of_range 660, 813Output-Iterator 917overflow_error 660Overhead 299overloading 207, 443override 586

PPaar

Schlüssel-/Objekt- 825pair 825Palindrom 189Parameter 197

aus Kommandozeile 395

-Liste 197mehrdimensionaler

Vektor 387-Pack 785Read-Only-Zeiger 389



1013

Typumwandlung 169variable Anzahl 725, 785von main() 395von Makros 145Zeiger 259

Paritätsbit 757Passwort 227past token 966PATH 398

-Variable 153payload 759Performance

-Test 739Persistenz 409

polymorpher Objekte 689

von Objekten 421Pfadangabe 967Pfeiloperator 279PI 143picture element 787Pixel 787Pizza 423Platzhalter 145Pointer 255

Smart- 847polar() 941Polarkoordinaten 937, 941polymorph

Schnittstelle 611Polymorphie 25, 585Polynom 945

Produkt 949Summe 949

pop_back() 817pop_front() 817Position

Byte- 409Cursor- 787in Containern 807in Strings 183

Positionierung-Flag 681wahlfrei 681

Postfix-Notation 107-Operator überladen

460Potenz 214, 943Potenzdarstellung

von Ganzzahlen 962

Potenzreihe 942pow() 62, 65, 214, 943, 951Prädikat 913Präfix

-Notation 107-Operator überladen

460Präprozessor 31, 965

-Direktiven 33Fehlermeldung 970

precision 86Primärdatei 693Primzahl 363Prinzip

FIFO- 803LIFO- 201, 803

Prioritätarithmetischer Operato-

ren 107Warteschlange 805

priority_queue 805private 271

Vererbung 541, 629Problem

Producer-Consumer 893

Reader-Writer 899Producer-Consumer

Problem 893Programm

Anwendungs- 269beenden 417-Code 203-Generator 969-Struktur 33-Umgebung 399

programmglobal 223Programmierung

modulare 29, 273objektorientierte 27, 269prozedurale 27

Projekt 195, 212, 273Software- 147

promotionintegral 163

PROMPT 398protected 553

-Vererbung 541, 629Prototyp 33, 63

-Funktions- 197Prozess

aufrufender 417

PSEUDO 365public 271

interface 271Vererbung 629

Puffer 355Punkt 73Punktoperator 277push() 811push_back() 810push_front() 810put() 97

Qqsort() 729, 738quadratisch

Gleichung 260Quadratwurzel 943Quellcode 29Quelldatei 29, 195, 273

Layout 33Queue 803, 804

double ended 805queue 70Quick-Sort 729

Rrand() 67Random Access 679Random-Access

Iterator 807Random-Access-Iterator

917range_error 660Range-For-Schleife 827Rastergrafik 787Raw Modus 414rdstate() 685read() 419Reader-Writer

Problem 899Read-Only 247

-Methode 303-Referenz 251-Zeiger 389

real() 941Realteil 937Rechenregeln 105rechtsbündig 89record 281recursive_mutex 891Redefinition



1014

virtueller Methoden 587von Datenelementen

547von Elementen 543von Methoden 547

Referenz 247als Parameter 249als Return-Wert 251, 313auf abstrakte Klassen

611auf Konstante 247auf R-Wert 523Read-Only- 247, 251-Typ 249

Referenztypbei Operatoren 253

Referenzzähler 857Register 229Reihenfolge

von Destruktor-Aufru-fen 589

von Konstruktor-Aufru-fen 327, 549, 635

rein virtuell 607Reinitialisierung 121Rekonstruktion

von Objekten 421rekursiv

Datenstruktur 495Funktion 209

release() 853remove() 927replace() 185, 927reset() 789, 853resize() 815, 945Return

-Taste 73return() 31, 199Return-Typ

-Ableitung 211nachgestellter 211

Return-Wert 63, 199, 313Objekt als 313

reverse() 385, 819Reverse-Iterator 919rfind() 185right 88Ring-Shift 951Rot-Schwarz-Baum 821Router 835Routing

Verfahren 835RTTI 592Rücksprungadresse 203Run-Time-Type-Informati-

on 592R-Wert 257

bewegen 523Referenz auf 523

SSchachteln

von Ausnahmebehand-lungen 657

Schalter 45Schaltjahr 316Schleife 119

do-while- 125Endlos- 123Kopf 121Range-For 827schachteln 125Zähler 121

Schlüssel/Objekt-Paar 825bei Hash-Dateien 698eingebetteter 821

Schlüsselwort 51const 55volatile 55

SchnittstelleFunktions- 197öffentliche 271, 543, 555polymorphe 611public- 543, 555von Klassen 301

Schreibenblockweises 419in eine Datei 409

Schreibschutzfür Parameter 389

Schreibweiseexponentielle 47

Schrittweite 953scientific 86search() 923second 825seekg() 681seekp() 681Seiteneffekt 109, 147Selbstaufruf

von Funktionen 209

Selection-Sort-Algorithmus 397, 723

Semikolon 31sequences 803sequenziell

Container 803Dateizugriff 409

Server 897Set 803

Einfügen 823Löschen 823ungeordnetes 831vereinbaren 823

set 70, 820, 831set() 789setf() 82setfill() 88setjmp.h 70setprecision() 86setw() 88, 355Setzen

von Bits 755shared_ptr 850, 857Shell 417Shift

arithmetischer 753Links- 753logischer 753-Operator 753-Operator überladen

459Rechts- 753

shift() 951short 41showpoint 86showpos 84Sieb

Eratosthenes- 363sign

extend 165signal.h 70Signatur

virtueller Methoden 587von Funktionen 207von Konstruktoren 291

sin() 62, 943sinh() 943size() 177, 815, 945, 957sizeof 43sizeof() 283Skalar 941, 947



1015

sleep() 340, 885slot 681, 698Smart Pointer 847

vergleichen 855Software

-Komponenten 195-Projekt 147

Sondertasten 154Sonderzeichen 49sort() 819, 931sort_heap() 933Sortieren

Algorithmen-Biblio-thek 931

von Listen 819Sortierverfahren

Bubble-Sort 363Quick-Sort 729, 739Selection-Sort- 397, 723

Speicherdynamisch reservieren

485freigeben 487

Speicherklasseextern 225register 229static 227von Funktionen 231von Variablen 223

Speicherleck 848Speichermodell 805Speicherplatz 53

für Datenlemente 273Speicherreservierung

dynamische 485Speicherzugriff

konkurrierend 881Spezifikation

Exception 657Spezifizierer 225, 586splice() 497Sprung 135Sprungtabelle 729sqrt() 62, 75, 943, 951srand() 67sstream 70Stack 201, 209, 803, 881

-Unwinding 655stack 70, 804Standard

Allokator-Klasse 805-Ausgabe 81

-Ein-/Ausgabe 153-Eingabe 81-Fehlerklassen siehe

Fehlerklasse-Funktion, Prototyp 63-Header-Datei 63, 71-Klassen 73-Konvertierung 475-Kopierkonstruktor 517-Makros 151, 971-Methoden 519-Namensbereich 233-Streams 81-Zuweisung 519, 613

Standard-Streams 81

Standardbibliothek 29, 195Standardfunktion

bsearch() 973mathematische 62qsort() 729, 738, 973terminate() 653

StandardklasseSiehe auch KlasseContainer 801File-Stream 411string 177stringstream 316

Standardmethoden 305Standardwert 293Stapel 201start() 957static 227, 231, 335static_cast<_> 577statisch 223

Bindung 591Datenelement 333Elementfunktion 335

StatusDatei- 685-Flag 415Flag von Dateien 685-Wort 685

std 31, 71, 233stdarg.h 70, 725stddef.h 70stdexcept 70stdio.h 70stdlib.h 70Steuerung

peripherer Geräte 145

Steuerzeichen 49, 761ausblenden 155Bildschirm 979

StrategieÜberlauf- 698

strcat() 391strcmp() 355strcpy() 355, 386, 391Stream 31, 79

-Klassen 81Standard- 81

streambuf 70Stream-Iterator 917stride() 957String 45, 73

anhängen 179Ausgabe 91einfügen 183Elementzugriff 187-Ende-Zeichen 355ersetzen 185Konstante 47-Länge 177leerer 47, 177löschen 183manipulieren 183suchen 185Teil- 185vergleichen 181Verkettung 179zuweisen 177

string 70Header-Datei 177Standardklasse 177

string.h 70Stringende-Zeichen 47stringizing token 965stringstream 316strlen() 355, 385Stroustrup

Bjarne 25strstr() 391struct 281Struktogramm 126, 128Struktur

rekursiv 209tm 285von C++-Programmen

33Subtraktion

von Zeigern 381, 383



1016

Suchebinäre 697, 812, 933in Bereichen 921in Maps 825in Strings 185

sum() 951swap() 259, 311swapping 485switch

-Anweisung 133Symbol 149symbolisch

Konstante 143Symmetrie

von Argumenten 311sync() 92Syntaxfehler 29Systemzeit 285

TTabelle

ASCII-Code 977Hash- 803, 829virtuelle Methoden- 591Vorrang- 976

Tabulatorbreite 49Tabulatorzeichen 49tan() 62, 943tanh() 943Tasten

Sonder- 154Teil

-String 185Teilmatrix 955Teilobjekt 275, 327

initialisieren 329konstantes 331

Teilvektor 953tellg() 681tellp() 681TEMP 398Template 770

Container- 805terminate() 653Test

Performance- 739Text

Ersatz- 143Textdatei 414Textmodus 414Textzeile

einlesen 97

this 309this_thread 885Thread 881

-ID 889initialisieren 883

throw 651Tilde 297time() 136, 189, 285time.h 70time_t 285tm 284Token 33

Past- 966stringizing 965

tolower() 151top() 813Top-Down-Prinzip 195transform() 925Transponierte 959Treiber

Bildschirm 979Treppe

zeichnen 789true 39, 111trunc 414try 653Typ Siehe Datentyp 43

arithmetischer 42einer Funktion 63eines Ausdrucks 105enum 337-Feld 585Funktion 197ganzzahliger 43-Information zur Lauf-

zeit 592maschinenabhängiger

733Parameter 197void 67, 199von Zeigern 255

Typanpassungimplizite 163übliche arithmetische

751type_traits 70typedef 733typeinfo 70typenlos 379Typname

Definition 733

Typumwandlungarithmetische 163ausschließen 477bei Funktionsaufrufen

571bei Zuweisungen 167,

573explizite 169für Klassen 473implizite in Basisklassen

571in Klassenhierarchien

571Standard- 475Verfahren 165von Referenzen 575von Zeigern 575

UÜberladung

von Funktionen 207Überlauf

-Strategie 698Übersetzungeinheit 223Umgebung

eines Programms 399Umgebungsvariable 967Umlenken

von Ein-/Ausgabe 153Umwandlung

von Datentypen 163underflow_error 660UND-Operator 113, 751union 283unique( 857unique_ptr 850UNIX 153unlock() 887unsetf() 82Unterprogrammsprung 203Unwinding

Stack- 655Up-Cast 577uppercase 84use_count() 857User Network Interface 759using 71

Deklaration 235-Direktive 31, 235

utility 70



1017

Vva_end() 727va_list 725va_start() 725valarray 70, 945value

high- 172Variable 53

extern 225global 53Klassen- 333lokal 53lokale 201PATH- 153register- 229Zeiger- 255

vector 70, 804, 805Vektor 351

Adresse 379als Argument 385als Datenelement 361assoziativer 457char- 355Container 805-Element 351globaler 353Länge 351lokaler 353mehrdimensionaler 359-Name 351numerischer 945statischer 353von Zeigern 393, 723Zuweisung 353

Vereinbarungvon Variablen 53

Vererbung 25Art 541-Diagramm 631, 635Konzept 539Mehrfach- 629

VerfahrenRouting- 835Sortier- 363, 723

Vergleich 39, 111-Funktion 738lexikografischer 181von Schlüsseln 821von Strings 181von Zeigern 383

Vergleichsoperator 111, 181

Verkettungvon Strings 179

Verschachtelnvon Schleifen 125von Verzweigungen 127

Verschachtelungstiefevon Schleifen 125

Verschiebungvon Bits 753

Verschlüsselungvon Daten 761

Versioneiner Klasse 269Index- 387von Funktionen 205von Klassen 301von Methoden 551, 587Zeiger- 387

VerweisOperator 257

virtual 587Basisklasse 633

Virtual Method Table 591virtuell

Methode 585Visual Studio 980

Community 980Express 980

VMT 591void 43, 67, 199void * 379volatile 55Vorrang 105, 442

arithmetischer Operato-ren 107

Auswahloperator 131boolescher Operatoren

113von Bitoperatoren 751

Vorrangtabelle 107für Operatoren 976

Vorzeichen 41, 962, 964-Bit 165, 962-Erweiterung 165-Operator 107

WWährung

europäische 447wahlfrei

Dateizugriff 409, 679Wahrheitswert 39

wait() 895Warnung 29Warteschlange

mit Prioritäten 805Warteschlangen 803wchar.h 70wchar_t 39wctype.h 70weak_ptr 850, 862Wegefindung 835Wert

Absolut- 131, 963boolescher 39eines Ausdrucks 105L- 257R- 257

Wertebereich 964what() 661while

Schleife 119width() 88, 355Wiederholung 135Wiederverwendbarkeit 27,

539von Klassen 273

Wiederverwendung 195WinNT 153Wort 93

Status- 685write() 419Wurzel

komplexe 937

ZZähler

Schleifen- 121Zahl

Darstellung 962Fibonacci- 353komplexe 937negative 85, 964PI 143positive 962Prim- 363

Zahlensystem 85Zeichen

Begrenzungs- 97Behandlung von 151Steuer- 761, 979Stringende 47Zugriff 187Zwischenraum- 93



1018

ZeichencodeAusgabe 91

Zeichenkette 45, 177Zeichenkonstante 47Zeichensatz 39Zeiger 255

als Parameter 259als Return-Wert 313, 391-Arithmetik 381, 383auf abstrakte Klassen

611auf const-Objekt 389auf Funktionen 729auf Objekte 279auf Zeiger 723get-/put- 679konstanter 255, 309NULL- 487Null- 256Read-Only- 389this 309typenloser 379und Vektoren 379-Vektor 393, 723vergleichen 383

-Version von Funktio-nen 387

ZeigervariableDefinition 255

Zeilennummer 153, 969Zeit 285zero

extend 165Zerstören

von Objekten 297Ziffer

hexadezimale 85Zufallszahl 67Zufallszahlengenerator 67,

136Zugriff

auf Basisklasse 547auf Container 813auf Daten 269auf private-Elemente

277Element- 545fehlerhafter 301-Methoden 301wahlfreier Datei- 679

Zugriffsrechtebei Vererbung 541

Zusammenfassung 107Zuweisung 442

einfache 109implizite Typumwand-

lung 167Move- 525Standard- 519Typumwandlung 573überladen 519virtuelle 613von Objekten 277, 305von Strings 177zusammengesetzte 109,

757Zuweisungsoperator 109Zweier-Komplement 165,

963Zweier-Potenz 753Zweig

else- 127Zwischenraumzeichen 93


Documents

C++ – Lernen und professionell anwenden - mitp.de · ten Programmiersprache C++. Außerdem werden die Schritte vorgestellt, die zur Erstellung eines lauffähigen C++-Programms erforderlich