C++ von A bis Z - s3-eu-west-1.amazonaws.com · Jürgen Wolf C++ von A bis Z Das umfassende...

Jürgen Wolf

C++ von A bis ZDas umfassende Handbuch

1429.book Seite 1 Dienstag, 5. Mai 2009 4:08 16

Auf einen Blick

1 Grundlagen in C++ ...................................................................... 25

2 Höhere und fortgeschrittene Datentypen .............................. 133

3 Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen ..................................................................... 225

4 Objektorientierte Programmierung ......................................... 265

5 Templates und STL ..................................................................... 477

6 Exception-Handling ................................................................... 661

7 C++-Standardbibliothek ............................................................ 695

8 Weiteres zum C++-Guru ............................................................ 821

9 Netzwerkprogrammierung und Cross-Plattform-Entwicklung in C++ ...................................... 917

10 GUI- und Multimediaprogrammierung in C++ ...................... 993

A Anhang ......................................................................................... 1207


5

Inhalt

Vorwort ..................................................................................................... 17Vorwort des Fachgutachters ...................................................................... 23

1 Grundlagen in C++ ................................................................ 25

1.1 Die Entstehung von C++ .......................................................... 251.1.1 Aufbau von C++ .......................................................... 28

1.2 Erste Schritte der C++-Programmierung ................................... 311.2.1 Ein Programm erzeugen mit einem

Kommandozeilen-Compiler ......................................... 321.2.2 Ausführen des Programms ........................................... 341.2.3 Ein Programm erzeugen mit einer IDE ......................... 34

1.3 Symbole von C++ .................................................................... 351.3.1 Bezeichner .................................................................. 351.3.2 Schlüsselwörter ........................................................... 351.3.3 Literale ....................................................................... 361.3.4 Einfache Begrenzer ...................................................... 37

1.4 Basisdatentypen ...................................................................... 391.4.1 Deklaration und Definition .......................................... 391.4.2 Was ist eine Variable? ................................................. 401.4.3 Der Datentyp »bool« ................................................... 401.4.4 Der Datentyp »char« ................................................... 411.4.5 Die Datentypen »int« .................................................. 441.4.6 Gleitkommazahlen »float«, »double« und

»long double« ............................................................. 461.4.7 Limits für Ganzzahl- und Gleitpunkt-Datentypen ......... 501.4.8 Die Größen der Basistypen .......................................... 511.4.9 void ............................................................................ 52

1.5 Konstanten .............................................................................. 531.6 Standard Ein-/Ausgabe-Streams ............................................... 54

1.6.1 Die neuen Streams – »cout«, »cin«, »cerr«, »clog« ........ 541.6.2 Ausgabe mit »cout« ..................................................... 561.6.3 Ausgabe mit »cerr« ...................................................... 561.6.4 Eingabe mit »cin« ........................................................ 57

1.7 Operatoren .............................................................................. 591.7.1 Arithmetische Operatoren ........................................... 601.7.2 Inkrement- und Dekrementoperator ........................... 631.7.3 Bit-Operatoren ........................................................... 641.7.4 Weitere Operatoren .................................................... 68


Inhalt

6

1.8 Kommentare ........................................................................... 681.9 Kontrollstrukturen ................................................................... 69

1.9.1 Verzweigungen (Selektionen) ...................................... 691.9.2 Schleifen (Iterationen) ................................................. 881.9.3 Sprunganweisungen .................................................... 96

1.10 Funktionen .............................................................................. 991.10.1 Deklaration und Definition .......................................... 991.10.2 Funktionsaufruf und Parameterübergabe ..................... 1021.10.3 Lokale und globale Variablen ...................................... 1091.10.4 Standardparameter ..................................................... 1101.10.5 Funktionen überladen ................................................. 1131.10.6 Inline-Funktionen ....................................................... 1171.10.7 Rekursionen ................................................................ 1201.10.8 Die »main«-Funktion ................................................... 121

1.11 Präprozessor-Direktiven ........................................................... 1221.11.1 Die »#define«-Direktive .............................................. 1231.11.2 Die »#undef«-Direktive ............................................... 1261.11.3 Die »#include«-Direktive ............................................. 1271.11.4 Die Direktiven »#error« und »#pragma« ...................... 1281.11.5 Bedingte Kompilierung ............................................... 129

2 Höhere und fortgeschrittene Datentypen ............................ 133

2.1 Zeiger ...................................................................................... 1332.1.1 Zeiger deklarieren ....................................................... 1342.1.2 Adresse im Zeiger speichern ........................................ 1352.1.3 Zeiger dereferenzieren ................................................ 1372.1.4 Zeiger, die auf andere Zeiger verweisen ....................... 1412.1.5 Dynamisch Speicherobjekte anlegen und zerstören –

»new« und »delete« .................................................... 1432.1.6 void-Zeiger ................................................................. 1482.1.7 Konstante Zeiger ......................................................... 148

2.2 Referenzen .............................................................................. 1492.3 Arrays ...................................................................................... 152

2.3.1 Arrays deklarieren ....................................................... 1522.3.2 Arrays initialisieren ...................................................... 1532.3.3 Bereichsüberschreitung von Arrays .............................. 1552.3.4 Anzahl der Elemente eines Arrays ermitteln ................ 1562.3.5 Array-Wert von Tastatur einlesen ................................ 1572.3.6 Mehrdimensionale Arrays ............................................ 157

2.4 Zeichenketten (C-Strings) – char-Array ..................................... 1592.4.1 C-String deklarieren und initialisieren .......................... 160


Inhalt

7

2.4.2 C-String einlesen ......................................................... 1612.4.3 C-Strings: Bibliotheksfunktionen ................................. 161

2.5 Arrays und Zeiger .................................................................... 1662.5.1 C-Strings und Zeiger .................................................... 1712.5.2 Mehrfache Indirektion ................................................ 1712.5.3 C-String-Tabellen ........................................................ 1732.5.4 Arrays im Heap (dynamisches Array) ........................... 176

2.6 Parameterübergabe mit Zeigern, Arrays und Referenzen .......... 1812.6.1 Call by value ............................................................... 1812.6.2 Call by reference – Zeiger als Funktionsparameter ....... 1822.6.3 Call by reference mit Referenzen nachbilden ............... 1842.6.4 Arrays als Funktionsparameter .................................... 1852.6.5 Mehrdimensionale Arrays an Funktionen übergeben ... 1872.6.6 Argumente an die main-Funktion übergeben .............. 188

2.7 Rückgabewerte von Zeigern, Arrays und Referenzen ................ 1902.7.1 Zeiger als Rückgabewert ............................................. 1902.7.2 Referenz als Rückgabewert .......................................... 1942.7.3 const-Zeiger als Rückgabewert .................................... 1952.7.4 Array als Rückgabewert ............................................... 1952.7.5 Mehrere Rückgabewerte ............................................. 196

2.8 Fortgeschrittene Typen ............................................................ 1972.8.1 Strukturen ................................................................... 1982.8.2 Unions ........................................................................ 2182.8.3 Aufzählungstypen ....................................................... 2212.8.4 typedef ....................................................................... 223

3 Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen ............................................................... 225

3.1 Gültigkeitsbereiche (Scope) ..................................................... 2253.1.1 Lokaler Gültigkeitsbereich (Local Scope) ..................... 2263.1.2 Gültigkeitsbereich Funktionen ..................................... 2263.1.3 Gültigkeitsbereich Namensraum (Namespaces) ........... 2283.1.4 Gültigkeitsbereich Klassen (Class Scope) ...................... 228

3.2 Namensräume (Namespaces) ................................................... 2283.2.1 Neuen Namensbereich erzeugen (Definition) .............. 2283.2.2 Zugriff auf die Bezeichner im Namensraum ................. 2313.2.3 using – einzelne Bezeichner aus einem Namensraum

importieren ................................................................. 2333.2.4 using – alle Bezeichner aus einem Namensraum

importieren ................................................................. 2363.2.5 Namensauflösung ....................................................... 239


Inhalt

8

3.2.6 Alias-Namen für Namensbereiche ............................... 2403.2.7 Anonyme (namenlose) Namensbereiche ...................... 2413.2.8 Namensbereich und Header-Dateien ........................... 242

3.3 C-Funktionen bzw. -Bibliotheken in einem C++-Programm ...... 2443.3.1 C-Funktionen aus einer C-Bibliothek aufrufen ............. 245

3.4 Speicherklassenattribute .......................................................... 2493.4.1 Speicherklasse »auto« .................................................. 2503.4.2 Speicherklasse »register« ............................................. 2503.4.3 Speicherklasse »static« ................................................ 2503.4.4 Speicherklasse »extern« ............................................... 2513.4.5 Speicherklasse »mutable« ............................................ 253

3.5 Typqualifikatoren ..................................................................... 2533.5.1 Qualifizierer »const« .................................................... 2543.5.2 Qualifizierer »volatile« ................................................. 254

3.6 Funktionsattribute ................................................................... 2553.7 Typumwandlung ...................................................................... 255

3.7.1 Standard-Typumwandlung .......................................... 2563.7.2 Explizite Typumwandlung ........................................... 260

4 Objektorientierte Programmierung ..................................... 265

4.1 OOP-Konzept versus prozedurales Konzept ............................. 2654.1.1 OOP-Paradigmen ........................................................ 266

4.2 Klassen (fortgeschrittene Typen) .............................................. 2674.2.1 Klassen deklarieren ..................................................... 2684.2.2 Elementfunktion (Klassenmethode) definieren ............ 2694.2.3 Objekte deklarieren .................................................... 2714.2.4 Kurze Zusammenfassung ............................................. 2714.2.5 »private« und »public« – Zugriffsrechte in der Klasse ... 2724.2.6 Zugriff auf die Elemente (Member) einer Klasse .......... 2744.2.7 Ein Programm organisieren ......................................... 2814.2.8 Konstruktoren ............................................................. 2854.2.9 Destruktoren ............................................................... 293

4.3 Mehr zu den Klassenmethoden (Klassenfunktionen) ................ 2954.3.1 Inline-Methoden (explizit und implizit) ....................... 2964.3.2 Zugriffsmethoden ........................................................ 2994.3.3 Read-only-Methoden .................................................. 3034.3.4 this-Zeiger .................................................................. 305

4.4 Verwenden von Objekten ........................................................ 3074.4.1 Read-only-Objekte ...................................................... 3074.4.2 Objekte als Funktionsargumente ................................. 3074.4.3 Objekte als Rückgabewert ........................................... 314


Inhalt

9

4.4.4 Klassen-Array (Array von Objekten) ............................ 3164.4.5 Dynamische Objekte ................................................... 3184.4.6 Dynamische Klassenelemente ..................................... 3244.4.7 Objekte kopieren (Kopierkonstruktor) ......................... 3284.4.8 Dynamisch erzeugte Objekte kopieren

(»operator=()«) ............................................................ 3304.4.9 Standardmethoden (Überblick) ................................... 3314.4.10 Objekte als Elemente (bzw. Eigenschaften) in anderen

Klassen ....................................................................... 3324.4.11 Teilobjekte initialisieren .............................................. 3384.4.12 Klassen in Klassen verschachteln ................................. 3404.4.13 Konstante Klasseneigenschaften (Datenelemente) ....... 3414.4.14 Statische Klasseneigenschaften (Datenelemente) ......... 3434.4.15 Statische Klassenmethoden ......................................... 3484.4.16 Friend-Funktionen bzw. friend-Klassen ....................... 3494.4.17 Zeiger auf Eigenschaften einer Klasse .......................... 352

4.5 Operatoren überladen ............................................................. 3584.5.1 Grundlegendes zur Operator-Überladung .................... 3584.5.2 Überladen von arithmetischen Operatoren .................. 3624.5.3 Überladen von unären Operatoren .............................. 3714.5.4 Überladen von ++ und -- ............................................. 3744.5.5 Überladen des Zuweisungsoperators ........................... 3764.5.6 Überladen des Indexoperators »[ ]«

(Arrays überladen) ....................................................... 3784.5.7 Shift-Operatoren überladen ........................................ 3814.5.8 ( )-Operator überladen ................................................ 385

4.6 Typumwandlung für Klassen .................................................... 3884.6.1 Konvertierungskonstruktor .......................................... 3884.6.2 Konvertierungsfunktion ............................................... 390

4.7 Vererbung (abgeleitete Klassen) ............................................... 3924.7.1 Anwendungsbeispiel (Vorbereitung) ........................... 3944.7.2 Die Ableitung einer Klasse .......................................... 3974.7.3 Redefinition von Klassenelementen ............................. 4014.7.4 Konstruktoren ............................................................. 4044.7.5 Destruktoren ............................................................... 4074.7.6 Zugriffsrecht »protected« ............................................. 4074.7.7 Typumwandlung abgeleiteter Klassen ......................... 4104.7.8 Klassenbibliotheken erweitern .................................... 413

4.8 Polymorphismus ...................................................................... 4144.8.1 Statische bzw. dynamische Bindung ............................ 4154.8.2 Virtuelle Methoden ..................................................... 415


Inhalt

10

4.8.3 Virtuelle Methoden redefinieren ................................. 4204.8.4 Arbeitsweise virtueller Methoden ............................... 4264.8.5 Virtuelle Destruktoren bzw. Destruktoren

abgeleiteter Klassen .................................................... 4314.8.6 Polymorphismus und der Zuweisungsoperator ............ 4334.8.7 Rein virtuelle Methoden und abstrakte Basisklassen .... 4354.8.8 Probleme mit der Vererbung und der

dynamic_cast-Operator ............................................... 4394.8.9 Fallbeispiel: Verkettete Listen ..................................... 441

4.9 Mehrfachvererbung ................................................................. 4634.9.1 Indirekte Basisklassen erben ........................................ 4674.9.2 Virtuelle indirekte Basisklassen erben .......................... 471

5 Templates und STL ............................................................... 477

5.1 Funktions-Templates ............................................................... 4775.1.1 Funktions-Templates definieren .................................. 4795.1.2 Typübereinstimmung .................................................. 4825.1.3 Funktions-Templates über mehrere Module ................ 4835.1.4 Spezialisierung von Funktions-Templates .................... 4835.1.5 Verschiedene Parameter ............................................. 4875.1.6 Explizite Template-Argumente .................................... 488

5.2 Klassen-Templates ................................................................... 4895.2.1 Definition ................................................................... 4905.2.2 Methoden von Klassen-Templates definieren .............. 4915.2.3 Klassen-Template generieren (Instantiierung) .............. 4965.2.4 Weitere Template-Parameter ...................................... 5015.2.5 Standardargumente von Templates ............................. 5045.2.6 Explizite Instantiierung ................................................ 506

5.3 STL (Standard Template Library) .............................................. 5075.3.1 Konzept von STL ......................................................... 5085.3.2 Hilfsmittel (Hilfsstrukturen) ......................................... 5125.3.3 Allokator ..................................................................... 5245.3.4 Iteratoren .................................................................... 5255.3.5 Container .................................................................... 5305.3.6 Algorithmen ................................................................ 5815.3.7 Allokatoren ................................................................. 643

6 Exception-Handling ............................................................. 661

6.1 Exception-Handling in C++ ...................................................... 6626.2 Eine Exception auslösen ........................................................... 662


Inhalt

11

6.3 Eine Exception auffangen – Handle einrichten .......................... 6636.3.1 Reihenfolge (Auflösung) der Ausnahmen ..................... 6666.3.2 Alternatives »catch(...)« ............................................... 6666.3.3 Stack-Abwicklung (Stack-Unwinding) .......................... 6686.3.4 try-Blöcke verschachteln ............................................. 6706.3.5 Exception weitergeben ................................................ 673

6.4 Ausnahmeklassen (Fehlerklassen) ............................................. 6766.4.1 Klassenspezifische Exceptions ..................................... 678

6.5 Standard-Exceptions ................................................................ 6806.5.1 Virtuelle Methode »what()« ........................................ 6816.5.2 Anwenden der Standard-Exceptions ............................ 681

6.6 System-Exceptions ................................................................... 6866.6.1 bad_alloc .................................................................... 6876.6.2 bad_cast ..................................................................... 6876.6.3 bad_typeid .................................................................. 6876.6.4 bad_exception ............................................................ 687

6.7 Exception-Spezifikation ........................................................... 6886.7.1 Unerlaubte Exceptions ................................................ 6896.7.2 terminate-Handle einrichten ....................................... 691

7 C++-Standardbibliothek ....................................................... 695

7.1 Die String-Bibliothek (string-Klasse) ......................................... 6957.1.1 Exception-Handling ..................................................... 6977.1.2 Datentypen ................................................................. 6977.1.3 Strings erzeugen (Konstruktoren) ................................ 6987.1.4 Zuweisungen ............................................................... 7007.1.5 Elementzugriff ............................................................. 7027.1.6 Länge und Kapazität ermitteln bzw. ändern ................ 7037.1.7 Konvertieren in einen C-String .................................... 7067.1.8 Manipulation von Strings ............................................ 7077.1.9 Suchen in Strings ........................................................ 7107.1.10 Strings vergleichen ...................................................... 7177.1.11 Die (überladenen) Operatoren .................................... 7197.1.12 Einlesen einer ganzen Zeile ......................................... 721

7.2 Ein-/Ausgabe Klassenhierarchie (I/O-Streams) ......................... 7227.2.1 Klassen für Ein- und Ausgabe-Streams ......................... 7247.2.2 Klassen für Datei-Streams (File-Streams) ..................... 7487.2.3 Klassen für String-Streams ........................................... 7637.2.4 Die Klasse »streambuf« ............................................... 7707.2.5 Die Klasse »filebuf« ..................................................... 7747.2.6 Die Klasse »stringbuf« ................................................. 775


Inhalt

12

7.3 Numerische Bibliothek(en) ....................................................... 7767.3.1 Komplexe Zahlen (»complex«-Klasse) .......................... 7767.3.2 valarray ....................................................................... 7797.3.3 Globale numerische Funktionen (»cmath« und

»cstdlib«) .................................................................... 8027.3.4 Grenzwerte von Zahlentypen ...................................... 8067.3.5 Halbnumerische Algorithmen ...................................... 811

7.4 Typerkennung zur Laufzeit ....................................................... 814

8 Weiteres zum C++-Guru ...................................................... 821

8.1 Module ................................................................................... 8218.1.1 Aufteilung ................................................................... 8228.1.2 Die öffentliche Schnittstelle (Header-Datei) ................. 8238.1.3 Die private Datei ......................................................... 8248.1.4 Die Client-Datei .......................................................... 8268.1.5 Speicherklassen »extern« und »static« .......................... 8278.1.6 Werkzeuge .................................................................. 829

8.2 Von C zu C++ .......................................................................... 8308.2.1 Notizen ....................................................................... 8318.2.2 Kein C++ ..................................................................... 8318.2.3 Kein C ......................................................................... 8338.2.4 »malloc« und »free« oder« new« und »delete« ............. 8348.2.5 »setjmp« und »longjmp« oder »catch« und »throw« ..... 835

8.3 »Altes« C++ ............................................................................. 8358.3.1 Header-Dateien mit und ohne Endung ........................ 8358.3.2 Standardbibliothek nicht komplett oder veraltet ......... 8368.3.3 Namespaces (Namensbereiche) ................................... 8368.3.4 Schleifenvariable von »for« .......................................... 836

8.4 UML ........................................................................................ 8378.4.1 Wozu UML? ................................................................ 8378.4.2 UML-Komponenten .................................................... 8398.4.3 Diagramme erstellen ................................................... 8408.4.4 Klassendiagramme mit UML ........................................ 840

8.5 Programmierstil ....................................................................... 8818.5.1 Kommentare ............................................................... 8818.5.2 Code ........................................................................... 8838.5.3 Benennung ................................................................. 8848.5.4 Codeformatierung ....................................................... 8848.5.5 Zusammenfassung ....................................................... 885

8.6 Entwicklungsstufen von Software ............................................ 8868.6.1 Auftrag bzw. Idee ....................................................... 887


Inhalt

13

8.6.2 Spezifikation und Anforderung .................................... 8888.6.3 Entwurf (Design) ......................................................... 8898.6.4 Programmieren (Codieren) .......................................... 8908.6.5 Testen und Debuggen ................................................. 8908.6.6 Freigabe (Release) ....................................................... 8918.6.7 Wartung ..................................................................... 8918.6.8 Aktualisierung (Update) .............................................. 892

8.7 Boost ....................................................................................... 8928.7.1 Boost.Regex (reguläre Ausdrücke) ............................... 8948.7.2 Boost.Iostreams .......................................................... 9098.7.3 Boost.Filesystem ......................................................... 911

9 Netzwerkprogrammierung und Cross-Plattform-Entwicklung in C++ .............................................................. 917

9.1 Begriffe zur Netzwerktechnik ................................................... 9189.1.1 IP-Nummern ............................................................... 9189.1.2 Portnummern ............................................................. 9199.1.3 Host- und Domainname .............................................. 9209.1.4 Nameserver ................................................................. 9219.1.5 IP-Protokoll ................................................................ 9219.1.6 TCP und UDP .............................................................. 9219.1.7 Was sind Sockets? ....................................................... 922

9.2 Header-Dateien zur Socketprogrammierung ............................ 9239.2.1 Linux/UNIX ................................................................. 9239.2.2 Windows .................................................................... 923

9.3 Client-Server-Prinzip ................................................................ 9269.3.1 Loopback-Interface ..................................................... 926

9.4 Erstellen einer Client-Anwendung ............................................ 9279.4.1 »socket()« – Erzeugen eines Kommunikations-

endpunkts ................................................................... 9279.4.2 »connect()« – Client stellt Verbindung zum

Server her ................................................................... 9299.4.3 Senden und Empfangen von Daten ............................. 9349.4.4 »close()« und »closesocket()« ....................................... 937

9.5 Erstellen einer Server-Anwendung ........................................... 9379.5.1 »bind()« – Festlegen einer Adresse aus dem

Namensraum .............................................................. 9389.5.2 »listen()« – Warteschlange für eingehende

Verbindungen einrichten ............................................. 9399.5.3 »accept()« und die Server-Hauptschleife ...................... 940


Inhalt

14

9.6 Cross-Plattform-Development ................................................. 9439.6.1 Abstraction Layer ...................................................... 9439.6.2 Header-Datei (»socket.h«) ......................................... 9439.6.3 Quelldatei (»socket.cpp«) .......................................... 9459.6.4 TCP-Echo-Server (Beispiel) ........................................ 9569.6.5 Exception-Handling integrieren ................................. 9589.6.6 Server- und Client-Sockets erstellen (TCP) ................. 9649.6.7 Ein UDP-Beispiel ....................................................... 974

9.7 Mehrere Clients gleichzeitig behandeln ................................... 9769.8 Weitere Anmerkungen zur Netzwerkprogrammierung ............. 986

9.8.1 Das Datenformat ...................................................... 9869.8.2 Der Puffer ................................................................. 9879.8.3 Portabilität ................................................................ 9889.8.4 Von IPv4 nach IPv6 ................................................... 9889.8.5 RFC-Dokumente (Request for Comments) ................. 9909.8.6 Sicherheit ................................................................. 9909.8.7 Fertige Bibliotheken .................................................. 991

10 GUI- und Multimediaprogrammierung in C++ .................... 993

10.1 GUI-Programmierung – Überblick ............................................ 99310.1.1 Low-Level ................................................................. 99410.1.2 High-Level ................................................................ 99410.1.3 Überblick über plattformunabhängige Bibliotheken ... 99510.1.4 Überblick über plattformabhängige Bibliotheken ....... 997

10.2 Multimedia- und Grafikprogrammierung – Überblick ............... 99810.2.1 Überblick über plattformunabhängige Bibliotheken ... 99810.2.2 Überblick über plattformabhängige Bibliotheken ....... 1000

10.3 GUI-Programmierung mit »wxWidgets« ................................... 100110.3.1 Warum »wxWidgets«? ............................................... 100110.3.2 Das erste Programm – Hallo Welt ............................. 100210.3.3 Die grundlegende Struktur eines »wxWidgets«-

Programms ............................................................... 100510.3.4 Event-Handle (Ereignisse behandeln) ........................ 101210.3.5 Die Fenster-Grundlagen ............................................ 101910.3.6 Übersicht über die »wxWidgets«-(Fenster-)Klassen .... 102110.3.7 »wxWindow«, »wxControl« und

»wxControlWithItems« – die Basisklassen .................. 102310.3.8 Top-Level-Fenster ..................................................... 102610.3.9 Container-Fenster ..................................................... 105010.3.10 Nicht statische Kontrollelemente .............................. 107710.3.11 Statische Kontrollelemente ....................................... 1135


Inhalt

15

10.3.12 Menüs ...................................................................... 114010.3.13 Ein Beispiel – Text-Editor .......................................... 115610.3.14 Standarddialoge ........................................................ 117110.3.15 Weitere Elemente und Techniken im Überblick ......... 1195

A Anhang .............................................................................. 1207

A.1 Operatoren in C++ und deren Bedeutung (Übersicht) .............. 1207A.2 Vorrangtabelle der Operatoren ................................................ 1209A.3 Schlüsselwörter von C++ .......................................................... 1210A.4 Informationsspeicherung ......................................................... 1210

A.4.1 Zahlensysteme .......................................................... 1211A.5 Zeichensätze ............................................................................ 1218

A.5.1 ASCII-Zeichensatz ..................................................... 1219A.5.2 ASCII-Erweiterungen ................................................. 1220A.5.3 Unicode .................................................................... 1222

Index ......................................................................................................... 1225


17

Vorwort

Es ist mir eine große Freude, Ihnen die zweite Auflage dieses Buches präsentierenzu dürfen. Die vorherige Auflage war immerhin schon drei Jahre alt, so dass sieauf den neuesten Stand gebracht werden musste. Einige Kapitel wurden außer-dem ein wenig erweitert. Neben der Aktualisierung des Buches wurden auchFehler der alten Auflage behoben. An dieser Stelle möchte ich mich bei den vie-len Lesern der ersten Auflage bedanken, die mir mit Hinweisen, Fehlermeldun-gen und Vorschlägen geholfen haben, dieses Buch noch weiter zu verbessern.

Über dieses Buch

Mittlerweile gibt es eine ganze Menge von Büchern zur C++-Programmierspra-che. Dies allein zeigt schon die Popularität, die diese Sprache genießt. Natürlichhabe ich es mir nicht nehmen lassen, auch etwas vom großen Kuchen abzube-kommen. Wieso aber habe ich mir die Mühe gemacht, gut acht Monate auf dasSchreiben eines weiteren Buches über diese Sprache zu verwenden, wenn schonunzählige davon vorhanden sind? Es gibt schließlich viele hervorragende C++-Bücher für Einsteiger. Und Profis greifen gern zum vielzitierten Stroustrup (»DieC++ Programmiersprache«). Für welche Zielgruppe ist also dieses Buch gedacht,und was bietet es, was andere C++-Bücher nicht haben?

Zielgruppe

Dieses Buch richtet sich an mehrere Zielgruppen und kann auch als Nachschlage-werk verwendet werden. Es eignet sich für den absoluten Einsteiger in die Pro-grammierung genauso wie für den fortgeschrittenen Programmierer. Auch»Umsteiger« von C dürften keine Probleme haben – das Déjà-vu-Erlebnis solltesich hier in Grenzen halten (speziell auch für die Leser meines Buches »C von Abis Z«). Es ist ebenfalls nicht nötig, bereits über Kenntnisse irgendeiner anderenProgrammiersprache zu verfügen. Nach diesem Buch können Sie ohne Bedenkenauf das Stroustrup-Buch zurückgreifen und sich selbst den letzten Schliff geben.Natürlich darf man bei einem Buch zur Programmierung (gleich welcher Pro-grammiersprache) immer erwarten, dass der Leser grundlegende Kenntnisse zumArbeiten mit einem PC mitbringt.


18

Vorwort

Aber was enthält dieses Buch nun wirklich, was andere Bücher zu C++ nicht bie-ten? Eine ganze Menge: Neben dem üblichen ANSI-C++-Standard geht diesesBuch auch auf Themen wie STL, Boost, Socket- oder die GUI-Programmierungein.

C und C++

Dass C++ eine Erweiterung von C ist, bringt so manchen Buchautor zum Grübeln.Soll man jetzt ein Buch zweiteilen und somit C und C++ verwenden, oder sollman C ganz ignorieren? Zugegeben, wer reines C++ programmieren will, benö-tigt kein C. Aber C völlig außen vor zu lassen und als unnötigen Ballast zubezeichnen ist ein weiterer folgenschwerer Fehler. Wer das Glück hat und einneues, »leeres« Projekt anfangen darf, dem kann C egal sein. Aber oft hat man alsProgrammierer die undankbare Aufgabe, »alte« Programme zu pflegen bzw. zuverbessern. Und häufig sind solche Programme noch in C geschrieben. Hierbeierhält man dann meistens den Auftrag, das Programm objektorientiert und fle-xibler zu machen, d. h., man soll aus einem in C geschriebenen Programm einC++-Programm machen. Wie dem auch sei, über das Pro und Contra ließen sichnoch viele Zeilen schreiben, und eben aus diesem Grund finden Sie auf der Buch-CD als kostenlose Beigabe die HTML-Version des Buches »C von A bis Z« (2. Auf-lage).

Betriebssystem

Da dieses Buch über den gewöhnlichen Standard-C++-Umfang hinausgeht, stel-len Sie sich sicherlich die Frage, ob Sie das alles auch auf Ihrem Betriebssystembenutzen können. Hierzu ein ganz klares Ja. Alle Themen sind so gut wie platt-formunabhängig und wurden auf Linux, UNIX (BSD) und MS Windows getestet.Und wenn es trotzdem mal die ein oder andere »Ungereimtheit« gibt, wird dar-auf hingewiesen, und es werden entsprechende Alternativen demonstriert.Natürlich ist dieses Buch so aufgebaut, dass zuerst auf die in C++ standardisiertenDinge eingegangen wird.

Übersicht

In Kapitel 1, »Grundlagen in C++«, wird auf die reinen Grundlagen von C++ ein-gegangen. Diese umfassen einfache Dinge wie den Bezeichner, Basisdatentypen,Konstanten, einfache Ein-/Ausgabe, die grundlegenden Operatoren, Kommen-


19

Vorwort

tare, Kontrollstrukturen wie Verzweigungen oder Schleifen, Funktionen und Prä-prozessor-Direktiven.

Kapitel 2, »Höhere und fortgeschrittene Datentypen«, geht auf die höheren undfortgeschrittenen Datentypen wie Zeiger, Referenzen, Arrays, Zeichenketten (C-Strings) und Strukturen ein.

Kapitel 3, »Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlun-gen«, behandelt unspektakuläre, aber sehr wichtige Themen wie die Gültigkeits-bereiche, Namensräume, Speicherklassenattribute, Typqualifikatoren undTypumwandlungen.

Kapitel 4, »Objektorientierte Programmierung«, ist das wichtigste, aber auchschwierigste Kapitel in diesem Buch. Hier werden alle Themen behandelt, die dieobjektorientierte Programmierung betreffen. Das Verstehen dieses Kapitels istdie Grundlage für die weiteren Kapitel im Buch und für C++ generell. Dabei gehtes um die Klassen und wie man diese in der Praxis anwenden kann. Natürlichwird hierbei auch auf Vererbung, Polymorphismus und Mehrfachvererbung ein-gegangen.

Kapitel 5, »Templates und STL«, enthält dann die Erstellung eigener Funktions-und Klassen-Templates. Darauf basiert ja auch die STL (Standard TemplateLibrary), weshalb auch sehr umfangreich auf STL eingegangen wird.

Da in den vorangegangenen Kapiteln häufig die Rede von Exceptions (Ausnah-mebehandlungen) war, erläutert Kapitel 6, »Exception-Handling«, dieses Themasehr umfassend.

Gewöhnlich besitzt jede Sprache einen Standardumfang. So natürlich auch C++mit ihren Standardbibliotheken. Zunächst wird sehr ausführlich die String-Bib-liothek vorgestellt. Anschließend folgen die Klassen für die Ein-/Ausgabe. Dabeiwerden neben den gewöhnlichen Klassen für die Ein- bzw. Ausgabe-Streamsauch die Klassen für die Datei- und String-Streams behandelt. Auch für Mathema-tiker hält C++ mit den Klassen valarray und complex einiges bereit. Natürlichwird auch auf andere numerische Bibliotheken eingegangen. Am Ende von Kapi-tel 7, »C++-Standardbibliothek«, finden Sie zudem eine Beschreibung dazu, wieSie eine Typerkennung zur Laufzeit durchführen können.

Kapitel 8, »Weiteres zum C++-Guru«, enthält viele Informationen, über die manals C++-Programmierer verfügen sollte. Neben einfacheren Dingen – zum Bei-spiel, wie Sie eigene Module erstellen – spielen hierbei auch die feinen, aber sehrwichtigen Unterschiede zwischen C und C++ eine Rolle. Des Weiteren finden Sieeine sehr umfassende Einführung in UML und die Erstellung von Klassendia-grammen. Natürlich wird auch ein wenig der Programmierstil vorgestellt. Sehr


20

Vorwort

selten liest man etwas über Boost, weshalb in Kapitel acht mit der BibliothekBoost.Regex (für reguläre Ausdrücke) darauf eingegangen wird.

Kapitel 9, »Netzwerkprogrammierung und Cross-Plattform-Entwicklung in C++«,behandelt die Netzwerkprogrammierung. Da diese nicht mehr zu den portablenSachen gehört, wird in diesem Kapitel u. a. auf die Cross-Plattform-Entwicklungeingegangen. Hierzu werden Sie eine eigene Socket-Klasse schreiben.

Im letzten Kapitel – Kapitel 10, »GUI- und Multimediaprogrammierung in C++« –erhalten Sie zunächst einen Überblick über die gängigen GUI- und Multimedia-bibliotheken. Anschließend wird sehr umfassend das wxWidgets-Frameworkbeschrieben. Auch hierbei müssen Sie sich keine Gedanken bezüglich der Porta-bilität machen. wxWidgets gibt es auf allen gängigen Plattformen, und – nochbesser – die Quelltexte lassen sich ohne Änderungen auf den verschiedensten Sys-temen übersetzen.

In diesem Buch finden Sie an einigen Stellen grau hinterlegte Kästen, in denenSie weiterführende Informationen zu bestimmten Themen erhalten. Einige Käs-ten sind am Rand mit einem speziellen Icon gekennzeichnet. Dieses Icon stehtneben einem Hinweis-Kasten. Hier erhalten Sie z. B. Informationen zu Unter-schieden zwischen C und C++, Hinweise auf Fehlerquellen sowie kleine Tippsund Tricks, die Ihnen das (Programmierer-)Leben erleichtern.

Buch-CD

Auf der Buch-CD finden Sie sämtliche Quellcodes aus dem Buch wieder. Ebensowurden einige Anleitungen gängiger Compiler (Entwicklungsumgebungen)erstellt, die Ihnen zeigen, wie Sie aus einem Quelltext ein ausführbares Pro-gramm machen. Sofern Sie also absoluter Neuling sind, sollten Sie zuerst einenBlick auf diese Buch-CD werfen.

Damit auch MS Windows-Anwender gleich loslegen können, finden diese aufder Buch-CD die Bloodshed-Dev-C++-Entwicklungsumgebung. Als Linux- bzw.UNIX-Anwender hat man es da leichter. Hier befindet sich gleich alles an Boarddes Betriebssystems und muss nicht extra besorgt werden. Gegebenenfalls kannes sein, dass man einzelne Pakete nachinstallieren muss (abhängig von der ver-wendeten Distribution).

Neben der bereits erwähnten HTML-Version meines Buches »C von A bis Z« fin-den Sie auch noch eine weitere HTML-Version des Buches »IT-Handbuch fürFachinformatiker« von Sascha Kersken. Dieses Buch wurde ausdrücklich auf mei-nen Wunsch hin auf die Buch-CD gepresst. Der Grund dafür ist, dass viele ange-


21

Vorwort

hende Programmierer häufig die Grundlagen der Informatik einfach übersprin-gen. Solche Wissensdefizite machen sich jedoch irgendwann bemerkbar. Ichverwende außerdem selbst immer wieder gern dieses Buch für meine Recher-chen.

Danksagung

Ein Buch mit einem solchen Umfang schreibt man nicht einfach so, und häufigsteckt monatelange Arbeit darin (und vom »Autor-Sein« kann man nicht leben).Schlimmer noch muss es aber für die Menschen sein, die mit dem Autor in dieserZeit zusammenleben. Meine Frau hat wohl schon die Hoffnung aufgegeben, miteinem normalen Menschen zusammen sein zu dürfen. Auch mein Sohn (vierJahre) erkennt und protestiert sofort, wenn ich mich wieder zum PC »wegschlei-chen« will. Kurz gesagt: Beim Schreiben von Büchern geht einfach schnell mal dieHarmonie flöten. Daher ist hier mal wieder ein riesiges Dankeschön an Euchbeide nötig. Ihr seid die wichtigsten Menschen in meinem Leben.

Die wichtigste Person im fachlichen Bereich ist Martin Conrad, der stets für Fach-lesungen meiner Bücher zur Verfügung steht. Er ist auch Maintainer »meiner«Webseite, und mittlerweile brüten wir beide auch unser erstes Projekt aus.Obwohl ich Martin mittlerweile mehrere Jahre kenne, haben wir uns noch nieim realen Leben gesehen. Wer sagt da, dass virtuelle Freundschaften nicht funk-tionieren. Auch dir, lieber Martin, vielen Dank für deine tolle Unterstützung.

Bücher zu schreiben ist das eine, aber einen Verlag, der so flexibel ist und demAutor so viele Freiheiten lässt, findet man kein zweites Mal. Natürlich gibt es hierauch immer eine Person, die hinter den Kulissen steht und diesen Prozess koor-diniert. In diesem Fall ist es meine Lektorin Judith Stevens-Lemoine, die michjetzt bereits beim vierten gemeinsamen Buchprojekt unterstützt. Vielen Dank,Judith, für die tolle Zusammenarbeit.

Jürgen Wolf


23

Vorwort des Fachgutachters

C++ – nur eine Erweiterung von C?

Der Geruch eines neuen Buches erfüllt den Raum, Ihr Rechner ist hochgefahren,und Sie sitzen in den Startlöchern, um sich mit C++ zu beschäftigen? Ich hoffe,Sie haben den Kaffee nicht vergessen!

Die meisten Leser werden sich vorher mit C beschäftigt haben, werden also eherUmsteiger auf eine objektorientierte Sprache sein. Hierbei war die Auswahl, waserlernt werden soll, sicher eine schwierige Entscheidung. Wenn erfahrene Pro-grammierer gefragt werden, welche Programmiersprache empfehlenswert ist,gibt es annähernd so viele Antworten wie Personen, die befragt werden.

Falls es Einwände gegen C++ gegeben hat, wird das meist die Nähe zu C gewesensein. Es ist durchaus möglich, C++ genauso wie C als prozedurale Sprache zu ver-wenden und dabei die Bibliotheken eher als Zusatzfunktionen zu nutzen, und lei-der wird C++ auch von vielen Leuten auf diese Art genutzt.

Um wirklich gut zu wartenden objektorientierten Code zu erhalten, ist ein kom-plettes Umdenken nötig, da die Schwerpunkte und Schwierigkeiten beiderAnsätze an völlig unterschiedlichen Stellen liegen.

Bei C war es noch möglich, kleinere Programme einfach zu beginnen und siewachsen zu lassen – bei objektorientierten Sprachen führt diese Vorgehensweiseschnell zu einem Neuschreiben des gesamten Codes, wenn der Code nicht proze-dural sein soll, was ja Sinn der Sache ist. Es ist bei der Planung notwendig, denobjektorientierten Ansatz zu verstehen und die Möglichkeiten zu kennen, dieC++ bietet. Fehlendes Wissen kann hier zu ärgerlichen groben Designfehlern undviel überflüssiger Arbeit führen.

Namensräume, Klassen, Templates, die STL ... – es ist gut, dies alles zu kennenund in die Planung der Programme einzubeziehen.

Aus diesen Gründen möchte ich Ihnen nahelegen, Ihr neues Buch möglichstkomplett durchzuarbeiten und zu vermeiden, mit Anfangswissen Projekte zustarten.

Ich wünsche Ihnen viel Spaß mit Ihrem neuen Buch und der Welt der objektori-entierten Programmierung!

Martin Conrad


225

Dieses Kapitel behandelt Themen, die zwar recht trocken und sehr theo-retisch, für die Praxis aber unverzichtbar sind. In den ersten beiden Kapiteln haben Sie viel über verschiedene Datentypen (Basistypen, Zei-ger, Referenzen, strukturierte Typen etc.) und Funktionen erfahren. In diesem Zusammenhang wurden aber noch einige wichtige Aspekte ver-nachlässigt, und zwar die Gültigkeitsbereiche, die Namensräume und die Sichtbarkeit. Auch die Deklarationen wurden nur recht einfach erklärt. Hierbei gibt es aber noch besondere Speicherklassenattribute, Typqualifikatoren und Funktionsattribute. Und dann fehlen auch noch die Typumwandlungen, bei denen man zwischen einer Standard-Umwandlung und einer expliziten Umwandlung unterscheidet.

3 Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen

3.1 Gültigkeitsbereiche (Scope)

Zunächst sollte man nicht den Fehler machen, den Begriff Gültigkeitsbereich mitdem Begriff Sichtbarkeit gleichzusetzen. Ein Speicherobjekt ist sichtbar, wennman innerhalb eines Bereichs darauf zugreifen kann. Damit ein solches Objektsichtbar ist, muss es gültig sein. Sie können zum Beispiel ein Objekt »ungültig«machen, indem Sie es mit einem Objekt mit gleichem Namen überdecken:

// cu.cpp#include <iostream>using namespace std;

int main(void) {// iwert ist hier "sichtbar"int iwert = 100;{

// iwert überdeckt das äußere iwertint iwert = 200;cout << iwert << '\n';

} // hier ist inneres iwert nicht mehr gültig// und somit ist äußeres iwert wieder sichtbar


226

Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen3

cout << iwert << '\n';return 0;

}

Das Programm bei der Ausführung:

200100

Jetzt aber zum eigentlichen Thema, den Gültigkeitsbereichen in C++. Der Gültig-keitsbereich ist ein Abschnitt im Quellcode, in dem ein deklarierter Bezeichnerverwendet werden kann. Häufig wird auch von einem Scope (= Gültigkeitsbe-reich des Bezeichners) gesprochen.

3.1.1 Lokaler Gültigkeitsbereich (Local Scope)

Wenn Sie einen Anweisungsblock verwenden, haben Sie automatisch einen lokalenGültigkeitsbereich (Local Scope) eingeführt. In einem lokalen Gültigkeitsbereich gel-ten die dort deklarierten Bezeichner immer nur im Anweisungsblock (zwischen dengeschweiften Klammern). Hierzu gehören alle Arten von Kontrollstrukturen wie if,for, switch und while, die auch als Substatement Scope bezeichnet werden. Wennmehrere gleichnamige Variablen vorhanden sind, erhält immer die lokalste Variableden Zuschlag. Eine Ausnahme bildet die Verwendung des Scope-Operators (oderauch Bereichsoperator) :: – aber dazu in Kürze mehr.

{int iwert = 100;{

// Verwendet äußeres iwertcout << iwert << '\n';int iwert = 200;// Verwendet inneres iwertcout << iwert << '\n';

}}

3.1.2 Gültigkeitsbereich Funktionen

Der Gültigkeitsbereich eines Funktions-Prototyps gilt bis zum Ende der Deklara-tion (mitsamt Funktionsparameter), und der Gültigkeitsbereich der Funktionsde-finition erstreckt sich über die gesamte Funktion (also den Anweisungsblock derFunktion). Ansonsten gilt auch hier, dass bei der Verwendung einer globalen undeiner lokalen Variable mit demselben Namen die lokalste Variable den Zuschlagerhält. Eine Ausnahme gibt es jedoch wieder, wenn Sie den Scope-Operator ::verwenden.


227

Gültigkeitsbereiche (Scope) 3.1

Mit dem Scope-Operator haben Sie die Möglichkeit, auf den globalen Gültigkeits-bereich zuzugreifen (egal, von wo). Haben Sie zum Beispiel eine lokale und eine glo-bale Variable mit dem Namen iwert, können Sie mit ::iwert auf die globale und,wie immer, mit dem Namen iwert (ohne den Scope-Operator) auf die lokale Vari-able zugreifen. Dieser Operator wird bei den Klassen in Kapitel 4, »ObjektorientierteProgrammierung«, noch näher besprochen. Trotzdem hierzu ein Beispiel:

// scope.cpp#include <iostream>using namespace std;

// globale Variableint iwert = 11;

void func( void );

int main(void) {func();return 0;

}

void func( void ) {int iwert = 22;// iwert der Funktion erhält Zuschlagcout << iwert << '\n';{

// Nochmals iwert der Funktioncout << iwert << '\n';int iwert = 33;// Inneres iwert erhält Zuschlagcout << iwert << '\n';// Globales iwert erhält den Zuschlagcout << ::iwert << '\n';

}// nochmals globales iwertcout << ::iwert << '\n';

}


2222331111


228


3.1.3 Gültigkeitsbereich Namensraum (Namespaces)

Ein Bezeichner, der in einem Namensraum deklariert ist, existiert vom Anfangseiner Deklaration bis zum Ende des Namensraums. Wegen der Wichtigkeit derNamensräume (engl.: Namespaces) in C++ wird in Abschnitt 3.2, »Namensräume(Namespaces)«, gesondert darauf eingegangen.

3.1.4 Gültigkeitsbereich Klassen (Class Scope)

Klassenelemente, die in einer Klasse deklariert werden, gelten von dieser Dekla-ration an bis zum Ende der Klassendeklaration. Auf Klassenelemente kann nur inVerbindung mit einer Variablen des Klassentyps zugegriffen werden. Daraufwird speziell bei den Klassen in Kapitel 4, »Objektorientierte Programmierung«,eingegangen.

3.2 Namensräume (Namespaces)

Mit Namensräumen (Namespaces) können Sie einen Gültigkeitsbereich erzeu-gen, in dem Sie beliebige Bezeichner wie Klassen, Funktionen, Variablen, Typenund sogar andere Namensräume deklarieren können. Die Verwendung vonNamensräumen ist besonders hilfreich bei sehr umfangreichen Projekten, beidenen für gewöhnlich mit mehreren Modulen und Klassenbibliotheken gearbei-tet wird. Hier kann es passieren, dass es bei der Vergabe von Namen zu Konflik-ten mit gleichen Namen kommt. Zwei Klassen oder Funktionen mit demselbenNamen lassen sich zum Beispiel ohne Namensräume nicht verwenden.

3.2.1 Neuen Namensbereich erzeugen (Definition)

Einen neuen Namensbereich können Sie entweder global oder innerhalb einesbereits definierten Namensbereichs einführen. Dieser wird deklariert, indemhinter dem Schlüsselwort namespace der Name des Namensraums folgt. DieDeklarationen, die anschließend zu diesem Namensbereich gehören, werdenzwischen geschweiften Klammern angegeben:

namespace meinBereich {int iwert;float fwert;// Definition von funktion()void funktion ( void ) {

// Anweisungen von funktion()}// Definition von eineKlasse


229

Namensräume (Namespaces) 3.2

class eineKlasse {// Anweisungen für eineKlasse

}}

Hier haben Sie eine int-Variable iwert, eine float-Variable fwert, die Funktionfunktion und die Klasse eineKlasse als Elemente für den Namensbereich mein-Bereich deklariert.

Natürlich können Sie einen solchen Namensbereich jederzeit um weitere Ele-mente erweitern. Im Beispiel wurden die Funktion funktion und die KlasseeineKlasse bereits definiert. In der Praxis wird allerdings meistens eine Deklara-tion im Namensbereich vorgenommen. Die eigentliche Definition wird fürgewöhnlich außerhalb des Namensbereichs durchgeführt. Hierzu muss allerdingsder Namensbereich mit dem Scope-Operator (bzw. Bereichsoperator) verwendetwerden. Die Funktion funktion und die Klasse eineKlasse werden dann wiefolgt definiert:

namespace meinBereich {int iwert;float fwert;// Deklaration von funktion()void funktion ( void );// Deklaration von eineKlasseclass eineKlasse;

}

// Definition von funktion()void meinBereich::funktion( void ) {

// Anweisungen von funktion()}

// Definition von eineKlasseclass meinBereich::eineKlasse {

// Anweisungen für eineKlasse}

Einen bereits eingeführten Namensbereich können Sie außerdem jederzeit wie-der öffnen und um weitere Elemente erweitern oder die Definition darin vorneh-men. Beispielsweise:

namespace meinBereich {int iwert;float fwert;// Deklaration von funktion()void funktion ( void );


230


// Deklaration von eineKlasseclass eineKlasse;

}

// Erneut im Namensbereich meinBereichnamespace meinBereich {

// Definition von meinBereich::funktion( void )void funktion( void ) {

// Anweisungen von funktion()}

}

// Definition von eineKlasseclass meinBereich::eineKlasse {

// Anweisungen für eineKlasse}

// Namensbereich neu öffnen und erweiternnamespace meinBereich {

// Namensbereich meinBereich um dwert erweitertdouble dwert;

}

Jetzt könnten Sie theoretisch einen neuen Namensbereich mit denselben Funkti-onen erzeugen, ohne dass es hierbei zu Konflikten kommt:

namespace meinBereich {int iwert;float fwert;// Deklaration von funktion()void funktion ( void );// Deklaration von eineKlasseclass eineKlasse;

}

namespace mein_NEUER_Bereich {int iwert;float fwert;// Deklaration von funktion()void funktion ( void );// Deklaration von eineKlasseclass eineKlasse;

}

Hier haben Sie zwei Namensbereiche (meinBereich und mein_NEUER_Bereich)mit denselben Elementen. Das kommt zwar in der Praxis selten in dieser Formvor, soll aber hier demonstrieren, wozu Namensbereiche dienen.


231


3.2.2 Zugriff auf die Bezeichner im Namensraum

Verwenden Sie einen Bezeichner innerhalb eines Namensraums, so können Siediesen, wie gewöhnlich, über den Typ und den Bezeichner ansprechen.

Bezeichner;

Wollen Sie allerdings einen Bezeichner außerhalb des Namensbereichs verwen-den, müssen Sie den Namensbereich mit dem Scope-Operator mit angeben.

Namensbereich::Bezeichner;

Auf globale Bezeichner, die Sie außerhalb eines Namensbereichs definiert haben,können Sie mit dem Scope-Operator (Bereichsoperator) allein zugreifen.

// Aufruf des globalen Bezeichners::Bezeichner;

Hierzu ein Beispiel, das die Zugriffe auf die einzelnen Bezeichner eines Namens-raums demonstrieren soll. Im Beispiel wurde dreimal eine Funktion funktion()und dreimal der Wert iwert verwendet, ohne dass es zu Konflikten kommt.

// namespace1.cpp#include <iostream>using namespace std;

// Deklaration globale Funktionvoid funktion( void );// globale Variable iwertint iwert = 1;

namespace ersterBereich {int iwert = 11;// Deklaration von Funktion im// Namensbereich ersterBereichvoid funktion( void );

}

namespace zweiterBereich {int iwert = 22;// Deklaration von Funktion im// Namensbereich zweiterBereichvoid funktion( void );

}

int main(void) {int gesamt;// Aufruf von funktion() aus Namensbereich ersterBereich


232


ersterBereich::funktion();// Aufruf von funktion() aus Namensbereich zweiterBereichzweiterBereich::funktion();// Aufruf der globalen Funktion funktion() ...funktion();// ... oder auch::funktion();

// Zugriff auf den Wert iwert aus ersterBereichersterBereich::iwert = 66;// Nochmals die Funktion aus dem// Namensbereich ersterBereichersterBereich::funktion();

// Rechnung mit Werten aus mehreren Namensbereichengesamt = ersterBereich::iwert +

zweiterBereich::iwert + ::iwert;cout << "Summe aus allen Namensbereichen : "

<< gesamt << '\n';return 0;

}

// globale Funktion definierenvoid funktion( void ) {

cout << "funktion(): Globale\n";cout << "Wert von iwert : " << iwert << "\n\n";

}

void ersterBereich::funktion( void ) {cout << "funktion(): Namensbereich ersterBereich\n";cout << "Wert von iwert : " << iwert << "\n\n";

}

void zweiterBereich::funktion( void ) {cout << "funktion(): Namensbereich zweiterBereich\n";cout << "Wert von iwert : " << iwert << "\n\n";

}


funktion(): Namensbereich ersterBereichWert von iwert : 11

funktion(): Namensbereich zweiterBereichWert von iwert : 22


233


funktion(): GlobaleWert von iwert : 1

funktion(): GlobaleWert von iwert : 1


Summe aus allen Namensbereichen : 89

Die Verwendung der globalen Funktion aus der main-Funktion heraus kann auchohne den Scope-Operator geschehen. Wollen Sie aber zum Beispiel die globaleFunktion funktion() aus einem anderen Namensbereich aufrufen, benötigen Siewieder den Scope-Operator. Wenn aus dem Namensbereich ersterBereich dieglobale Funktion funktion() verwendet werden soll, müssen Sie wie folgt vor-gehen:

void ersterBereich::funktion( void ) {cout << "funktion(): Namensbereich ersterBereich\n";cout << "Wert von iwert : " << iwert << "\n\n";// Ruft die globale Funktion funktion() auf::funktion();

}

Den Scope-Operator zu vergessen hätte in diesem Beispiel außerdem noch dennegativen Effekt, dass eine nicht mehr ohne Gewalt zu beendende Rekursiongestartet würde.

In der Praxis sollte man es sich angewöhnen, den Scope-Operator zu verwenden.Werden (wie im Beispiel gesehen) mehrere Funktionen mit demselben Namendeklariert sowie definiert, und Sie importieren einzelne oder alle Bezeichner auseinem Namensbereich, so wird dem Bezeichner aus dem importierten Bereichder Vorzug gegeben, da dieser dann eben der globalere Bezeichner ist (siehe dazuauch den folgenden Abschnitt 3.2.3.).

3.2.3 using – einzelne Bezeichner aus einem Namensraum importieren

Will man nicht ständig den Namensbereich mit angeben, kann man auch ein-zelne Bezeichner aus einem Namensbereich »importieren«. Hierzu werdenDeklarationen mit dem Schlüsselwort using gemacht. Mit folgender using-Deklaration können Sie zum Beispiel aus dem Namensbereich ersterBereich dieFunktion funktion() importieren:


234


using ersterBereich::funktion; // Achtung, ohne Klammern ()

Jetzt können Sie die Funktion funktion() aus dem Namensbereich ersterBe-reich mit einem einfachen Aufruf des Bezeichners aufrufen:

funktion(); // Funktion aus Namensbereich ersterBereich

Hierzu nochmals unser Beispiel namespace1.cpp, verändert durch das Schlüssel-wort using und einige importierte Bezeichner:


// Deklaration globale Funktionvoid funktion( void );// globale Variable iwertint iwert = 1;

namespace ersterBereich {int iwert = 11;// Deklaration von Funktion// im Namensbereich ersterBereichvoid funktion( void );

}

namespace zweiterBereich {int iwert = 22;// Deklaration von Funktion// im Namensbereich zweiterBereichvoid funktion( void );

}

int main(void) {using ersterBereich::funktion;using zweiterBereich::iwert;int gesamt;// Aufruf von funktion() aus Namensbereich ersterBereichfunktion();// Aufruf von funktion() aus Namensbereich zweiterBereichzweiterBereich::funktion();// Aufruf der globalen Funktion funktion() ...// Jetzt unbedingt mit dem Scope-Operator ::::funktion();


235


// Zugriff auf den Wert iwert aus zweiterBereichiwert = 66;// Nochmals die Funktion aus dem// Namensbereich zweiterBereichzweiterBereich::funktion();

// Rechnung mit Werten aus mehreren Namensbereichengesamt = ersterBereich::iwert + iwert + ::iwert;cout << "Summe aus allen Namensbereichen : "

<< gesamt << '\n';return 0;

}

// globale Funktion definierenvoid funktion( void ) {

cout << "funktion(): Globale\n";cout << "Wert von iwert : " << iwert << "\n\n";

}

void ersterBereich::funktion( void ) {cout << "funktion(): Namensbereich ersterBereich\n";cout << "Wert von iwert : " << iwert << "\n\n";

}

void zweiterBereich::funktion( void ) {cout << "funktion(): Namensbereich zweiterBereich\n";cout << "Wert von iwert : " << iwert << "\n\n";

}






Summe aus allen Namensbereichen : 78


236


3.2.4 using – alle Bezeichner aus einem Namensraum importieren

Wollen Sie alle Bezeichner eines Namensraums sichtbar machen, so ist dies zumBeispiel mit folgender Angabe möglich:

using namespace ersterBereich;

Jetzt sind alle Bezeichner aus dem Namensbereich ersterBereich einfach mitdem Bezeichner ansprechbar – es ist keine explizite Angabe des Scope-Operatorsmehr nötig. Natürlich kann es trotzdem sinnvoll sein, den Scope-Operator zu ver-wenden, um Mehrdeutigkeiten zu vermeiden.

Beachten Sie bitte, dass eine using-Direktive, die den kompletten Namensbe-reich »importiert«, nicht einer Deklaration aller Namen eines Namensbereichsentspricht, sondern lediglich einer Bekanntgabe des Namensraums. Dies bedeu-tet, dass eine using-Direktive allein noch nicht zu einem Konflikt führt, wennsich im aktuellen und importierten Namensbereich gleiche Bezeichner befinden.Das Problem der Mehrdeutigkeit tritt erst dann auf, wenn die Bezeichner ange-sprochen werden. Dazu sollte man wissen, wie C++ nach einem Bezeichner sucht(siehe Abschnitt 3.2.5, »Namensauflösung«).

Ein Beispiel, das die Verwendung von using-Direktiven demonstriert:


namespace ersterBereich {int iwert = 11;// Deklaration von Funktion funktion1// im Namensbereich ersterBereichvoid funktion1( void );

}

namespace zweiterBereich {

Hinweis

Eine using-Deklaration ist die Deklaration eines Namens im Gültigkeitsbereich undkeine Definition!

Hinweis

Beim »Importieren« einzelner Bezeichner aus einem Namensraum spricht man von einerusing-Deklaration. Bei der Verwendung aller Namen aus dem Namensraum ohneAngabe des Scope-Operators wird von einer using-Direktive gesprochen.


237


float fwert = 11.11;// Deklaration von Funktion funktion2// im Namensbereich zweiterBereichvoid funktion2( void );

}

int main(void) {using namespace ersterBereich;using namespace zweiterBereich;

// Ruft funktion1() aus Namensbereich ersterBereich auffunktion1();// Ruft funktion2() aus Namensbereich zweiterBereich auffunktion2();

// Gibt den Wert von iwert aus Bereich ersterBereich auscout << "main() -> iwert : " << iwert << '\n';// Gibt den Wert von fwert aus Bereich zweiterBereich auscout << "main() -> fwert : " << fwert << '\n';return 0;

}

void ersterBereich::funktion1( void ) {cout << "funktion(): Namensbereich ersterBereich\n";cout << "Wert von iwert : " << iwert << "\n\n";

}

void zweiterBereich::funktion2( void ) {cout << "funktion(): Namensbereich zweiterBereich\n";cout << "Wert von fwert : " << fwert << "\n\n";

}



funktion(): Namensbereich zweiterBereichWert von fwert : 11.11

main() -> iwert : 11main() -> fwert : 11.11

Wenn ein Namensraum auch eine using-Direktive enthält, die Bezeichner impor-tiert, so wird automatisch der zweite Namensbereich mit importiert:


238



namespace ersterBereich {int iwert = 11;// Deklaration von Funktion funktion1// im Namensbereich ersterBereichvoid funktion1( void );

}

namespace zweiterBereich {using namespace ersterBereich;float fwert = 11.11;// Deklaration von Funktion funktion2// im Namensbereich zweiterBereichvoid funktion2( void );

}

int main(void) {// Importiert automatisch auch ersterBereichusing namespace zweiterBereich;

// Ruft funktion1() aus Namensbereich ersterBereich auffunktion1();// Ruft funktion2() aus Namensbereich zweiterBereich auffunktion2();

// Gibt den Wert von iwert aus Bereich ersterBereich auscout << "main() -> iwert : " << iwert << '\n';// Gibt den Wert von fwert aus Bereich zweiterBereich auscout << "main() -> fwert : " << fwert << '\n';return 0;

}

void ersterBereich::funktion1( void ) {cout << "funktion(): Namensbereich ersterBereich\n";cout << "Wert von iwert : " << iwert << "\n\n";

}void zweiterBereich::funktion2( void ) {

cout << "funktion(): Namensbereich zweiterBereich\n";cout << "Wert von fwert : " << fwert << "\n\n";

}


239


Sie können die Namensbereiche aber auch verschachteln, das heißt, in einemNamensbereich können noch mehrere andere Namensbereiche deklariert wer-den. Hier ein solches Beispiel:

namespace ersterBereich_aussen {int iwert = 11;void funktion( void );namespace ersterBereich_innen1 {

int iwert = 22;void funktion1( void );

}namespace ersterBereich_innen2 {

int iwert = 33;void funktion2( void );

}}...// Aufruf von funktion1()ersterBereich_aussen::ersterBereich_innen1::funktion1();// Aufruf von funktion2()ersterBereich_aussen::ersterBereich_innen2::funktion2();// Aufruf von funktion()ersterBereich_aussen::funktion();

Wenn Sie Namensbereiche verschachteln, kann dies sehr verwirren, daher soll-ten Sie sich folgende Zugriffsregeln merken:

� Ein Bezeichner im inneren Namensraum verdeckt Bezeichner gleichenNamens aus den äußeren Bereichen.

� Im inneren Namensraum können Sie die Bezeichner aus den äußerenNamensbreichen verwenden, ohne den Scope-Operator dafür zu benutzen.

� Alle Bezeichner eines inneren Namensraums sind für den äußeren Namensbe-reich nicht sichtbar und müssen mit dem Scope-Operator verwendet werden.

� Bei verschachtelten Namensräumen, die mit der using-Direktive »importiert«werden, sind nur die Bezeichner im Namensraum selbst sichtbar! Bezeichnerinnerhalb eines Namensraums sind hier noch nicht verfügbar.

3.2.5 Namensauflösung

Hier nun der versprochene Abschnitt, der kurz beschreibt, wie C++ nach einemBezeichner sucht (wird auch als Name Lookup bezeichnet). Es folgt ein Beispiel,mit dem Sie die anschließend beschriebenen Namensauflösungen in der Praxisdemonstrieren können, indem Sie die einzelnen Bezeichner iwert auskommen-tieren bzw. wieder anwenden.


240



namespace einBereich {// Deklaration im Namensbereich einBereichint iwert = 11;

}

// globale Deklarationint iwert = 22;

int main(void) {using namespace einBereich;// lokale Deklarationint iwert = 33;cout << iwert << '\n';return 0;

}

Stößt der Compiler auf einen Bezeichner, versucht er, diesen Namen nach folgen-dem Schema aufzulösen:

� Zuerst wird nach der lokalen Deklaration eines Bezeichners gesucht.

� Wird keine lokale Deklaration des Bezeichners gefunden, werden Bereicheabgesucht, die im aktuellen Gültigkeitsbereich enthalten sind. Dies umfassttheoretisch auch den globalen Bereich.

� Als Letztes wird nach dem Bezeichner im importieren Namensraum gesucht.Dieser enthält auch die namenlosen Namensbereiche – siehe Abschnitt 3.2.7,»Anonyme (namenlose) Namensbereiche«.

3.2.6 Alias-Namen für Namensbereiche

Wenn ein Namensbereich bereits definiert wurde, dürfen Sie dafür auch einenneuen Namen (genauer: Alias-Namen) verwenden.

namespace neuerName alterName;

Hiermit können Sie auf die Bezeichner des Namensbereichs sowohl mit neuer-Name als auch mit alterName zugreifen. Diese Technik wird gerne beim Zugriffauf verschachtelte Namensbereiche verwendet, beispielsweise so:

namespace ersterBereich_aussen {int iwert = 11;void funktion( void );


241


namespace ersterBereich_innen {float fwert = 11.11;void funktion1( void );

}}

Wenn Sie nun folgende Definition machen

namespace einBereich ersterBereich::ersterBereich_innen;

können Sie zum Beispiel mit

einBereich::fwert = 22.22;

auf die Variable fwert im inneren Bereich des Namensbereichs ersterBereich_innen zugreifen. Ohne den Alias-Namen müssten Sie umständlich Folgendes ver-wenden:

ersterBereich_aussen::erster_Bereich_innen::fwert = 22.22;

3.2.7 Anonyme (namenlose) Namensbereiche

Es kann auch ein Namensraum ohne einen Namen verwendet werden, beispiels-weise so:

namespace {// ...

}

Dieser Namensbereich wird als Namensraum mit einem systemweit eindeutigenNamen mit einer using-Direktive verwendet und entspricht im Prinzip folgen-dem Konstrukt:

namespace einBereich {// ...

}using namespace einBereich;

Auch wenn Sie dem anonymen Namensbereich keinen Namen gegeben haben,so wird dennoch einer vom Compiler vergeben. Durch die automatische Verwen-dung der anschließenden using-Direktive können Sie Bezeichner eines anony-men Namensbereichs im aktuellen Gültigkeitsbereich – siehe Abschnitt 3.1,»Gültigkeitsbereiche (Scope)« – direkt (ohne Scope-Operator) ansprechen.

Außerhalb dieses Gültigkeitsbereichs können die Bezeichner des anonymenNamenbereichs nicht mehr verwendet werden, weil es nicht möglich ist, eineusing-Direktive für einen Namensbereich zu verwenden, der keinen Namen hat.


242


Damit hat man ein effektives Mittel, wenn man globale Variablen verwendenwill/muss (warum auch immer). Da der Gültigkeitsbereich nur für die aktuelleÜbersetzungseinheit (beispielsweise der Datei) gültig ist, entstehen keine Kon-flikte, wenn in einer anderen Datei der Übersetzungseinheit eine globale Vari-able mit demselben Namen existieren sollte. Natürlich stellt dies nach wie vorkeinen Freischein für globale Variablen dar.

Nebenbei stellen anonyme Namensbereiche eine gute Alternative für static-Deklarationen da, beispielsweise:

static int iwert;

Hier haben Sie eine Variable vom Typ int mit einer statischen (siehe Abschnitt3.4.3, »Speicherklasse 'static'«) Lebensdauer deklariert. Auch diese Deklarationhat ihren Gültigkeitsbereich in der aktuellen Übersetzungseinheit. Dasselbe rea-lisieren Sie auch mit einem anonymen Namensraum wie folgt:

namespace {int iwert;

}

3.2.8 Namensbereich und Header-Dateien

Das beste Beispiel zum Thema Namensbereich finden Sie in der C++-Standardbi-bliothek selbst. Im ANSI-C++-Standard sind alle Klassen, Objekte und Funktionenin der C++-Standardbibliothek im Namensbereich std definiert. Durch die Ver-wendung von

using namespace std;

im Programm ersparen Sie sich den Scope-Operator und können auf alle Klassen,Objekte und Funktionen ohne den Scope-Operator :: auf die Bezeichner zugrei-fen. Ohne die Verwendung der using-Direktive und das »Importieren« desNamensbereichs std müssten Sie auf die Bezeichner der Header-Datei<iostream> wie folgt zugreifen:

// namespace6.cpp#include <iostream>

int main(void) {std::cout << "Ohne using namespace std\n";return 0;

}

Ich könnte es jetzt hierbei belassen und davon ausgehen, dass schon alles in Ord-nung gehen wird. Aber wenn Sie sich vielleicht schon einige ältere Quellcodes


243


angesehen haben, haben Sie vermutlich festgestellt, dass es Programme gibt, dieiostream folgendermaßen einbinden

#include <iostream.h>

(also mit .h) und keine using-Direktive für den Namensbereich std verwenden.Wenn Sie also das folgende Programm übersetzen, werden Sie gewöhnlich keineProbleme bekommen:

// namespace7.cpp#include <iostream.h>

int main(void) {cout << "Ohne using namespace std\n";return 0;

}

Dass dies hier ohne Bekanntgabe des Namensbereichs std funktioniert, liegtdaran, dass C++ vor 1997 noch gar keine Namensbereiche kannte. Die Verwen-dung der Header-Dateien mit der Endung .h wie zum Beispiel <iostream.h> funk-tioniert nur noch aus Gründen der Kompatibilität zu älteren Programmen.

Als nun eine neudefinierte Version der Standardbibliothek mit vielen neuenHilfsmitteln hinzugefügt wurde, war der Name der Header-Dateien ein Problem.Hätte man hierbei wieder einen Namen wie <iostream.h> verwendet, so hätteman Probleme mit älteren Programmen bekommen. Daher hat man kurzerhandbeschlossen, das .h aus den Standard-Header-Dateien zu entfernen.

Somit besitzen laut Standard die Header-Dateien der Standardbibliothek jetztkeine Endung mehr. Das heißt auch, dass bei vielen Compilern nun die Standard-Header-Dateien im Allgemeinen doppelt vorhanden sind – einmal mit derEndung .h (veraltet) und einmal ohne (aktueller Standard) –, um die Kompatibili-tät zu älteren C++-Programmen zu erhalten.

Bei den neuen Header-Dateien ohne eine Endung wie <iostream> werden dieDeklarationen im Namensbereich std platziert. Somit ist nach dem neuen Stan-dard Folgendes korrekt:

// namespace8.cpp#include <iostream>

int main(void) {std::cout << "Aktueller Standard\n";return 0;

}


244


Oder auch mit der using-Direktive (mit der Sie auch gleich die Kompatibilität zuälteren Programmen bewahren, die noch keine Namensräume kennen):


int main(void) {cout << "Aktueller Standard\n";return 0;

}

Die Version, die Sie im Beispiel namespace7.cpp gesehen haben, ist somit nurnoch geduldet, entspricht aber nicht mehr dem aktuellen Standard. Leider kannman nicht einfach den neuen Standard verwenden. Auf manchen Implementie-rungen (beispielsweise auf Uralt-Systemen) schlägt nämlich die Version ohneeine Endung der Standard-Header-Dateien bei der Übersetzung fehl. Dann bleibteinem meistens nichts anderes mehr übrig, als die alte Version mit der Endung.h zu verwenden.

3.3 C-Funktionen bzw. -Bibliotheken in einem C++-Programm

Es wurde zuvor bereits erwähnt, dass sich der Weg, eine Header-Datei einzu-binden, mit dem neuen C++-Standard geändert hat. Dies gilt auch für die Ver-wendung der Standardbibliotheks-Funktionen von C. Neben der Neuerung, dassHeader-Dateien nicht mehr mit der Endung .h (siehe Abschnitt 3.2.8, »Namens-bereich und Header-Dateien«) eingebunden werden, bekommen Header-Dateienvon Standard-C das Zeichen »c« vorangestellt. Damit werden diese als C-Header-Dateien gekennzeichnet und gleich sichtbar. Aus <stdio.h> wird also <cstdio>.

Hierzu eine Liste von C-Header-Dateien (siehe Tabelle 3.1), wie sie im ANSI-C++-Standard eingebunden werden sollten, und das Gegenstück dazu in ANSI C:

Hinweis

Aktuellere Compiler (beispielsweise g++ ab 4.3.x) hingegen werden ein Beispiel wienamespace7.cpp nicht mehr übersetzen und korrekterweise auch bemängeln, dass coutnicht in diesem Gültigkeitsbereich bekannt ist.


245

C-Funktionen bzw. -Bibliotheken in einem C++-Programm 3.3

3.3.1 C-Funktionen aus einer C-Bibliothek aufrufen

Dieser Abschnitt richtet sich an die schon etwas erfahreneren Programmierer, diebereits Programme in C geschrieben haben.

Wenn Sie zum Beispiel eine C-Funktion aus einer C-Bibliothek aufrufen wollen,müssen Sie nicht den C-Quellcode neu kompilieren. Wollen Sie also in einemC++-Programm eine C-Funktion aus einer C-Bibliothek aufrufen, die mit einemC-Compiler übersetzt wurde, müssen Sie dies dem C++-Compiler bekanntgeben:

extern "C" typ funktion( parameter );

Damit teilen Sie dem C++-Compiler mit, dass die Funktion funktion() mit einemC-Compiler übersetzt wurde. Hier sollte man vielleicht noch darauf hinweisen,dass ein C++-Compiler Funktionsaufrufe anders übersetzt, weil dieser gegenüberC einige Spracherweiterungen (beispielsweise Überladung) besitzt. Natürlich kön-nen Sie hierbei auch mehrere C-Funktionen einer Bibliothek verwenden. Hierzumüssen Sie die Funktionen nur in geschweiften Klammern zusammenfassen:

ANSI C ANSI C++

<assert.h> <cassert>

<ctype.h> <cctype>

<errno.h> <cerrno>

<float.h> <cfloat>

<iso646.h> <ciso646>

<limits.h> <climits>

<locale.h> <clocale>

<math.h> <cmath>

<setjmp.h> <csetjmp>

<signal.h> <csignal>

<stdarg.h> <cstdarg>

<stddef.h> <cstddef>

<stdio.h> <cstdio>

<stdlib.h> <cstdlib>

<string.h> <cstring>

<time.h> <ctime>

<wchar.h> <cwchar>

<wtype.h> <cwtype>

Tabelle 3.1 Vergleich der Header-Dateien in ANSI-C und ANSI C++


246


extern "C" {typ funktion1( parameter );typ funktion2( parameter );typ funktion3( parameter );

}

Sind diese C-Funktionen bereits in einer Header-Datei deklariert, müssen Sie nurnoch diese Datei einkopieren:

extern "C" {#include "CFunktionen.h"

}

Wollen Sie C-Funktionen oder Header-Dateien sowohl für C- als auch C++-Pro-gramme zur Verfügung stellen (was durchaus üblich ist), müssen Sie einebedingte Kompilierung wie folgt verwenden:

// Haben wir ein C++-Programm#ifdef __cplusplusextern "C" { // Für das C++-Programm#endif

// Für C- und C++-Programmetyp funktion1( parameter );typ funktion2( parameter );typ funktion3( parameter );

#ifdef __cplusplus} // Für das C++-Programm#endif

Mit der vordefinierten symbolischen Konstante __cplusplus können Sie feststel-len, ob ein C- oder C++-Compiler verwendet wird. Handelt es sich um einen C++-Compiler, wird die extern "C"-Deklaration mit den geschweiften Klammern ver-wendet.

Wenn Sie C-Funktionen in einem C++-Programm neu erstellen wollen – wie dieszum Beispiel nötig ist, wenn Sie eine C-Funktion aufrufen, die als Argument eineweitere C-Funktion erwartet (etwa bei den Standard-C-Funktionen bsearch()und qsort()) –, dann können Sie auch hier den C++-Compiler mit extern "C"anweisen, diese Funktion als C-Funktion zu übersetzen. Hierzu ein reines C-Pro-grammbeispiel:

/* bsearch.c */#include <stdio.h>#include <stdlib.h>#include <string.h>/* Anzahl der Strings */#define MAX 5


247

C-Funktionen bzw. -Bibliotheken in einem C++-Programm 3.3

/* Vergleichsfunktion für zwei Strings */int cmp_str(const void *s1, const void *s2) {

return (strcmp(*(char **)s1, *(char **)s2));}

int main(void) {char *daten[MAX], puffer[80], *ptr,

*key_ptr, **key_ptrptr;int count;/* Wörter eingeben */printf("Geben Sie %d Wörter ein\n", MAX);for (count = 0; count < MAX; count++) {

printf("Wort %d: ", count+1);fgets(puffer, 80, stdin);/* Speicher für das Wort Number count reservieren */daten[count] = (char *) malloc(strlen(puffer)+1);strcpy(daten[count], strtok(puffer,"\n") );

}/* Die einzelnen Wörter sortieren */qsort(daten, MAX, sizeof(daten[0]), cmp_str);/* Sortierte Daten ausgeben */for (count = 0; count < MAX; count++)

printf("\nWort %d: %s", count+1, daten[count]);

/* Jetzt nach einem Wort suchen */printf("\n\nNach welchem Wort wollen Sie suchen: ");fgets(puffer, 80, stdin);/* Zur Suche übergeben Sie zuerst den puffer an key,* danach benötigen Sie einen weiteren Zeiger, der* auf diesen Such-Schlüssel zeigt*/key_ptr = strtok(puffer, "\n");key_ptrptr = &key_ptr;/* ptr bekommt die Adresse des Suchergebnisses */ptr =(char *) bsearch(key_ptrptr, daten, MAX,

sizeof(daten[0]), cmp_str);

if(NULL == ptr)printf("Kein Ergebnis für %s\n", puffer);

elseprintf("%s wurde gefunden\n", puffer);

return EXIT_SUCCESS;}


248


Dies hier ist reiner C-Code. Wenn Sie nun die »dankbare« Aufgabe haben, diesesProgramm in ein C++-Programm umzuschreiben, haben Sie immer noch das Pro-blem, dass die beiden Funktionen bsearch() und qsort() C-Funktionen alsArgumente erwarten. Mit dem bisherigen Wissen und extern "C" können Siedies durchaus selbst realisieren, wenn Sie wollen. Hier das Beispiel umgeschrie-ben in einen C++-Code:

/* bsearch.cpp */#include <iostream>#include <cstdio>#include <cstdlib>#include <cstring>using namespace std;

// Anzahl der Stringsconst int MAX=5;const int BUF=80;

// Vergleichsfunktion für zwei Stringsextern "C" {

int cmp_str(const void *s1, const void *s2) {return (strcmp(*(char **)s1, *(char **)s2));

}}

int main(void) {char *daten[MAX], puffer[BUF], *ptr,

*key_ptr, **key_ptrptr;

// Wörter eingebencout << "Geben Sie " << MAX << " Wörter ein\n";for (int count = 0; count < MAX; count++) {

cout << "Wort " << (count+1) << ": ";cin.getline(puffer, BUF);// Speicher für das Wort Number count reservierendaten[count] = new char [BUF+1];strcpy(daten[count], strtok(puffer,"\n") );

}// Die einzelnen Wörter sortierenqsort(daten, MAX, sizeof(daten[0]), cmp_str);// Sortierte Daten ausgebenfor (int count = 0; count < MAX; count++)

cout << "\nWort " << count+1 << ": " << daten[count];


249

Speicherklassenattribute 3.4

// Jetzt nach einem Wort suchencout << "\n\nNach welchem Wort suchen Sie : ";cin.getline(puffer, BUF);/* Zur Suche übergeben Sie zuerst den puffer an key,* danach benötigen Sie einen weiteren Zeiger, der* auf diesen Such-Schlüssel zeigt*/key_ptr = strtok(puffer, "\n");key_ptrptr = &key_ptr;// ptr bekommt die Adresse des Suchergebnissesptr =(char *) bsearch(key_ptrptr, daten, MAX,

sizeof(daten[0]), cmp_str);

if(0 == ptr) {cout << "Kein Ergebnis für " << puffer << '\n';

}else {

cout << puffer << " wurde gefunden\n";}return 0;

}


Geben Sie 5 Wörter einWort 1: VogelWort 2: MenschWort 3: AutoWort 4: BaumWort 5: Pferd

Wort 1: AutoWort 2: BaumWort 3: MenschWort 4: PferdWort 5: Vogel

Nach welchem Wort suchen Sie : BaumBaum wurde gefunden

3.4 Speicherklassenattribute

Mit Speicherklassenattributen geben Sie die Speicherklasse eines Bezeichners anund bestimmen somit die Lebensdauer und Bindung eines Bezeichners.


250


3.4.1 Speicherklasse »auto«

Die Speicherklasse auto haben Sie bisher fast immer (unbewusst) verwendet.Durch das Voranstellen des Schlüsselworts auto bei der Deklaration einer Vari-ablen wird diese Variable automatisch angelegt und am Ende des Gültigkeits-bereichs (Blocks) wieder gelöscht. Der Gültigkeitsbereich von auto ist somitderselbe wie bei einer lokalen Variablen – siehe Abschnitt 3.1.1, »Lokaler Gültig-keitsbereich (Local Scope)«:

auto int iwert = 11;

ist dasselbe wie

int iwert = 11;

Da also auto die Standard-Speicherklasse ist, kann die Angabe auch ganz entfal-len. Verwenden Sie auto für globale Bezeichner, erhalten Sie eine Fehlermel-dung, da auto nur für lokale Objekte gültig ist – und somit auf Funktionen über-haupt nicht anwendbar, weil diese immer global sind.

3.4.2 Speicherklasse »register«

Alles, was zu auto gesagt wurde, trifft auch auf die Speicherklasse register zu.Allerdings weisen Sie mit dem Schlüsselwort register den Compiler an, dieseVariable möglichst lange im Prozessor-Register zu halten – wodurch ein schnelle-rer Zugriff möglich ist als auf dem Arbeitsspeicher. Allerdings gilt für das Schlüs-selwort register mit Variablen dasselbe wie für inline bei den Funktionen –der Compiler entscheidet selbst, welche Variable er in den schnellen Prozessor-Registern ablegt. Somit kann der Compiler diese Speicherklasse auch ignorieren.

3.4.3 Speicherklasse »static«

Wenn Sie eine Variable mit der Speicherklasse static deklarieren, existiert dieseVariable von ihrer ersten Verwendung an bis zum Ende des Programms. Bei ska-laren Objekten bewirkt static, dass dieses Objekt automatisch mit 0 initialisiertwird. Ein Beispiel dazu:

/* static.cpp */#include <iostream>using namespace std;

void funktion( void );

int main(void) {for( int i=0; i < 3; i++ ) {


251

Speicherklassenattribute 3.4

funktion();}return 0;

}

void funktion( void ) {static int iwert;cout << iwert << '\n';iwert++;

}


012

In der Funktion funktion() finden Sie eine statische Variable iwert, deren Wertbei einem Funktionsaufruf zunächst ausgegeben wird. Beim ersten Aufruf ist die-ser Wert automatisch 0 – außer man initialisiert diesen mit einem anderen Wert.Am Ende der Funktion wird dieser Wert um eins inkrementiert. Beim Beendender Funktion wird die statische Variable iwert nicht wie üblich zerstört, sondernbleibt während der Lebenszeit des Programms erhalten, was die erneuten Funk-tionsaufrufe auch demonstrieren.

Allerdings bleibt der Gültigkeitsbereich nach wie vor nur innerhalb der Funktionfunktion() erhalten. Es kann also nicht außerhalb der Funktion auf diese stati-sche Variable zugegriffen werden. Ein erneuter Funktionsaufruf von funktion()hat außerdem den Vorteil, dass diese Variable nicht mehr erneut angelegt wer-den muss.

Natürlich können Sie auch Funktionen mit der Speicherklasse static versehen.Dies wird zum Beispiel verwendet, damit Funktionen (und natürlich auch Vari-ablen) eine lokale Gültigkeit haben – also ausschließlich in der Datei gültig sind.In C++ ist es allerdings mittlerweile üblich, interne Objekte nicht mehr mit derSpeicherklasse static zu versehen, sondern es wird dazu ein anonymer Namens-raum verwendet – siehe Abschnitt 3.2.7, »Anonyme (namenlose) Namensberei-che«.

3.4.4 Speicherklasse »extern«

Standardmäßig können alle global in einer Datei definierten Bezeichner in ande-ren Dateien benutzt werden, die nicht als static ausgewiesen wurden.


252


Somit ist also die Verwendung der Speicherklasse extern zunächst optional –wenn man genau ist. Mit dem Schlüsselwort extern teilen Sie dem Compiler mit,dass die Definition von Variablen oder Funktionen in einer anderen Datei odereinem externen Modul vorgenommen wurde. Mit extern deklarierte Objektegeben nur den Namen bekannt und belegen zunächst noch keinen Speicherplatz.Dies geschieht erst bei der Definition in einer anderen Datei.

Hierzu ein Beispiel:

// abc.cpp#include <iostream>using namespace std;

extern void print1( void );extern void print2( void );extern int MAX;

int main(void) {print1();print2();cout << "Wert von MAX: " << MAX << '\n';return 0;

}

Hier finden Sie die Deklaration von zwei Funktionen und einer Variablen, die alsextern deklariert sind. Somit weiß der Compiler an dieser Stelle schon mal, dasssich die Definitionen dieser Bezeichner in einer anderen Datei befinden. Im Falleder Funktionen könnten Sie das Schlüsselwort extern auch weglassen. Bei derVariablen MAX hingegen würde dies zu einer Fehlermeldung führen, wenn in derexternen Datei ebenfalls eine Variable mit demselben Namen vorhanden wäre(worauf dieses Beispiel ja auch hinaus will) – wobei wir auch gleich wieder beider Warnung wären, möglichst auf globale Variablen zu verzichten.

Die Datei, in der sich die Funktionen und die Variable befinden, heißt in diesemFall xyz.cpp und sieht so aus:

// xyz.cpp#include <iostream>using namespace std;

void print1( void );void print2( void );int MAX = 10;

void print1( void ) {


253

Typqualifikatoren 3.5

cout << "Ich bin print1()\n";}

void print2( void ) {cout << "Ich bin print2()\n";

}

Sofern Sie dieses Beispiel in der Praxis ausführen wollen, müssen Sie die Dateixyz.cpp beim Übersetzen mit angeben bzw. dem »Projekt« hinzufügen.

Beim Einsatz von const-Bezeichnern lässt sich das hier Beschriebene allerdingsnicht so realisieren, da const-Bezeichner nur in der Datei gültig sind, in der diesedefiniert werden. Wollen Sie const-Bezeichner in verschiedenen Dateien ver-wenden, müssen Sie diese schon bei der Deklaration als extern definieren. Diessähe, bezogen auf die Datei abc.cpp und die Variable MAX, wie folgt aus:

// abc.cpp...extern const int MAX;...

Und bei der Datei xyz.cpp, in der MAX auch definiert wurde, sieht der Vorgang wiefolgt aus:

// xyz.cpp...extern const int MAX = 10;...

Eine weitere Anwendung der Speicherklasse extern haben Sie ja bereits kennen-gelernt, als es darum ging, C-Code in einem C++-Programm einzufügen (sieheAbschnitt 3.3, »C-Funktionen bzw. -Bibliotheken in einem C++-Programm«).

3.4.5 Speicherklasse »mutable«

Die Speicherklasse mutable wird nur auf Klassenelemente angewendet, doch seihier schon mal der Vollständigkeit halber darauf hingewiesen. Mit diesemSchlüsselwort spezifizieren Sie ein Klassenelement als »manipulierbar«, auchwenn dieses Element mit (nicht explizit) const vereinbart wurde!

3.5 Typqualifikatoren

Es gibt zwei Typqualifikatoren, const und volatile. const haben Sie bereitskennengelernt (siehe Abschnitt 1.5, »Konstanten«). Die beiden Qualifikatoren


254


lassen sich auch miteinander verwenden, wodurch sich insgesamt vier Angabenvon Typen ergeben:

// unqualifizierte Typangabeusigned int reg;// const-Objektconst unsigned int reg;// volatile-Objektvolatile unsigned int reg;// const volatile-Objektconst volatile unsigned int reg;

3.5.1 Qualifizierer »const«

Wie bereits erwähnt, wurde const bereits in Abschnitt 1.5, »Konstanten«,beschrieben. Hiermit qualifizieren Sie einen Typ so, dass dieser nicht mehr geän-dert werden darf. Dies bedeutet, dass er nicht mehr auf der linken Seite vor einerZuweisung stehen darf:

const int MAX = 5;// Fehler!!!MAX = 10;

3.5.2 Qualifizierer »volatile«

volatile gibt eine Variable an, die im Programm zum Beispiel vom Betriebssys-tem, von der Hardware oder einem gleichzeitig ausgeführten Thread (Parallelpro-zess) geändert werden kann.

Der Qualifizierer volatile kann nur auf Variablen angewendet werden undbewirkt, dass diese Variablen außerhalb des normalen Programmablaufs denWert verändern können. Mit volatile modifizieren Sie eine Variable so, dassder Wert dieser Variablen vor jedem Zugriff neu aus dem Hauptspeicher eingele-sen werden muss.

Das Hauptanwendungsgebiet hierfür ist die System-, Hardware- und Treiberpro-grammierung. Beispielsweise soll in einer Schleife überprüft werden, ob einbestimmter Zustand im Register des Prozessors vorzufinden ist:

while ( reg &( ZUSTAND_A|ZUSTAND_B)) {// Ein Hardware-Gerät wird überprüft

}cout << "Status Gerät X ... [OK]\n";


255

Typumwandlung 3.7

An dieser while-Schleife sehen manche Compiler, dass immer dieselbe Adresseüberprüft wird, und optimieren diese Schleife weg. Dies bedeutet, die Überprü-fung des Gerätestatus wird nur einmal ausgeführt, weil hier die Schleife weg ist.Der Compiler kann einfach nicht wissen, wie wichtig diese Überprüfung für denweiteren Programmablauf ist. Somit gilt für Variablen, die mit volatile dekla-riert sind, dass diese ohne jede Optimierung neu aus dem Hauptspeicher geladenund neue Werte auch sofort wieder dort abgelegt werden.

3.6 Funktionsattribute

Auch für Funktionen gibt es Attribute. Mit inline haben Sie bereits ein Attributkennengelernt. Neben inline (siehe Abschnitt 1.10.6, »Inline-Funktionen«) gibtes noch die Attribute virtual und explicit, die allerdings nur im Zusammen-hang mit Klassen und Methoden verwendet werden können.

3.7 Typumwandlung

Bevor man sich mit der Typumwandlung beschäftigt, sollte man sich zunächstvor Augen halten, dass ein Typ auch nichts anderes darstellt als eine Kette einzel-ner Bits mit 0 und 1. Wie Sie bereits bei den Basisdatentypen erfahren haben, istdie Länge dieser Bit-Kette abhängig vom Datentyp. So hat der Datentyp chargewöhnlich meistens ein Byte, was meistens auch acht Bits sind (aber nicht seinmüssen). Der Datentyp int repräsentiert auf einer 32-Bit-Maschine meistens vierBytes und hat somit gewöhnlich 32 einzelne Bits mit 0 und 1. Beispielsweisesieht die Zahl 100 als char-Wert wie folgt aus:

01100100 // 1 Byte -> 8 Bits -> Wert = 100

Bei einem Typ int sieht diese Bit-Kette wie folgt aus (32 Bit):

00000000 00000000 00000000 01100100

Im Grunde haben Sie hier dieselbe Bit-Stellung wie im ersten Byte. Somit könn-ten Sie für den Wert 100 sowohl den Typ char also auch int verwenden. Neh-men wir aber mal den Wert 256 als int:

00000000 00000000 000000001 00000000

Dieser Wert passt nicht mehr in den Typ char, da hierbei das zweite Byte miteinem Bit besetzt ist.


256


Worauf ich hinaus will, ist, dass bei einer Typumwandlung (beispielsweise hiervon int nach char) einige Stellen »verloren« gehen könnten. Häufig treten solcheProbleme (auch unsichere Konvertierung genannt) beim Konvertieren von Gleit-punktzahlen zu ganzzahligen Werten auf.

Eine Typumwandlung kann implizit – also durch den Compiler automatisch –erfolgen oder explizit vom Programmierer mit einem Cast-Ausdruck »erzwun-gen« werden. Bei den Klassen können Sie außerdem noch eine solche Typum-wandlung selbst definieren – worauf aber erst in Abschnitt 4.7.7, »Typumwand-lung abgeleiteter Klassen«, eingegangen wird.

3.7.1 Standard-Typumwandlung

Eine implizite Standard-Typumwandlung wird vom Compiler vorgenommen,wenn der Typ eines Ausdrucks nicht mit dem Typ übereinstimmt, der erwartetwurde. Dies trifft häufig in folgenden Fällen zu:

� Funktionsaufrufe – wurde bei einem Funktionsaufruf zum Beispiel eindouble-Wert erwartet, als Argument aber ein Typ int übergeben, wird dasint-Argument in einen double-Wert konvertiert.

� Arithmetische Ausdrücke und Vergleiche – werden bei Berechnungen zweiverschiedene Typen verwendet, so wird immer der »kleinere« der Typen inden Typ des »größeren« konvertiert.

� Initialisierung (Zuweisung) – der Wert, der auf der rechten Seite einer Zuwei-sung angegeben wird, wird automatisch in den Wert konvertiert, der auf derlinken Seite steht.

Integral-Promotion

Um es gleich klarzustellen, wir sprechen hier von einer automatischen Promo-tion, die der Compiler mit den Datentypen machen »kann«, und nicht von einerautomatischen Typumwandlung. Bei einer integralen Promotion wird beispiels-weise häufig ein Typ in einen anderen integralen Typ umgewandelt. Ein Beispieldazu:

char cwert = 0x00;...// Vergleich von zwei int-Werten !!!if ( cwert != 0x80 ) {

// ...}


257

Typumwandlung 3.7

Obwohl Sie hier einen Typ char verwenden, vergleicht das ausführende Pro-gramm zwei int-Werte. Dass dies so ist, liegt daran, dass vor der Ausführungeiner Operation immer der Typ des Operanden angepasst wird. Diese Promotionwird immer so ausgeführt, dass der »kleinere« Typ auf den »größeren« erweitertwird – natürlich nur dann, wenn auch keine Werte verloren gehen.

Es ist also tatsächlich so, dass die Typen char, unsigned char, signed char, shortund unsigned short vom Compiler auf den Typ int erweitert werden können.Kann der Wertebereich nicht von int abgedeckt werden, so kann der Compilerversuchen, eine Anpassung auf unsigned int vorzunehmen. Dasselbe wird auchmit bool, enum und wchar_t gemacht.

Die folgende Tabelle (3.2) zeigt, welche integralen Promotionen der Compilervornehmen kann. Auf der linken Seite steht der integrale Typ, der automatisch inden integralen Typ der rechten Seite umgewandelt wird, wenn der Wertebereichabgedeckt wird.

Gleitkomma-Promotion

Neben der integralen Promotion gibt es noch die Gleitkomma-Promotion. Hierversucht der Compiler, einen Ausdruck vom Typ float in einen Ausdruck vomTyp double zu konvertieren.

Integral-Typumwandlung

Zunächst macht man sich vielleicht um die integrale Typumwandlung rechtwenig Gedanken. Sobald man aber die int-Werte mit und ohne signed undunsigned verwendet und vermischt, sind Fehler garantiert.

Bei einer integralen Typumwandlung werden entweder int-Ausdrücke in einenentsprechenden unsigned- oder eben einen signed-Typ umgewandelt. Wichtigist es zu wissen, dass die Konvertierung eines signed-Typs in einen unsigned-Typ immer undefiniert ist. Das heißt, das Ergebnis lässt sich nicht vorhersagen,weil es vom Compiler abhängt, wie dieser eine solche Konvertierung durchführt.

Typ Integrale Promotion zu

char, signed char, unsigned char int

short, unsigned short int

wchar_t int, unsigned int, long, unsigned long

enum int, unsigned int, long, unsigned long

bool int

class (Bit-Felder) unsigned int

Tabelle 3.2 Integrale Promotion


258


Ein Beispiel hierzu:

signed int siwert = –100;int iwert = 100;

// iwert wird zu unsigned int konvertiertunsigned int uiwert1 = iwert;// undefiniert – compilerabhängigunsigned int uiwert2 = siwert;// Ok, iwert speichert signed int-Wertint iwert2 = siwert;// undefiniert – compilerabhängigint iwert3 = 4294967290;// Okunsigned int uiwert3 = 4294967290;

Wenn der Zieltyp bool ist, wird entsprechend nach 0 oder 1 konvertiert:

int iwert1 = 100;int iwert2 = 0;

// int->bool – Wird nach 1 konvertiertbool bwert1 = iwert1;// int->bool Wird nach 0 konvertiertbool bwert2 = iwert2;

Gleitkomma-Typumwandlung

Natürlich kann auch der Typ einer Gleitkommazahl in einen anderen Gleitkom-matyp umgewandelt werden (beispielsweise float nach double oder umge-kehrt). Sofern allerdings der Wert einer Gleitpunktzahl nicht in einer anderenganz abgedeckt werden kann, ist der Wert auf der linken Seite der Zuweisungundefiniert – also auch wieder compilerabhängig, da sich nicht sagen lässt, wasder Compiler damit macht.

Integral-Gleitkomma-Typumwandlung

Natürlich kann auch einem integralen Typ ein Gleitkommatyp zugewiesen wer-den. Allerdings kann der integrale Typ keine Nachkommastelle speichern, sodass diese Informationen verloren gehen. Lässt sich der Gleitkommawert nichtals integraler Wert darstellen, ist das Ergebnis wieder undefiniert und abhängigdavon, was der Compiler damit macht.

float fwert = 3.14567;// Gleitkomma-Integral-Umwandlung -> aus 3.14567 wird 3int iwert = fwert;


259

Typumwandlung 3.7

Der umgekehrte Fall, wenn ein integraler Typ in einen Gleitkommatyp umge-wandelt bzw. diesem zugewiesen wird, ist weniger problematisch. Das Ergebnisentspricht dann einer Gleitkomma-Repräsentation.

Bool-Typumwandlung

Jeder Wert vom integralen Typ, vom Enumerations- oder vom Zeigertyp kannautomatisch in einen bool-Wert umgewandelt werden. 0 wird somit zum bool-Wert false und alles andere zum bool-Wert true.

int iwert1 = 100;int iwert2 = 0;int* iptr = 0;

// integraler Typ zu bool aus 100 wird true (1)bool bwert = iwert1;if( bwert == true ) {

cout << "iwert1 ist nicht 0!\n";}

// integraler Typ zu bool aus 0 wird false (0)bwert = iwert2;if( bwert == false ) {

cout << "iwert2 ist 0!\n";}

// Zeigertyp zu bool aus Nullzeiger wird false (0)bwert = iptr;if( bwert == false ) {

cout << "iptr ist ungültig\n";}

iptr = &iwert1;// Zeigertyp zu bool aus gültiger Adresse wird true (1)bwert = iptr;if( bwert == true ) {

cout << "iptr ist gültig\n";}

Zeiger- und Basisklassen-Typumwandlung

Es gibt auch zwei Fälle der automatischen Typumwandlung von Zeigern, undzwar kann jeder Zeigerwert, der den Wert 0 enthält, auch in einen Nullzeiger(NULL) umgewandelt werden. Außerdem kann jeder Zeiger eines bestimmtenTyps in einen Zeiger vom Typ void umgewandelt werden. Hierbei erhält manebenfalls die Anfangsadresse des Speicherobjekts.


260


Auch bei den Klassen gibt es die Möglichkeit von Typumwandlungen im Zusam-menhang mit der Vererbung. Aber hierauf wird erst in Abschnitt 4.7.7, »Typum-wandlung abgeleiteter Klassen«, eingegangen.

3.7.2 Explizite Typumwandlung

Nachdem Sie erfahren haben, wie der Compiler automatisch implizite Umwand-lungen vornimmt, sehen Sie jetzt, wie Sie als Programmierer selbst solcheTypumwandlungen realisieren können. Sie sollten sich allerdings hierbei immervor Augen halten, dass Sie den Compiler damit »zwingen«, etwas zu tun, was die-ser eigentlich nicht so machen würde. Somit sollte auch klar sein, dass einegedankenlose Typumwandlung das eine oder andere Problem mit sich bringt.Dies beginnt bei falschen Ergebnissen und kann bis zum Absturz des Programmsführen.

Typumwandlung mit dem C-Cast

Zwar werden Sie in der Praxis kaum noch eine Typumwandlung mit den C-Castsmachen, aber da es noch viel C-Code (oder eine Mischung aus C und C++) gibt,sollten Sie auch den C-Cast-Operator und dessen Verwendung kennen. Die Syn-tax dazu ist recht einfach:

(Typ) Ausdruck;

Hiermit wandeln Sie das Ergebnis des Ausdrucks in den entsprechenden Typ um:

float fwert;int iwert1 = 100, iwert2 = 33;// Ergebnis der Division von Ganzzahlen// umwandeln in Gleitpunktzahlenfwert = (float) iwert1 / iwert2;

Ohne die Typumwandlung mit dem C-Cast (float) würden Sie als Ergebnis denWert 3 zurückbekommen. Die Nachkommastellen würden abgeschnitten wer-den. Was ist also so »schlimm« am C-Cast-Operator? Verwenden wir hierfür dochmal folgendes Beispiel:

float fwert;int iwert1 = 100, iwert2 = 33;

Hinweis

Bevor Sie sich auf das Abenteuer der expliziten Typumwandlung einlassen, sollten Siesich überlegen, ob dies nicht zunächst mit der impliziten Umwandlung möglich ist. Dasheißt, Sie sollten nur eine explizite Typumwandlung vornehmen, wenn dies nicht mehranders möglich ist.


261

Typumwandlung 3.7

// Ergebnis der Division von Ganzzahlen// umwandeln in Gleitpunktzahlenfwert = (char) iwert1 / iwert2;

Eigentlich handelt es sich um dasselbe Beispiel, nur habe ich hier statt eines Castsnach float einen Cast nach char gemacht – sinnlos, aber möglich.

Leider ist ein C-Cast auch möglich, wenn das Ergebnis des rechten Ausdrucks grö-ßer als die Zielgruppe ist. Wird zum Beispiel versucht, eine float-Berechnung ineinem short-Wert mit Hilfe eines C-Casts zu speichern, so lässt sich dies auch»mit Gewalt« realisieren:

short swert;float fwert1 = 1000000, fwert2 = 33;swert = (short) fwert1 / fwert2;

Der Compiler dürfte (sollte) hier zwar eine Warnung ausgeben, aber leider gibtes immer wieder Programmierer, die das ignorieren.

Also ist das Problem an den C-Casts, dass man fast jeden beliebigen Datentypohne Sicherheitsabfrage umwandeln kann.

C++ hat hierzu noch eine alternative Notation des alten C-Casts mit eingeführt:

Typ (Ausdruck);

Diese Notation stellt eine lesbare Alternative zu den alten C-Casts dar und wirdwie ein Funktionsstil ausgeführt und auch so bezeichnet:

float fwert;int iwert1 = 100, iwert2 = 33;// Ergebnis der Division von Ganzzahlen// umwandeln in Gleitpunktzahlenfwert = float(iwert1) / float(iwert2);

Neue C++-Typumwandlungs-Operatoren

In C++ wurden vier neue Operatoren zur Typumwandlung eingeführt, derenVerwendung erheblich sicherer ist als die von C-Casts (aber zunächst auch kom-plizierter). Hier die vier neuen Cast-Operatoren:

const_cast<TYP>(ausdruck)static_cast<TYP>(ausdruck)

Hinweis

Man kann es nicht oft genug erwähnen: Wenn Sie ein C++-Projekt starten, sollten Siedie neuen Operatoren zur Typumwandlung verwenden.


262


dynamic_cast<TYP>(ausdruck)reinterpret_cast<TYP>(ausdruck)

TYP ist hier der neue Typ, in den Sie den Ausdruck konvertieren wollen.

const_cast<TYP>-Typumwandlung

Mit der Typumwandlung const_cast<TYP> wandeln Sie einen Typ mit den Qua-lifikatoren const oder volatile in einen Ausdruck desselben Typs um, nur ohneden Qualifizierer – der Qualifizierer (const oder volatile) wird also vorüberge-hend entfernt.

Ein einfaches Beispiel: Eine Funktion gibt einen const char*-Wert zurück, Siewollen (oder können) den Rückgabewert aber nicht in einem const char*-Zeigerspeichern, sondern in einem einfachen char-Zeiger. Hierzu müssen Sie miteinem const_cast vorübergehend den Qualifizierer außer Kraft setzen. Das fol-gende Listing demonstriert ein solches Beispiel. Die Funktion substring suchtim String s1 nach einem Unterstring s2 und gibt die Anfangsadresse auf diesenUnterstring zurück (falls vorhanden). Ohne den const_cast würde sich das Pro-gramm nicht übersetzen lassen.

// const_cast.cpp#include <iostream>#include <cstring>using namespace std;

const char* substr( const char* s1, const char* s2 );

int main(void) {const char* cptr1 = "Hallo Welt!";const char* cptr2 = "Welt";// const char* nach char* konvertierenchar *retptr = const_cast<char*>( substr(cptr1, cptr2) );if ( retptr != 0 ) {

cout << retptr << '\n'; // Welt!}return 0;

}

const char* substr( const char* s1, const char* s2 ) {return strstr( s1, s2 );

}

Natürlich bedeutet das jetzt nicht, dass Sie const_cast auch auf echte Objekteanwenden können, die bei ihrer Deklaration als const vereinbart wurden. Der


263

Typumwandlung 3.7

Grund ist ganz einfach, da manche Compiler bei einem Typ, den Sie mit constqualifizieren, bestimmte Optimierungen vornehmen. Beispielsweise könnte derCompiler diese Konstante in einem Read-only-Speicher wie Flash oder EEPROMablegen. Ein schreibender Zugriff darauf hat wieder undefinierte Folgen. Folgen-des ist also recht kritisch zu betrachten:

const int ciwert = 100;// Nicht erlaubt !!!int iwert = const_cast<int>(ciwert);

Die meisten Compiler sollten hierbei sowieso eine Fehlermeldung ausgeben.

static_cast<TYP>-Typumwandlung

Ein static_cast<TYP> können Sie überall einsetzen, um zum Beispiel Ganzzahl-typen und Gleitkommatypen hin- und herzukonvertieren. Natürlich bedeutetdies auch wieder, dass zum Beispiel bei einer Konvertierung von int nach charnur die Bits mit niedrigen Werten übernommen werden. Auch hier wird der Restwieder verworfen.

double dwert = 9.1;// explizite Typumwandlung von double nach intint iwert = static_cast<int>(dwert);

// explizite Typumwandlung von int nach floatfloat fwert = static_cast<float>(iwert);

// Konvertiert das Ergebnis in einen int-Wertint idoppelt = static_cast<int>( dwert * dwert );

Der static_cast-Operator wird auch dazu verwendet, um typenlose Zeiger(void*) in einen beliebigen anderen Zeiger zu konvertieren, beispielsweise so:

void *vptr = ....;// Zeiger-Umwandlung von void* nach char*char* cptr = static_cast<char*>(vptr);

Natürlich kann der static_cast-Operator auch zur definierten Umwandlungvon Objekten (genauer Objektzeigern) einer Klasse auf Objekte einer Basisklasse(die in einer Beziehung zueinander stehen) verwendet werden.

reinterpret_cast<TYP>-Typumwandlung

Die Typumwandlungen, die Sie nicht mehr mit const_cast oder static_castrealisieren können, müssen Sie mit reinterpret_cast durchführen. Derreinterpret_cast ist also für alle anderen Fälle gedacht. Wenn Sie sich die


264


Fälle ansehen, die const_cast und static_cast bereits abdecken, so scheintreinterpret_cast für die »exotischeren« Umwandlungen zuständig zu sein.Vorwiegend wird dieser Operator dazu verwendet, verschiedene Zeigertypenund Ganzzahlen in Zeiger bzw. umgekehrt zu konvertieren. Beachten Sie, dassbei einer solchen Umwandlung auch die Bit-Kette anders interpretiert wird, waszu einem komplett neuen Resultat führen kann.

Dieser Operator gibt eine alte Sichtweise aus der C-Programmiersprache wieder,die eine Variable nur noch als Ansammlung von Bytes betrachtet, die man belie-big interpretieren kann. Wenn Sie diesen Operator verwenden, machen Siezumindest deutlich, dass Sie sich der Risiken bewusst sind. Ein solches Beispielist im Umgang mit Dateien gegeben, die im Binärformat gespeichert sind. WennSie den Inhalt einer solchen Datei einlesen, verwenden Sie gewöhnlich dieMethode istream::read() aus der Standardbibliothek:

istream::read(char *ptr, streamsize n);

Als erstes Argument müssen Sie einen char-Zeiger auf den Speicher übergeben,in dem der Dateiinhalt geschrieben werden soll. Wenn Sie allerdings eine Reihevon int-Werten binär einlesen wollen, benötigen Sie einen reinterpret_cast,um den Zeiger »umzuinterpretieren«. Hier ein solcher Codeausschnitt:

int* buffer;...// Puffer in der Größe reservierenbuffer = new int[size];...// Datei zuvor noch öffnenifstream in(dateiname_zum_lesen, ios::in | ios::binary);...// Daten lesenin.read(reinterpret_cast<char*>(buffer), size*sizeof(int));

Beachten Sie bitte außerdem, dass Sie eine teilweise plattformabhängige Typum-wandlung vornehmen.

dynamic_cast<TYP>-Typumwandlung

Die letzte Art der Typumwandlung, der dynamic_cast-Operator, steht in einemsehr engen Zusammenhang mit dem Typsystem von C++ (RTTI = Runtime TypeInformation System) und wird auch erst in Kapitel 4, »Objektorientierte Program-mierung«, wo die Klassen und Vererbungen näher behandelt werden, erläutert,da dieser Operator auch nur in diesem Zusammenhang von Bedeutung ist.


1225

Index

- (Operator) 60-- (Operator) 63! (Operator) 79!= (Operator) 77# (Präprozessor) 123#define 123#elif 130#else 130#endif 130#error 128#if 129#ifdef 129#ifndef 129#include 127#pragma 129#pragma pack 218#undef 126% (Operator) 60%= (Operator) 62& (Operator) 65& (Referenz) 149&& (Operator) 79* (Indirektionsoperator) 137* (Operator) 60*= (Operator) 62+ (Operator) 60++ (Operator) 63+= (Operator) 62. (Punktoperator) 275.* (Operator) 353/ (Operator) 60/* */ (Kommentar) 68// (Kommentar) 68/= (Operator) 62< (Operator) 77<< (Operator) 67<< (Shift-Operator) 56

Überladen 381<= (Operator) 77<algorithm> 581<boost/regex.hpp> 899<cfloat> 50, 811<climits> 50, 811<cmath> 802<complex> 776

<cstdlib> 147, 802<cstring> 162, 164<deque> 551<exception> 687, 689<float.h> 50<fstream> 748, 751<funktional> 520<iomanip> 730<iostream> 54, 722<limits.h> 50<limits> 806<list> 540<memory> 645<new> 323, 687<numeric> 811<queue> 557, 561<set> 565<sstream> 764<stack> 554<stdexcept> 681, 689<stdlib.h> 147<string.h> 162<string> 695<strstream> 764<typeinfo> 687, 814<utility> 512<valarray> 779<vector> 534-= (Operator) 62== (Operator) 77> (Operator) 77-> (Pfeiloperator) 277->* (Operator) 353>= (Operator) 77>> (Operator) 67>> (Shift-Operator) 57

Überladen 381?: (Operator) 78[] (Index) 152[] (Indexoperator) 378[] Operator 702^ (Operator) 66__attribut__ 217__cplusplus 246_Bool 40


1226

Index

| (Operator) 66|| (Operator) 79~ (Operator) 67

A

Abgeleitete Klasse 392Basisinitialisierer 405Destruktor 407, 431Elementinitialisierer 406Explizite Typumwandlung 412Klassenbibliotheken erweitern 413Konstruktor 404protected 407public 399Redefinition 401Standardkonstruktor 405Typumwandlung 410Zugriff auf Basisklasse 400Zugriffsrechte 399, 407

abs() 777, 787Absolutwert 803Abstrakte Basisklasse 435Abstrakte Klasse

Konstruktor 438Kopierkonstruktor 439

accept() 940accumulate() 811acos() 787, 802Ada 26Adapter-Klassen 553address() 647adjacent_difference() 812adjacent_find() 586advance() 529AF_BLUETOOTH 928AF_INET 928AF_INET6 928AF_IRDA 928AF_UNIX 928Aktualparameter 104Algol68 26Algorithmen

binäre Suche 624halbnumerische 811Heap- 635Laufzeit 533lexikografischer Vergleich 639Maximum 638

Algorithmen (Forts.)Mengenoperationen 630Minimum 638Mischen 627mit Prädikat (STL) 581nicht verändernde Sequenz- 581Permutation (STL) 641sortieren 620STL 509, 581

Alias-Name 149Allegro 999allocate() 646Allokator 524, 643

Adresse ermitteln 647Datentypen 646Elemente konstruieren 647Elemente zerstören 647Maximale Größe 647selbst definieren 648Speicher freigeben 646Speicher reservieren 646Standard- 645Vergleichsoperatoren 648void 648

ANSI 44append() 708apply() 782Arcuscosinus 802Arcussinus 802Arcustangens 802arg() 777Array 152

Anzahl Elemente ermitteln 156assoziatives 380Bereichsüberschreitung 155Buffer Overflow 155call by reference 185char 159deklarieren 152delete 176dynamisch 176Funktionsparameter 185Funktionsparameter (mehrdim.) 187Heap 176initialisieren 153Klasse 316mehrdimensional 157new 176Objekt 316


1227

Index

Array (Forts.)Rückgabewert aus Funktionen 195struct 204Strukturen 204Teilvektoren 788überladen 378Werte eingeben 157Zeiger 166zweidimensional (dynamisch) 179

ASCII-Code 44ASCII-Erweiterungen 1220ASCII-Zeichensatz 41, 1219asin() 787, 802assign() 536, 542, 553, 701at() 534, 551, 702atan() 787, 802atan2() 788, 802Aufzählungstyp

enum 221Ausgabe

blockweise 758Datei 748Flag 742Status 742synchronisieren 741unformatierte 736zeichenweise 754zeilenweise 756

auto 250average case 533

B

back() 534, 540, 551, 558back_inserter 527bad() 743, 763bad_alloc 687bad_cast 687bad_exception 687bad_typeid 687, 818basic_string 696Basisdatentyp 39

Definition 39Deklaration 39

Basisinitialisierer 405Basisklasse

abstrakt 435, 436BCD 49BCPL 25

Bedingte Kompilierung 129Bedingungsoperator 78before() 818begin() 529BEGIN_EVENT_TABLE() 1010Begrenzer 37

geschweifte Klammern 38Gleichheitszeichen (=) 38Komma (,) 38Semikolon (;) 37

Bereichsoperator 226best case 533Bezeichner 35

importieren 233Namensraum 233, 236

bidirectional_iterator 526Binärsystem 1212binary_search() 624bind() 938bind1st 523bind2nd 523Bit-Felder 216Bit-Operatoren 64Blockweise Ausgabe 758Blockweise Eingabe 758bool 40

false 40true 40

Bool-Typumwandlung 259Boost 892

Regex 894Regex (Konstuktor) 898

braces 38break 84, 96Buffer Overflow 164Bytes 1218

C

C++ 26_Bool 40Casts 260Erweiterungen 29extern 245free() 147Header-Dateien 244in C++ verwenden 244kein C 833


1228

Index

C (Forts.)malloc() 147mit Klassen 26Umschreiben nach C++ 830

C++Aufbau 28C 830Entstehung 25Geschichte 25kein C++ 831Operatoren 1207Schlüsselwörter 1210Schwächen 30Standard 27Stärken 29Stroustrup 25veraltetes 835

C++09 27c_str() 706call by reference 182, 185, 201, 309

Referenzen 184call by value 103, 181, 201, 308capacity() 535, 704case-Marke 83catch

setjmp 835catch() 663catch(...) 666ceil() 803cerr 55, 56cfloat 50, 811char 41, 696

Array 159signed 41unsigned 41

CHAR_BIT 41, 50CHAR_MAX 50CHAR_MIN 50cin 55, 57

get() 58getline() 59, 161

class 267struct 267

clear() 535, 541, 552, 567, 575, 704, 743, 762

climits 41, 44, 50, 811clog 55close() 749, 774, 937closesocket() 937

cmath 802Code 883

Formatierung 884Codespeicher 143compare() 717Compiler 31

Borlands Free Command Line Tools 34GNU g++ 33Microsoft Visual C++ 33

complex 776conj() 777Connect() 1017connect() 929const 53, 125, 148, 195, 221, 254

define 125Klasseneigenschaft 341

const_cast<> 262const_iterator 527construct() 647Container 508, 530

abstrakte 553assoziative 564bit_vector 579bitset 580Datentypen 530deque 551eigener Allokator 648entwickeln 656hash_ 580Laufzeitklassen 532list 540map 572Methoden 531multimap 572multiset 564Operatoren 531priority_queue 560queue 557sequentielle 532set 564slist 579stack 554string 580vector 533wstring 580

continue 97copy() 597, 706copy_backward() 597copy_n() 598


1229

Index

cos() 777, 787, 803cosh() 777, 787, 803Cosinus 803count() 568, 576, 596count_if() 596cout 55, 56, 725Create() 1021Cross-Plattform-Entwicklung 943

Abstraction Layer 943Client-Sockets 964Exception-Handling 958Hauptprogramm 956Header-Datei 943Mehrere Clients gleichzeitig 976Quelldatei(en) 945Server-Sockets 964TCP-Echo-Server 956UDP-Client 975UDP-Server 974

cshift() 782cstdlib 147, 802C-String 159

Bibliotheksfunktionen 161Buffer Overflow 164deklarieren 160eingeben 161initialisieren 160Probleme 164string 706Tabellen 173Terminierungszeichen 160Zeiger 171

cstring 162, 164curly brackets 38

D

data() 706Datei

Ausgabe 748, 751blockweise ausgeben 758blockweise einlesen 758Eingabe 748, 751Exception 763Fehlerbehandlung 762Positionierung 760zeichenweise ausgeben 754zeichenweise einlesen 754zeilenweise ausgeben 756

Datei (Forts.)zeilenweise einlesen 756Zugriff (wahlfrei) 760

Datenabstraktion 266Datenkapselung 266Datenspeicher 143Datenstrom 753Datentyp 39

fortgeschritten 133Grenzwerte 806Information zur Laufzeit 814

DBL_DIG 51DBL_EPSILON 51DBL_MANT_DIG 50DBL_MAX 51DBL_MAX_10_EXP 51DBL_MAX_EXP 51DBL_MIN 51DBL_MIN_10_EXP 51DBL_MIN_EXP 51deallocate() 647Debuggen 890dec 726DECLARE_EVENT_TABLE() 1010default 84define-Direktive 123Definition 39, 99Deklaration 39, 99Dekrementoperator 63delete 146, 322

Array 176free() 834

denorm_min() 809deque (STL-Container) 551

Datentypen 551Methoden 551

Design 889Destroy() 1021destroy() 647Destruktor 293

abgeleitete Klasse 407, 431aufrufen (implizit) 295definieren 293deklarieren 293inline 298virtueller 431

Dezimalkomma 47Dezimalsystem 1212DirectX 1000


1230

Index

Disconnect() 1017distance() 529divides<> 522do...while 91domain_error 685Domainname 920double 47Draft Standard 27DSP 41Dualsystem 1212dynamic_cast<> 264, 439, 819

bad_cast 687Dynamisch Speicher anlegen 143Dynamische Datenstrukturen 210

E

EBCDIC-Code 44Eingabe

blockweise 758Datei 748Flag 742Status 742synchronisieren 741unformatierte 738zeichenweise 754zeilenweise 756

EinlesenString 721

Elementfunktion 269Elementinitialisierer 338, 406Elementzeiger 352elif-Direktive 130Ellipse 116else if-Verzweigung 73else-Direktive 130else-Verzweigung 69empty() 704END_EVENT_TABLE() 1010endif-Direktive 130endl 725ends 725Entwicklungsumgebung 31

IDE 31Entwurf 889enum 221EOF 58eof() 743, 762epsilon() 809

equal() 594equal_range() 567, 576, 625equal_to<> 522erase() 535, 541, 552, 566, 575, 708error-Direktive 128Escape-Zeichen 42EVT_BUTTON() 1010Exception 661

alternatives catch() 666auffangen 663auflösen 666auslösen 662bad_alloc 687bad_cast 687bad_exception 687bad_typeid 687catch() 663domain_error 685invalid_argument 684ios_base::failure 685Klasse 676klassenspezifisch 678Laufzeitfehler 681length_error 684logische Fehler 681new 144out_of_range 682overflow_error 686range_error 686set_terminate() 691set_unexpected() 689Spezifikation 688Stack-Abwicklung 668Standard- 680System- 686terminate()-Handle 691throw 662try 663try-Blöcke verschachteln 670underflow_error 686unerlaubte 689unexpected() 689weitergeben 673what() 681

exception 680Exception-Handling 661Exception-Klasse 676exp() 777, 787, 803Explizite Typumwandlung 260


1231

Index

Exponent 46Extern 245, 251, 827

F

fabs() 803fail() 743, 763false 40FD_CLR() 979FD_ISSET() 979FD_SET() 979FD_ZERO() 979Fehlerbehandlung

Datei 762Fehlerklasse 676Felder 152filebuf 774fill() 607, 734fill_n() 607find() 567, 575, 582, 711find_end() 593find_first_not_of() 714find_first_of() 585, 713find_if() 582find_last_not_of() 715find_last_of() 714fixed 726flags() 746Fließkommadatentypen 46Fließkommazahlen 36float 46float.h 50floor() 803FLT_DIG 51FLT_EPSILON 51FLT_MANT_DIG 50FLT_MAX 51FLT_MAX_10_EXP 51FLT_MAX_EXP 51FLT_MIN 51FLT_MIN_10_EXP 51FLT_MIN_EXP 51FLT_RADIX 50FLTK (GUI-Bibliothek) 995Fluchtzeichen 42flush 56, 725flush() 736fmod() 803for 93

for_each() 582Formalparameter 104Fortgeschrittene Typen 197

Aufzählungstypen (enum) 221Bit-Felder 216Klasse 267Strukturen (struct) 198Unions 218verkettete Liste 210

forward_iterator 526Fox (GUI-Bibliothek) 996free() 147, 834frexp() 803friend 349

Operator-Überladung 365front() 534, 540, 551, 558front_inserter 527fstream 748funktional 520Funktionen 99

Array als Rückgabewert 195Arrays als Parameter 185Attribute 255Aufruf 102Bezeichner 100call by reference 182call by value 103, 181const-Zeiger als Rückgabewert 195Definition 99Deklaration 99Exception 688friend 349globale Variablen 109Gültigkeitsbereich 226inline 117lokale Variablen 109main() 121, 188mathematische 802mehrdimensionale Arrays 187mehrere Rückgabewerte 196Objekt als Argument 307pair 516Parameter 100Parameterübergabe 103, 181Polymorphie 113Prototyp 100Referenz als Rückgabewert 194Rekursion 120Rückgabetyp 100, 105


1232

Index

Funktionen (Forts.)Rückgabewert 105, 190Rücksprungadresse 117Scope-Operator 226Spezifizierer 100Stack 117Standardparameter 110Strukturen als Parameter 201Template 477überladen 113Zeiger als Parameter 182Zeiger als Rückgabewert 190zwei Werte zurückgeben 516

Funktionsadapter 522bind1st 523bind2nd 523not1 523not2 523ptr_fun 523

Funktionsobjekte 520divides<> 522equal_to<> 522greater<> 522greater_equal<> 522less<> 522less_equal<> 522logical_and<> 522logical_not<> 522logical_or<> 522minus<> 522modulus<> 522multiplies<> 522negate<> 522not_equal_to<> 522plus<> 522

Funktions-Template 477Argumente 482definieren 479Gültigkeitsbereich 483Spezialisierung 483Typ explizit festlegen 488Typübereinstimmung 482unterschiedliche Parameter 487

G

Ganzzahlen 36, 44Garbage Collection 146gcount() 739

generate() 607generate_n() 607get() 58, 738, 754gethostbyname() 932getline() 59, 161, 721, 739, 756getservbyname() 931Gleitkomma-Promotion 257Gleitkomma-Typumwandlung 258Gleitkommazahlen 46

Genauigkeit 47Rechenfehler 48

GLU 998GLUT 999good() 743, 762goto 96Grafikprogrammierung 993greater<> 522greater_equal<> 522Grenzwerte 806gslice 792gtkmm (GUI-Bibliothek) 996GUI-Programmierung 993

FLTK 995Fox 996gtkmm (gtk--) 996High-Level 994Low-Level 994MFC 997OWL 997Qt 996RAD-Tools 995VCL 997wxWidgets 1001

Gültigkeitsbereich 225Funktionen 226Klassen 228Lokal 226Namensraum 228

H

Halbnumerische Algorithmen (STL) 811Header-Datei

ANSI-C 244mit Endung 835Namensraum 242ohne Endung 835

HeapAlgorithmen (STL) 635


1233

Index

Heap (Forts.)Array 176

Heap-Speicher 143hex 726Hexadezimalsystem 1214Hostname 920htonl() 931htons() 931

I

ifdef-Direktive 129if-Direktive 129ifndef-Direktive 129ifstream 751if-Verzweigung 69ignore() 739imag() 777IMPLEMENT_APP() 1004in_avail() 771INADDR_ANY 938include-Direktive 127includes() 630indirect_array 800Indirektionsoperator 137Informationsspeicherung 1210Inkrementoperator 63inline 118, 126

define 126Destruktor 298Konstruktor 298Methode 296

inner_product() 811inplace_merge() 628input_iterator 526insert() 535, 541, 552, 567, 575, 707inserter 527int 44INT_MAX 44, 50INT_MIN 44, 50Integral-Gleitkomma-Typumwandlung

258Integral-Promotion 256Integral-Typumwandlung 257internal 734invalid_argument 684iomanip 730ios 723ios::adjustfield 745, 746

ios::app 749, 765ios::ate 749, 765ios::badbit 685, 742, 763ios::basefield 745ios::beg 761ios::binary 749, 765ios::cur 761ios::dec 745ios::end 761ios::eofbit 685, 742, 763ios::failbit 685, 742, 763ios::fixed 745ios::floatfield 745ios::goodbit 742ios::hex 745ios::in 749, 765ios::internal 734, 746ios::left 734, 746ios::oct 745ios::out 749, 765ios::right 734, 746ios::scientific 745ios::seekdir 760ios::showbase 746ios::showpoint 746ios::showpos 746ios::trunc 749, 765ios::uppercase 746ios_base::failure 685iostream 722IP-Nummer 918

dynamisch 918statisch 918

IP-Protokoll 921IPv4 919IPv6 919is_heap() 636is_open() 748, 774is_sorted() 622istream 736istringstream 764iter_swap() 600Iterationen 88Iterator 508, 525, 527

advance() 529bidirektionaler 526distance() 529Distanzen 529Einfüge- 527


1234

Index

Iterator (Forts.)Forward- 526Funktionen 529Input- 526Kategorien 526konstanter 527Output- 526Random-Access- 526, 624reverser 527Stream- 528Zustand 525

K

key_comp() 568, 576Klasse 267

abgeleitete 392abstrakt 435, 436als Eigenschaft 332Array 316Bereichsoperator 270call by reference 309call by value 308Container erstellen 656deklarieren 268Destruktor 293Direkter Zugriff 275dynamische Eigenschaften 324Eigenschaften 268eingebettet 332Elementzeiger 352enum-Eigenschaften 278Exception 676Fehler- 676friend 349indirekter Zugriff 277konstante Klasseneigenschaft 341Konstruktor 285Konvertierungsfunktion 390Konvertierungskonstruktor 388Mehrfachvererbung 463Member 268Methode 268, 269, 295mit UML visualisieren 840Objekte deklarieren 271Objekte verwenden 307Operator-Überladung 358Polymorphie 414Polymorphismus 414

Klasse (Forts.)private 272, 407Programm organisieren 281protected 407public 272, 407Read-only-Methoden 303Referenzen 310Scope-Operator 270statische Klasseneigenschaft 343Template 489this-Zeiger 305Typumwandlung 388Vererbung 392verkettete Liste 441verschachteln 340virtual 433Zeiger auf Eigenschaften 352Zugriff auf Elemente 274Zugriffsmethoden 299Zugriffsrechte 272

Klassen-Array 316deklarieren 316dynamisch 318initialisieren 316Zugriff 317

Klassenbibliotheken erweitern 413Klassenelemente

dynamisch 324Klassenmethoden 295Klassen-Template 489

Argumente 501Definition 490explizite Instantiierung 506generieren 496Instantiierung 496Methode 491Parameter 501Standardargumente 504verkettete Liste 490

Klassen-Typumwandlung 259Kommentare 68, 881Komplexe Zahlen 776Konstanten 53Konstruktor 285

abgeleitete Klasse 404abstrakte Klassen 438aufrufen 289definieren 287deklarieren 286


1235

Index

Konstruktor (Forts.)inline 298Konvertierungs- 388Kopier- 328Standard- 292virtueller 433

Kontrollstrukturen 69Verzweigungen 69

Konvertierungsfunktion 390Konvertierungskonstruktor 388Kopierkonstruktor

Abstrakte Klasse 439

L

Laufzeitklassen 532exponentiell 533konstant 532linear 532logarithmisch 532N*log N 532quadratisch 532

LDBL_DIG 51LDBL_EPSILON 51LDBL_MANT_DIG 51LDBL_MAX 51LDBL_MAX_10_EXP 51LDBL_MAX_EXP 51LDBL_MIN 51LDBL_MIN_10_EXP 51LDBL_MIN_EXP 51ldiv_t 806left 734length() 704length_error 684, 697less_equal<> 522lexicographical_compare() 639Limits

Ganzzahlen 50Gleitkommazahlen 50

limits 806limits.h 41, 44, 50Linker 31Linksassoziativität 60list (STL-Container) 540


listen() 939Literale 36

locale 47log() 777, 787, 803log10() 777, 787, 803Logarithmus 803logic_error 681logical_and<> 522logical_not<> 522logical_or<> 522Logische Operatoren 79long 45long double 47long int 45long long 44, 46LONG_MAX 50LONG_MIN 50longjmp 835Loopback-Interface 926lower_bound() 567, 576, 625

M

main() 121Argumente 122, 188Funktionsparameter 188Parameter 122Rückgabewert 122

make_heap() 636MAKEWORD() 925Makros 123malloc() 147, 834Manipulatoren

eigene 728eigene mit Parameter 731istream 738mit Parameter 730ostream 725

Mantisse 47map (STL-Container) 572


MaschinenspracheMaschinencode 31

Maschinenwörter 1218mask_array 797math.h 802Mathematische Funktionen 802, 803Matrix 789max() 639, 782, 808max_element() 639


1236

Index

max_size() 648, 704MB_LEN_MAX 50Mehrfachvererbung 463

Erzeugung der Objekte (Reihenfolge) 474

indirekte Basisklasse erben 467virtuelle indireke Basisklasse erben 471

Member 268memchr() 165memcmp() 165memcpy() 165memmove() 165memset() 165Mengenoperationen

Algorithmen (STL) 630merge() 542, 628MesaGL 999Methode 269

definieren 269inline 296inline (explizit) 297inline (implizit) 296Klassen-Template 491Objekt als Rückgabewert 314Objekte als Argument 310Operator-Überladung 363Read-only- 303rein virtuell 435Rückgabewert (virtuell) 424Standard- 331static 348this 305virtual 417, 433virtuelle 415virtuelle Methoden redefinieren 420Zugriffs- 299Zugriffsrechte (virtuell) 425

MFCwxWidgets 1206

MFC (GUI-Bibliothek) 997min() 638, 782, 808min_element() 639minus<> 522Mischen

Algorithmen (STL) 627mismatch() 590modf() 803Modularisierung 281

Module 31, 821aufteilen 822Client-Datei 826extern (Speicherklasse) 827Hauptprogramm 826Header-Datei(en) 823main() 826namenloser Namensraum 828öffentliche Schnittstelle 823organisieren 822private Datei 824static (Speicherklasse) 827

modulus<> 522multimap (STL-Container) 572Multimediaprogrammierung 993

Allegro 999DirectX 1000GLU 998GLUT 999MesaGL 999OpenGL 998SDL 1000

multiplies<> 522multiset (STL-Container) 564mutable 253

N

Name Lookup 239name() 814Namensauflösung 239Namensbereich 836Namensraum 228

Alias-Name 240anonym 241, 828Erzeugen 228Header-Datei 242importieren 233, 236namenlos 241static 242using 233, 236Zugriff auf Bezeichner 231

Nameserver 921namespace 236Namespaces 228negate<> 522Netzwerkprogrammierung 917

Client-Server-Prinzip 926Linux 923


1237

Index

Netzwerkprogrammierung (Forts.)Windows 923

Netzwerktechnik 918Domainname 920Hostname 920IP-Nummer 918IP-Protokoll 921IPv4 919IPv6 919Loopback-Interface 926Nameserver 921Portnummer 919Sockets 922TCP 921UDP 921

new 144, 322Array 176bad_alloc 687Exception 323, 687Exceptions 144Fehler-Handle 323malloc() 834nothrow 145Rückgabewert 144set_new_handler() 323

next_permutation() 642norm() 777noshowbase 726noshowpoint 726noshowpos 726not_equal_to<> 522not1 523not2 523nothrow 145nouppercase 726nth_element() 618ntohl() 931ntohs() 931NULL 141numeric 811numeric_limits 806

O

Objekteals Rückgabewert 314Array 316call by reference 309call by value 308

Objekte (Forts.)deklarieren 271dynamisch anlegen 318Elementinitialisierer 338freigeben 320Funktionsargument 307kopieren 328kopieren (dynamisch) 330Read-only- 307Referenzen 310Teil- 334Teilobjekte initialisieren 338verwenden 307Zuweisung verhindern 377

Objektorientiert 265oct 726ofstream 751Oktalsystem 1213OnInit() 1004open() 748, 751, 752, 774OpenGL 998openmode 765operator 358operator=() 330Operatoren 59

arithmetische 60Bedingung 78Bit- 64Dekrement 63Inkrement 63logische 79Typumwandlung 261überladen 358Übersicht 1207Vergleichs- 76Vorrangtabelle 1209

Operator-Überladungfriend-Funktion 365Klassenmethode 363

ostream 724Manipulatoren 725

ostringstream 764out_of_range 682, 697, 702output_iterator 526overflow_error 686OWL (GUI-Bibliothek) 997


1238

Index

P

pair 512pair<> 567partial_sort() 621partial_sort_copy() 621partial_sum() 812partition() 618PDP 44Permutation 641plus<> 522Pointer 133polar() 777Polymorphie 266, 414Polymorphismus 414

dynamic_cast<> 439dynamische Bindung 415Methoden redefinieren 420Rückgabewert 424Signatur 422statische Bindung 415virtual 417Zugriffsrechte 425Zuweisungsoperator 433

pop() 555, 558, 562pop_back() 535, 541, 552pop_front() 541, 552pop_heap() 635PopupMenu 1154Portnummer 919pow() 778, 788, 803Prädikat (STL) 581pragma-Direktive 129Präprozessor

bedingte Kompilierung 129define 123Direktiven 122elif 130else 130endif 130error 128if 129ifdef 129ifndef 129include 127pragma 129undef 126

precision() 726prev_permutation() 641

priority_queue (STL-Container) 560Methoden 561

private 272, 407ProcessEvent() 1017Programm organisieren 281Programmierstil 881

Benennungen 884Code 883Formatierung 884Kommentare 881

protected 407Prototyp 100ptr_fun 523public 272, 407pubseekoff() 771pubseekpos() 771pubsetbuf() 771pubsync() 771Puffer

filebuf 774streambuf 770stringbuf 775

push() 555, 558, 562push_back() 535, 541, 552push_front() 541, 552push_heap() 635put() 736, 754putback() 739

Q

Qt (GUI-Bibliothek) 996Quadratwurzel 803Qualifizierer

const 254volatile 254

Quantifizierer 897queue (STL-Container) 557


quiet_NaN() 809

R

RAD-Tools 995random_access_iterator 526random_shuffle() 616, 617range_error 686rbegin() 527


1239

Index

rdbuf() 749rdstate() 743read() 739, 758readsome() 739real() 777Rechtsassoziativität 60recv() 934recvfrom() 936Redefinition 401reelle Zahlen 46Referenzen 149

call by reference nachbilden 184Klasse 310Rückgabewert aus Funktion 194Zeiger 150

RegexBoost 894

regex_match() 899regex_replace() 906regex_search() 902register 250Reguläre Ausdrücke 894, 895

$ 898* 898+ 898. 896< 898> 898? 898[] 896^ 898Alternativen 897B 898b 898beliebiges Zeichen 896D 898d 898Einführung 895Elemente (POSIX) 895ersetzen 906Gruppierung 897Komplettsuche 899Quantifizierer 897S 898s 898Sonderzeichen 898Teilsuche 902Zeichenauswahl 896Zeichenklassen 896

Reguläre Ausdrücke (Forts.)Zeichen-Literale 896

reinterpret_cast<> 263Rekursionen 120remove() 542, 609remove_copy() 610remove_copy_if() 610remove_if() 542, 609rend() 527replace() 604, 708replace_copy() 605replace_copy_if() 605replace_if() 605reserve() 535, 704resetiosflags() 730resize() 535, 541, 552, 704, 782return 106reverse() 543, 600reverse_copy() 598reverse_iterator 527rfind() 711right 734rotate() 614rotate_copy() 615round_error() 809RTTI 814runtime_error 681

S

sbumpc() 771SCHAR_MAX 50SCHAR_MIN 50Schleifen 88

do...while 91for 93while 88

Schlüsselwörter 35C++ 833, 1210

scientific 726Scope 225

Klasse 228lokal 226Operator 226

SDL 1000search() 593search_n() 586seekg() 760seekp() 760


1240

Index

select() 977FD_CLR() 979FD_ISSET() 979FD_SET() 979FD_ZERO() 979

Selektionen 69send() 934sendto() 936sequentielle Container 532set (STL-Container) 564


set_difference() 631set_intersection() 631set_new_handler() 323set_symmetric_difference() 632set_terminate() 691set_unexpected() 689set_union() 630setbase() 730setf() 727, 746setfill() 730setiosflags() 730setjmp 835setprecision() 730setstate() 743setw() 730sgetc() 772sgetn() 772shift() 782Shift-Operator

<< 56>> 57

short 45short int 45Show() 1020showbase 726showpoint 726showpos 726SHRT_MAX 50SHRT_MIN 50signaling_NaN() 809Signatur 114, 422signed 46Simula 25sin() 778, 787, 803sinh() 778, 787, 803Sinus 803size() 704, 782

sizeof 52Skip() 1017slice 789snextc() 771socket() 927Socketprogrammierung 917, 923

accept() 940Adresse festlegen (binden) 938bind() 938Client-Anwendung 927Client-Server-Prinzip 926close() 937closesocket() 937connect() 929Daten empfangen 934Daten senden 934Datenformat 986gethostbyname() 932hostent 932htonl() 931htons() 931IPv4 nach IPv6 ändern 988Linux 923listen() 939ntohl() 931ntohs() 931Portabilität 988Puffer 987recv() 934recvfrom() 936RFC-Dokumente 990select() 977send() 934sendto() 936servent 931Server-Anwendung 937Server-Hauptschleife 940Sicherheit 990sockaddr_in 930Socket anlegen 927Socket freigeben 937socket() 927Verbindung annehmen 940Verbindung herstellen 929Warteschlange einrichten 939Windows 923

Sockets 922sort() 543, 620sort_heap() 636


1241

Index

sortierenAlgorithmen (STL) 620

Speicher freigeben 146Speicher reservieren 143Speicherbereiche

Code 143Daten 143Heap 143Stack 143

Speicherklassenattribute 249auto 250extern 251mutable 253register 250static 250

Spezifikation 888splice() 542Sprunganweisungen 96sputbackc() 772sputc() 772sputn() 772sqrt() 778, 787, 803sstream 764stable_partition() 618stable_sort() 621Stack 117

Overflow 120stack (STL-Container) 554


Stack-Speicher 143Stack-Unwinding 668Standard Template Library 507Standardausgabe 55, 56Standardbibliothek 695Standardeingabe 55Standard-Exception 680Standardfehlerausgabe 55Standardklasse

complex 776filebuf 774fstream 748gslice 792ifstream 751indirect_array 800ios 723iostream 722istream 736istringstream 764

Standardklasse (Forts.)mask_array 797ofstream 751ostream 724ostringstream 764slice 789sstream 764streambuf 770string 695stringbuf 775stringstream 764strstream 764valarray 779

Standardparameter 110Standard-Streams 54static 242, 250, 827

Klasseneigenschaft 343Klassenmethoden 348

static_cast<> 263Statische Klassenmethoden 348std 55stderr 55stdin 55stdlib.h 147, 802stdout 55Steuerzeichen 42STL 507

abstrakte Container 553Algorithmen 509, 581Algorithmen für Mengenoperationen

630Algorithmen zum lexikografischen

Vergleich 639Algorithmen zum Mischen 627Algorithmen zum Sortieren 620Algorithmen zum Suchen 624Allokator 524, 643assoziative Container 564bit_vector (Container) 579bitset (Container) 580Container 508, 530deque (Container) 551Funktionsobjekte 520halbnumerische Algorithmen 811hash_ (Container) 580Heap-Algorithmen 635Hilfsmittel 512Iterator 508, 525Konzept 508


1242

Index

STL (Forts.)list (Container) 540map (Container) 572multimap (Container) 572multiset (Container) 564pair 512Permutation (Algorithmen) 641priority_queue (Container) 560queue (Container) 557selbstdefinierter Allokator 648set (Container) 564slist (Container) 579stack (Container) 554string (Container) 580vector (Container) 533Vergleichsoperatoren 519verkettete Liste 543wstring (Container) 580

str() 766, 775strcat() 162strchr() 164strcpy() 161Stream

Ausgabe- 724Datei- 748Daten- 753Eingabe- 736File- 748Flag 742Puffer 770Status 742String- 763synchronisieren 741verbinden 741

streambuf 764, 770Streams 54

Standard- 722String 159

Bibliothek- 695C-String 706Datentypen 697einlesen 721Elementzugriff 702erzeugen 698Exception-Handling 697Kapazität ändern 703Konstruktoren 698konvertieren 706Länge ermitteln 703

String (Forts.)Manipulation 707Streams 763suchen in 710Überladene Operatoren 719vergleichen 717zeilenweise Einlesen 758Zuweisung 700

stringKlasse 695

string.h 162stringbuf 764, 775String-Streams 763, 764strlen() 163strncat() 162strncmp() 165strncpy() 161Stroustrup 25strrchr() 164strstr() 165strstream 764strtok() 165struct 198

class 267Strukturen 198

Array 204Bit-Felder 216deklarieren 198dynamisch 210eingebettet 208gepackt 216Parameterübergabe an Funktionen 201union 218Variante 218vergleichen 203verkettete Liste 210Zugriff 199

substr() 709Suche

Algorithmen (STL) 624String 710

sum() 782sungetc() 772swap() 536, 542, 553, 568, 576, 600,

709swap_ranges() 600switch 83

case 83default 84


1243

Index

T

tan() 778, 787, 803Tangens 803tanh() 778, 803TCP 921Teilvektoren 788tellg() 760tellp() 760Template

Funktions- 477Klasse 489STL 507verkettete Liste 490

terminate() 663, 691Testen 890this 305

*this 306, 312this-> 306, 312

throw 662longjmp 835

tie() 741top() 555, 562transform() 602true 40try 663

verschachteln 670Typdefinition

typedef 223type_info 814typeid() 815typeinfo 814Typerkennung zur Laufzeit 814Typqualifikatoren 253

const 254volatile 254

Typumwandlung 255abgeleitete Klasse 410Bool- 259C-Casts 260const_cast<> 262dynamic_cast<> 264explizit 260Gleitkomma- 258Gleitkomma-Promotion 257implizit 256Integral- 257Integral-Gleitkomma- 258Integral-Promotion 256

Typumwandlung (Forts.)Klassen 259, 388Konvertierungsfunktion 390Konvertierungskonstruktor 388Operatoren 261reinterpret_cast<> 263Standard 256static_cast<> 263Zeiger 259

U

Überladen- (unärer Operator) 371-- (unärer Operator) 374! (unärer Operator) 372() (Funktionsoperator) 385++ (unärer Operator) 374+= (Operator) 362<< (Shift-Operator) 381= (Zuweisungsoperator) 376>> (Shift-Operator) 381arithmetische Operatoren 362Funktionen 113Operatoren 358unäre Operatoren 371

UCHAR_MAX 50UDP 921UINT_MAX 50ULONG_MAX 50UML 837

Abhängigkeiten 867abstrakte Klassen 852Aggregationen 859Assoziationen 853Diagramme erstellen 840Eigenschaften einer Klasse 841Kardinalität 856Klasse 840Klassenattribut 846Klassendiagramme 840Komponenten 839Komposita 861Kontexte 862Mehrfachvererbung 851Methoden einer Klasse 844Notizen machen 848Objekt einer Klasse 843Pakete 863


1244

Index

UML (Forts.)qualifizierte Assoziation 858reflexive Assoziation 858Schnittstellen 865Sichtbarkeit 845spezielle Assoziationen 858Vererbung 849Wozu UML? 837

undef-Direktive 126underflow_error 686unexpected() 689Unformatierte Ausgabe 736

flush() 736put() 736write() 736

Unformatierte Eingabe 738gcount() 739get() 738getline() 739ignore() 739putback() 739read() 739readsome() 739unget() 739

unget() 739Unicode 44, 1222Unions 218unique() 542, 612unique_copy() 612unsetf() 746unsigned 46upper_bound() 567, 576, 625uppercase 726USHRT_MAX 50using 233, 236, 241

namespace 236utility 512

V

valarray 779gslice 792indirect_array 800mask_array 797mathematische Funktionen 787Methoden 781Operatoren 784slice 789Teilvektoren 788

value_comp() 568, 576Variable 40Variablen

global 109lokal 109

Variante 218VCL (GUI-Bibliothek) 997vector (STL-Container) 533


Vektoren 152Vererbung 266, 392

dynamic_cast<> 439public 399Signatur 422Zugriffsrechte 399

Vergleichsoperatoren 76Verkettete Liste 210, 441, 490, 543

Anker 211doppelt verkettet 215Ende 212Knoten 211

VerschmelzenAlgorithmen (STL) 627

Verzweigungen 69case 83else 69else if 73if 69switch 83

virtual 417, 433Virtual Method Table (VMT) 426void 52

Zeiger 148void* 141volatile 254Vorrangtabelle 1209

W

Wahlfreier Dateizugriff 760Wahrheitswert 40wchar_t 43, 696what() 681while 88width() 734Win32-API 994Winsock 923

initialisieren 925


1245

Index

worst case 533write() 736, 758ws 738WSACleanup() 925WSAStartup() 925wstring 696wxApp 1003wxArray 1201wxBitmap 1196wxBitmapButton 1088

Ereignis-Handle einrichten 1089Style 1089

wxBookCtrlBase 1058wxBoxSizer 1047wxBusyInfo 1173wxButton 1081

Ereignis-Handle einrichten 1083Methoden 1082Stock-Button 1084Style 1082

wxCheckBox 1103Ereignis-Handle einrichten 1105Methoden 1104Style 1104

wxCheckListBox 1107Ereignis-Handle einrichten 1110Methoden 1109, 1110Style 1108

wxChoice 1091Ereignis-Handle einrichten 1094Methoden 1092

wxChoicebook 1059wxClipboard 1198wxColourDialog 1182wxComboBox 1097

Ereignis-Handle einrichten 1099Methoden 1098Style 1098

wxCommandEvent 1010wxContextMenuEvent 1146

Ereignis-Handle einrichten 1147wxControl 1026wxControlWithItems 1026wxCursor 1197wxDateSpan 1203wxDateTime 1202wxDC 1195wxDialog 1035

Methoden 1036

wxDialog (Forts.)Style 1036

wxDir 1203wxDirDialog 1181

Style 1182wxEVT_DESTROY 1021wxEvtHandle 1012wxFFile 1203wxFile 1203wxFileDialog 1178

Methoden 1180Style 1179

wxFileName 1204wxFindReplaceDialog 1194wxFlexGridSizer 1049wxFontDialog 1184wxFrame 1003, 1005, 1027


wxGauge 1136wxGrid 1199wxGridSizer 1048wxHashMap 1202wxHtmlWindow 1198wxIcon 1197wxImage 1197wxInputStream 1204wxList 1202wxListbook 1058wxListBox 1107


wxListCtrl 1198wxLongLong 1203wxMDIChildFrame 1034wxMDIParentFrame 1034wxMenu 1140

Ereignis-Handle einrichten 1146Methoden 1141Tastenkombinationen 1145

wxMenuBar 1147Methoden 1148

wxMessageDialog 1035, 1040Style 1040

wxMultiChoiceDialog 1187wxNotebook 1051

Methoden 1052


1246

Index

wxNotebook (Forts.)Style 1052

wxNotebookSizer 1049wxNumberEntryDialog 1191wxObjArray 1202wxObject 1203wxOutputStream 1204wxPageSetupDialog 1194wxPanel 1007, 1050wxPasswordEntryDialog 1194wxPoint 1203wxPopupWindow 1050wxPrintDialog 1194wxProgressDialog 1171


wxRadioBox 1113Ereignis-Handle einrichten 1115Methoden 1114Style 1114

wxRadioButton 1113Ereignis-Handle einrichten 1117Methoden 1116Style 1116

wxRect 1203wxRegEx 1201wxScrolledWindow 1060

Ereignis-Handle einrichten 1061Methoden 1061

wxShowTip 1174wxSingleChoiceDialog 1186

Style 1187wxSize 1203wxSizer 1045

Flags für Ausrichtung 1046Flags für Rahmen 1046

wxSlider 1119Ereignis-Handle einrichten 1123Methoden 1122Style 1122

wxSocket 1205wxSortedArray 1202wxSpinCtrl 1119


wxSplitterWindow 1066Ereignis-Handle einrichten 1068Style 1067

wxStaticBitmap 1137Methoden 1138

wxStaticBox 1139wxStaticBoxSizer 1049wxStaticLine 1138wxStaticText 1136


wxStreamBase 1204wxString 1201wxStringTokenizer 1201wxTaskBarIcon 1199wxTempFile 1203wxTextCtrl 1125


wxTextEntryDialog 1192wxTextFile 1203wxThread 1205wxTimeSpan 1203wxToggleButton 1133

Ereignis-Handle einrichten 1134Methoden 1133

wxToolBar 1149Ereignis-Handle einrichten 1154Methoden 1151

wxToolbarStyle 1150

wxToolbook 1060wxTopLevelWindow

Methoden 1029wxTreebook 1060wxTreeCtrl 1198wxUpdateUIEvent 1146

Ereignis-Handle einrichten 1146wxWidgets 1001

Container-Fenster 1050Dateiklassen 1203Datenstrukturen 1201Device-Context 1195Dialoge 1171Dialoge für Dateien 1178Dialoge für Verzeichnisse 1178Dynamischer Event-Handle 1017Ereignis-Handle 1012Ereignisse behandeln 1009Ereignisse überspringen 1017Fenster 1019


1247

Index

wxWidgets (Forts.)Hallo Welt 1002Kontrollbalken 1147Kontrollelemente 1077Kontrollelemente (statisch) 1135Maus-Eingabe 1195Menüs 1140MFC 1206Stream-Klassen 1204Tastatur-Eingabe 1195Text-Editor (Beispiel) 1156Top-Level-Fenster 1020Übersicht 1001Verzeichnisklassen 1203wxWindows 1002Zwischenablage 1197

wxWindow 1004, 1005, 1020, 1023Ereignis-Handle einrichten 1023Methoden 1048, 1087PopupMenu 1154

wxWindows 1002wxWizard 1198

X

Xlib 994

Z

ZahlenGrenzwerte 806komplexe 776

Zahlensysteme 1211dezimal nach dual 1215dezimal nach hexadezimal 1216Dezimalsystem 1212dual nach dezimal 1216Dualsystem 1212hexadezimal nach dezimal 1217hexadezimal nach dual 1217Hexadezimalsystem 1214oktal nach dual 1217Oktalsystem 1213umrechnen 1215

Zeichen 37Einlesen 58

Zeichenauswahl 896Zeichencodierung 44Zeichenketten 37, 159

einlesen 58Zeichenklassen 896Zeichen-Literale 896Zeichensätze 44, 1218

ASCII 1219ASCII-Erweiterungen 1220Unicode 1222

Zeichenweise Ausgabe 754Zeichenweise Eingabe 754Zeiger 133

Adressen speichern 135Adresszuweisung 135Arithmetik 140Array 166auf andere Zeiger verweisen 141auf Klasseneigenschaften 352const 148C-String 171deklarieren 134delete 146dereferenzieren 137dynamisch Speicher anlegen 143Elementzeiger 352Funktionsparameter 182konstante 148mehrfache Indirektion 171new 144Referenzen 150Rückgabewert 190Typumwandlung 259verkettete Liste 210virtueller Methoden- 426void 148

Zeigerarithmetik 140Zeiger-Typumwandlung 259Zeilenweise Ausgabe 756Zeilenweise Eingabe 756Zugriffsmethoden 299Zugriffsrechte 407

abgeleitete Klasse 407Klasse 272


C++ von A bis Z - s3-eu-west-1.amazonaws.com · Jürgen Wolf C++ von A bis Z Das umfassende...

Documents

Transcript of C++ von A bis Z - s3-eu-west-1.amazonaws.com · Jürgen Wolf C++ von A bis Z Das umfassende...