Inhaltsverzeichnis 1

Wie lese ich dieses Buch?

2

Es war einmal. . . 2.1 Der Name „C++“ . . . . . . . . . . . . . . . . . . . 2.2 Weiterentwicklung der Programmiersprache C++ . . 2.3 Berücksichtigung aktueller technischer Gegebenheiten 2.3.1 Verbesserungen am Sprachkern . . . . . . . . 2.3.2 Erweiterung der Programmbibliothek . . . . .

. . . . .

11 . . . . . 12 . . . . . 13 . . . . . 13 . . . . . 13 . . . . . 14

Compiler 3.1 Hilfsmittel . . . . . . 3.2 Die GCC . . . . . . . 3.3 Für Fortgeschrittenere 3.4 Makefiles . . . . . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

15 . 15 . 15 . 17 . 19

GUIs und C++ 4.1 Was ist ein GUI? . 4.2 C++ und GUIs . . 4.3 Einsatz von GUI . 4.3.1 Qt . . . . 4.3.2 GTK+ . . 4.3.3 wxWidgets

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

21 . 21 . 21 . 22 . 22 . 22 . 23

3

4

. . . . .

9

. . . . . .

5

Hallo, du schöne Welt!

25

6

Einfache Ein- und Ausgabe 6.1 Einfache Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . 6.2 Einfache Eingabe . . . . . . . . . . . . . . . . . . . . . . . . .

29 30 31

7

Kommentare

35

1

2 8

9

Rechnen (lassen) 8.1 Einfaches Rechnen . . . . . . . 8.2 Die großen 4 . . . . . . . . . . 8.3 Zusammengesetzte Operatoren 8.4 Inkrement und Dekrement . . .

. . . .

. . . .

. . . .

. . . .

. . . .

Variablen, Konstanten und ihre Datentypen 9.1 Datentypen . . . . . . . . . . . . . . . . 9.1.1 Wahrheitswerte . . . . . . . . . 9.1.2 Zeichen . . . . . . . . . . . . . 9.1.3 Ganzzahlen . . . . . . . . . . . 9.1.4 Gleitkommazahlen . . . . . . . 9.2 Variablen . . . . . . . . . . . . . . . . . 9.3 Konstanten . . . . . . . . . . . . . . . . 9.4 Literale und ihre Datentypen . . . . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

37 . . . . 37 . . . . 39 . . . . 40 . . . . 40

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

45 45 45 46 46 52 52 55 56 59 59 61 61 62 64 64 64

10 Rechnen mit unterschiedlichen Datentypen 10.1 Ganzzahlen unter sich . . . . . . . . . 10.2 Gleitkommarechnen . . . . . . . . . . 10.3 Casting . . . . . . . . . . . . . . . . . 10.3.1 Implizite Typumwandlung . . 10.3.2 Explizite Typumwandlung . . 10.4 Ganzzahlen und Gleitkommazahlen . . 10.5 Rechnen mit Zeichen . . . . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

11 Verzweigungen 11.1 Falls . . . . . . . . 11.2 Andernfalls . . . . 11.3 Vergleichsoperatoren 11.4 Logische Operatoren 11.5 Bedingter Ausdruck

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

67 . 67 . 68 . 71 . 71 . 75

. . . . . .

77 79 83 84 86 87 88

. . . . . . . . . . . . . .

12 Schleifen 12.1 Die while-Schleife . . 12.2 Die do-while-Schleife . 12.3 Die for-Schleife . . . 12.4 Die break-Anweisung . 12.5 Die continue-Anweisung 12.6 Kapitelanhang . . . . 13 Auswahl

. . . .

. . . . . . .

. . . . .

. . . . . .

. . . . .

. . . . . .

. . . . .

. . . . . .

. . . . .

. . . . . .

. . . . .

. . . . . .

. . . . .

. . . . . .

. . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

91

3 13.1 switch und break . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 13.2 Nur Ganzzahlen . . . . . . . . . . . . . . . . . . . . . . . . . . 95 13.3 Zeichen und mehrere case-Zweige . . . . . . . . . . . . . . . . . 96 14 Ein Taschenrechner wird geboren 99 14.1 Die Eingabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 14.2 Die 4 Grundrechenarten . . . . . . . . . . . . . . . . . . . . . . 99 14.3 Das ganze Programm . . . . . . . . . . . . . . . . . . . . . . . 100 15 Zusammenfassung 15.1 Ein- und Ausgabe . . . . 15.2 Kommentare . . . . . . . 15.3 Rechnen . . . . . . . . . 15.4 Variablen . . . . . . . . . 15.4.1 Datentypen . . . 15.4.2 Initalisierung . . 15.4.3 Typaufwertung . 15.5 Kontrollstrukturen . . . . 15.5.1 Anweisungsblöcke 15.5.2 Verzweigung . . 15.5.3 Schleifen . . . . 15.5.4 Auswahl . . . . .

. . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

16 Prozeduren und Funktionen 16.1 Parameter und Rückgabewert . . . . . . . 16.2 Übergabe der Argumente . . . . . . . . . 16.2.1 call-by-value . . . . . . . . . . . 16.2.2 call-by-reference . . . . . . . . . 16.3 Default-Parameter . . . . . . . . . . . . . 16.4 Funktionen überladen . . . . . . . . . . . 16.5 Funktionen mit beliebig vielen Argumenten 16.6 Inline-Funktionen . . . . . . . . . . . . . 17 Lebensdauer und Sichtbarkeit von Variablen 17.1 Lebensdauer . . . . . . . . . . . . . . . . 17.1.1 Globale Variablen . . . . . . . . . 17.1.2 Lokale Variablen . . . . . . . . . 17.1.3 Statische Variablen . . . . . . . . 17.1.4 Dynamisch erzeugte Variablen . . 17.1.5 Objekte und Membervariablen . . 17.2 Sichtbarkeit . . . . . . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . . . . . . . .

. . . . . .

. . . . . . . . .

. . . . . . .

. . . . . . .

. . . . . . . . . . . .

. . . . . . . .

. . . . . . .

. . . . . . . . . . . .

. . . . . . . .

. . . . . . .

. . . . . . . . . . . .

. . . . . . . .

. . . . . . .

. . . . . . . . . . . .

. . . . . . . .

. . . . . . .

. . . . . . . . . . . .

. . . . . . . .

. . . . . . .

. . . . . . . . . . . .

. . . . . . . .

. . . . . . .

. . . . . . . . . . . .

. . . . . . . .

. . . . . . .

. . . . . . . . . . . .

. . . . . . . .

. . . . . . .

. . . . . . . . . . . .

. . . . . . . .

. . . . . . .

. . . . . . . . . . . .

103 103 104 104 105 105 106 106 107 107 107 107 108

. . . . . . . .

109 109 112 112 113 116 117 117 118

. . . . . . .

121 121 121 122 122 122 123 123

4 17.2.1 Allgemein . . . . . . . . . . . . . . . . . . . . . . . . . 123 17.2.2 Gültigkeitsbereiche und deren Schachtelung . . . . . . . 124 17.2.3 Welche Variablen sind sichtbar? . . . . . . . . . . . . . 124 18 Schleifen mal anders – Rekursion 127 18.1 Fakultät . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 18.2 Fibonacci-Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . 129 19 Zeiger 19.1 Grundlagen zu Zeigern . . . . . . 19.2 Zeiger und const . . . . . . . . . . 19.3 Zeigerarithmetik . . . . . . . . . . 19.4 Negativbeispiele . . . . . . . . . . 19.5 void-Zeiger (anonyme Zeiger) . . . 19.6 Zeiger und Funktionen . . . . . . . 19.7 Funktionszeiger . . . . . . . . . . 19.8 Zeiger und Referenzen und Klassen 19.9 Löschen von Zeigern . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

131 131 133 133 135 136 137 138 140 140

20 Referenzen 20.1 Grundlagen zu Referenzen . . . . . . . . 20.2 Anwendung von Referenzen . . . . . . . . 20.2.1 const-Referenzen . . . . . . . . . . 20.2.2 Referenzen als Rückgabetyp . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

141 141 143 144 145

21 Felder 21.1 Zeiger und Arrays . . . . . . 21.2 Mehrere Dimensionen . . . . 21.3 Arrays und Funktionen . . . 21.4 Lesen komplexer Datentypen

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

147 148 150 152 154

22 Zeichenketten 22.1 Einleitung . . . . . . . . . . 22.2 Wie entsteht ein string-Objekt? 22.3 string und andere Datentypen 22.4 Zuweisen und Verketten . . . 22.5 Nützliche Methoden . . . . . 22.6 Zeichenzugriff . . . . . . . . 22.7 Manipulation . . . . . . . . . 22.7.1 Suchen . . . . . . . . 22.7.2 Ersetzen . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

157 157 158 159 161 162 163 164 164 165

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

5 22.7.3 Einfügen . . . . . . 22.7.4 Kopieren . . . . . . 22.8 Vergleiche . . . . . . . . . 22.9 Zahl zu string und umgekehrt 22.10 C-Strings . . . . . . . . . .

. . . . . . . . . . . . . . . . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

165 166 167 168 174

23 Vorarbeiter des Compilers 23.1 #include . . . . . . . . . . . . . . . . 23.2 #define und #undef . . . . . . . . . . . 23.3 # . . . . . . . . . . . . . . . . . . . 23.4 ## . . . . . . . . . . . . . . . . . . . 23.5 #if, #ifdef, #ifndef, #else, #elif und #endif 23.6 #error und #warning . . . . . . . . . . . 23.7 #line . . . . . . . . . . . . . . . . . 23.8 #pragma . . . . . . . . . . . . . . . . . 23.9 Vordefinierte Präprozessor-Variablen

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

175 175 176 177 177 178 179 179 180 180

. . . .

181 181 182 183 184

24 Headerdateien 24.1 Was ist eine Headerdatei? . . . 24.2 Namenskonventionen . . . . . 24.3 Schutz vor Mehrfacheinbindung 24.4 Inline-Funktionen . . . . . . . 25 Das Klassenkonzept 25.1 Ein eigener Datentyp

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

185 . . . . . . . . . . . . . . . . . . . . . . . 185

26 Erstellen und Zerstören 26.1 Konstruktor . . . . . . . . . . 26.1.1 Defaultparameter . . . 26.1.2 Mehrere Konstruktoren 26.1.3 Standardkonstruktor . . 26.1.4 Kopierkonstruktor . . . 26.2 Destruktor . . . . . . . . . . . 26.3 Beispiel mit Ausgabe . . . . . 27 Privat und öffentlich

. . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

189 189 192 192 194 195 195 196 199

28 Klassen und const 201 28.1 Konstante Methoden . . . . . . . . . . . . . . . . . . . . . . . . 201 28.2 Sinn und Zweck konstanter Objekte . . . . . . . . . . . . . . . . 202 28.3 Zugriffsmethoden . . . . . . . . . . . . . . . . . . . . . . . . . 203

6 29 Überladen. . . 205 29.1 Code-Verdopplung vermeiden . . . . . . . . . . . . . . . . . . . 206 30 Call by reference

209

31 Operatoren überladen 31.1 Definition der überladenen Operatoren 31.2 Codeverdopplung vermeiden . . . . . 31.3 Ein-/Ausgabeoperatoren überladen . . 31.4 Spaß mit „falschen“ Überladungen . . 31.5 Präfix und Postfix . . . . . . . . . . . 31.6 Übersicht . . . . . . . . . . . . . . . . 31.7 Rückgabetypen . . . . . . . . . . . . 31.8 Casten . . . . . . . . . . . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

211 213 213 213 213 214 216 216 216

32 Klassen als Datenelemente einer Klasse 217 32.1 Verweise untereinander . . . . . . . . . . . . . . . . . . . . . . 217 33 Rechnen mit Brüchen 219 33.1 Was diese Klasse bieten soll . . . . . . . . . . . . . . . . . . . . 219 33.2 Was diese Klasse nicht kann . . . . . . . . . . . . . . . . . . . . 220 33.3 Ein erster Blick . . . . . . . . . . . . . . . . . . . . . . . . . . 220 34 Die Methoden 34.1 Zugriff . 34.2 ggT() . . 34.3 kgV() . . 34.4 kuerzen()

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

221 222 222 223 224

35 Die Rechenoperationen 35.1 Addition . . . . . 35.2 Subtraktion . . . . 35.3 Multiplikation . . 35.4 Division . . . . . 35.5 Kombination . . . 35.6 Abschluss . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

225 225 225 226 226 226 227

. . . .

. . . .

. . . .

. . . .

36 Umwandlung aus anderen Datentypen 229 36.1 Gleitkommazahl wird Bruch . . . . . . . . . . . . . . . . . . . . 230 36.2 (k)ein Kopierkonstruktor . . . . . . . . . . . . . . . . . . . . . 232 37 Ein- und Ausgabe

233

7 37.1 Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 37.2 Eingabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234 38 Umwandlung in andere Datentypen

235

39 Der Taschenrechner geht zur Schule

237

40 Zusammenfassung

239

41 Nochmal Klassen

247

42 Wir empfehlen inline

249

43 Vererbung 43.1 Einleitung . . . . . . . . . . 43.2 Die Ausgangslage . . . . . . 43.3 Gemeinsam und doch getrennt 43.3.1 Beispiel . . . . . . . 43.4 Erläuterung des Beispiels . . 43.5 protected . . . . . . . . . . . .

251 251 251 252 252 253 254

. . . . . . . . . . . . . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

44 Methoden (nicht) überschreiben 255 44.1 Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255 44.2 2 gleiche Namen, 1 Aufruf . . . . . . . . . . . . . . . . . . . . 255 44.3 Die Methode des Vaters aufrufen . . . . . . . . . . . . . . . . . 256 45 Private und geschützte Vererbung 45.1 Einleitung . . . . . . . . . . 45.2 Private Vererbung . . . . . . 45.3 Geschützte Vererbung . . . . 45.4 Wann wird was benutzt? . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

257 257 257 257 257

46 Funktionstemplates 46.1 Spezialisierung . . . . . . . . . . . . . . . 46.2 Zwischen Spezialisierung und Überladung 46.3 Überladen von Template-Funktionen . . . 46.4 Templates mit mehreren Parametern . . . 46.5 Nichttypargumente . . . . . . . . . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

259 261 263 264 269 272

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

47 Container 273 47.1 Kontainerklassen . . . . . . . . . . . . . . . . . . . . . . . . . . 273 47.1.1 Kontainereigenschaften . . . . . . . . . . . . . . . . . . 274

8 47.1.2

Grundlegende Mitgliedsfunktionen der sequentiellen Kontainerklassen . . . . . . . . . . . . . . . . . . . . . . 275 47.1.3 Adaptive Kontainer . . . . . . . . . . . . . . . . . . . . 276 48 Interne Zahlendarstellung 277 48.1 Gleitkommazahlen . . . . . . . . . . . . . . . . . . . . . . . . . 286 49 Autoren

289

50 Bildnachweis

291

Lizenz This work is licensed under a Creative Commons Attribution-Share Alike 3.0 Unported License, see http://creativecommons.org/licenses/by-sa/3.0/

Kapitel 1 Wie lese ich dieses Buch? Egal, ob Sie schon C++ können, eine andere Programmiersprache beherrschen oder kompletter Programmieranfänger sind. Wenn Sie in C++ programmieren wollen, werden Sie mit diesem Buch etwas anfangen können. Es steht Ihnen frei, das Buch ganz normal von Anfang an zu lesen oder sich die Kapitel herauszupicken, die Sie interessieren. Allerdings sollten Sie beim Herauspicken darauf achten, dass Sie den Stoff der vorherigen Kapitel beherrschen, andernfalls werden Sie wahrscheinlich Schwierigkeiten haben, das Kapitel Ihres Interesses zu verstehen. Dieses Buch gliedert sich in verschiedene Abschnitte, von denen jeder einen eigenen Schwierigkeitsgrad und entsprechend eine eigene Zielgruppe hat. Die meisten Abschnitte vermitteln Wissen über C++ oder sollen die praktische Anwendung zeigen, um das bisherige Wissen zu festigen. Andere weisen auf Besonderheiten und „Stolpersteine“ hin oder vermitteln Hintergrundwissen. Am Ende eines jeden Abschnittes steht eine Zusammenfassung, anhand der das gesamte, in diesem Abschnitt beschriebene Wissen, noch mal schnell nachgelesen werden kann. Wer schnell etwas nachschlagen will, kann sich in der Regel an die Zusammenfassungen halten. Auf Abweichungen von dieser Regel wird explizit hingewiesen. Jeder Abschnitt enthält eine Anzahl von Kapiteln, welche einen komplexeren Zusammenhang erklären. Die Abschnitte sind in sich abgeschlossen, setzen aber voraus, dass Sie den Stoff der vorherigen Abschnitte verstanden haben. Am Ende jedes Kapitels stehen meistens ein paar Fragen und/oder Aufgaben, die Ihnen helfen sollen zu überprüfen, ob Sie verstanden haben, was im entsprechenden Kapitel stand. Die Antworten auf die Fragen lassen sich einfach ausklappen, für die Aufgaben gibt es je einen Verweis auf eine Seite mit einer Musterlösung. 9

10 Diese Musterlösung ist natürlich nicht die einzige Variante, um die Aufgabe korrekt zu erfüllen, sie dient lediglich als Beispiel, wie Sie es machen könnten. Zu beachten ist allerdings, dass das im Kapitel erworbene Wissen genutzt werden sollte, um die Aufgabe zu erfüllen. „Für Programmieranfänger“ ist der nächste Abschnitt. Wenn Sie schon in einer anderen Programmiersprache Programme geschrieben haben, können Sie diesen Abschnitt getrost überspringen. Es geht nicht speziell um C++, sondern eher darum, zu begreifen, was überhaupt eine Programmiersprache ist und wie man dem Rechner sagen kann, was er zu tun hat. Wenn Sie eine andere Programmiersprache schon sehr sicher beherrschen, reicht es wahrscheinlich, wenn Sie von den nächsten Abschnitten nur die Zusammenfassungen lesen, aber es kann Ihnen in keinem Fall schaden, auch die kompletten Abschnitte zu lesen. Die Zusammenfassungen sollen Ihnen zwar einen groben Überblick geben, was in diesem Abschnitt vermittelt wurde, aber es ist nun einmal nicht möglich, zur gleichen Zeit kurz und vollständig zu sein. Sofern Sie C++ schon sicher beherrschen, können Sie sich einfach ein Kapitel ausgucken, es lesen und wenn nötig, in einem früheren Kapitel nachschlagen. Umsteigern ist dieses Verfahren hingegen nicht zu empfehlen, weil C++ eben doch etwas anderes ist als die meisten anderen Programmiersprachen. In jedem Fall hoffen wir, dass dieses Buch Ihnen hilft, Programmieren zu lernen und Ihre Fähigkeiten zu verbessern, aber vergessen Sie niemals, dass ein Buch nur eine Stütze sein kann. Programmieren lernt man durchs Programmieren!

Kapitel 2 Es war einmal. . . C++ wurde von Bjarne Stroustrup ab 1979 in den AT&T Bell Laboratories entwickelt. Ausgangspunkt waren Untersuchungen des UNIX-Betriebssystemkerns in Bezug auf verteiltes Rechnen. Auf die Idee für eine neue Programmiersprache war Stroustrup schon durch Erfahrungen mit der Programmiersprache Simula im Rahmen seiner Doktorarbeit an der Cambridge University gekommen. Simula erschien zwar geeignet für den Einsatz in großen Software-Projekten, die Struktur der Sprache erschwerte aber die für viele praktische Anwendungen erforderliche Erzeugung hocheffizienter Programme. Demgegenüber ließen sich effiziente Programme zwar mit der Sprache BCPL schreiben, für große Projekte war BCPL aber wiederum ungeeignet. Mit den Erfahrungen aus seiner Doktorarbeit erweiterte Stroustrup nun die Programmiersprache C um ein Klassenkonzept, für das die Sprache Simula-67 das primäre Vorbild war. Die Wahl fiel auf die Programmiersprache C, eine Mehrzwecksprache, die schnellen Code produzierte und einfach auf andere Plattformen zu portieren war. Als dem Betriebssystem UNIX beiliegende Sprache hatte C außerdem eine nicht unerhebliche Verbreitung. Zunächst fügte er der Sprache Klassen (mit Datenkapselung) hinzu, dann abgeleitete Klassen, ein strengeres Typsystem, Inline-Funktionen und Standard-Argumente. Während Stroustrup „C with Classes“ („C mit Klassen“) entwickelte (woraus später C++ wurde), schrieb er auch cfront, einen Compiler, der aus C with Classes zunächst C-Code als Zwischenresultat erzeugte. Die erste kommerzielle Version von cfront erschien im Oktober 1985. 1983 wurde C with Classes in C++ umbenannt. Erweiterungen darin waren: virtuelle Funktionen, Überladen von Funktionsnamen und Operatoren, Referenzen,

11

12 Konstanten, änderbare Freispeicherverwaltung und eine verbesserte Typüberprüfung. Die Möglichkeit von Kommentaren, die an das Zeilenende gebunden sind, wurde wieder aus BCPL übernommen (//). 1985 erschien die erste Version von C++, die eine wichtige Referenzversion darstellte, da die Sprache damals noch nicht standardisiert war. 1989 erschien die Version 2.0 von C++. Neu darin waren Mehrfachvererbung, abstrakte Klassen, statische Elementfunktionen, konstante Elementfunktionen und die Erweiterung des Schutzmodells um protected. 1990 erschien das Buch „The Annotated C++ Reference Manual“, das als Grundlage für den darauffolgenden Standardisierungsprozess diente. Relativ spät wurden der Sprache Templates, Ausnahmen, Namensräume, neuartige Typumwandlungen und boolesche Typen hinzugefügt. Im Zuge der Weiterentwicklung der Sprache C++ entstand auch eine gegenüber C erweiterte Standardbibliothek. Erste Ergänzung war die Stream-I/O-Bibliothek, die Ersatz für traditionelle C-Funktionen wie zum Beispiel printf() und scanf() bietet. Eine der wesentlichen Erweiterungen der Standardbibliothek kam später durch die Integration großer Teile der bei Hewlett-Packard entwickelten Standard Template Library (STL) hinzu. Nach jahrelanger Arbeit wurde schließlich 1998 die endgültige Fassung der Sprache C++ (ISO/IEC 14882:1998) genormt. 2003 wurde ISO/IEC 14882:2003 verabschiedet, eine Nachbesserung der Norm von 1998. Die nächste größere Überarbeitung der Sprache C++ erscheint voraussichtlich im Jahr 2009. Die vorhandenen Performance-Probleme der Sprache C++, die Rechenzeit und Speicherplatz betreffen, werden auf hohem Niveau zusammen mit Lösungen im Technical Report ISO/IEC TR 18015:2006 diskutiert. Das Dokument ist zum Download von ISO freigegeben.

2.1

Der Name „C++“

Der Name ist eine Wortschöpfung von Rick Mascitti und wurde zum ersten Mal im Dezember 1983 benutzt. Der Name kommt von der Verbindung der Vorgängersprache C und dem Inkrement-Operator „++“, der den Wert einer Variable um eins erhöht.

13

2.2

Weiterentwicklung der Programmiersprache C++

Um mit den aktuellen Entwicklungen der sich schnell verändernden ComputerTechnik Schritt zu halten, aber auch zur Ausbesserung bekannter Schwächen, erarbeitet das C++-Standardisierungskomitee derzeit die nächste größere Revision von C++, die inoffiziell mit C++0x abgekürzt wird, worin die Ziffernfolge eine grobe Einschätzung des möglichen Erscheinungstermins andeuten soll. Im November 2006 wurde der Zieltermin für die Fertigstellung auf das Jahr 2009 festgelegt und die Abkürzung C++09 dafür eingeführt. Die vorrangigen Ziele für die Weiterentwicklung von C++ sind Verbesserungen im Hinblick auf die Systemprogrammierung sowie zur Erstellung von Programmbibliotheken. Außerdem soll die Erlernbarkeit der Sprache für Anfänger verbessert werden.

2.3

Berücksichtigung aktueller technischer Gegebenheiten

C++ deckt einige typische Problemfelder der Programmierung noch nicht ausreichend ab, zum Beispiel die Unterstützung von Nebenläufigkeit (Threads), deren Integration in C++, insbesondere für die Verwendung in Mehrprozessorumgebungen, die eine Überarbeitung der Sprache unumgänglich macht. Die hierfür nötige Überarbeitung des C++-Speichermodells soll Garantien der Sprache für den nebenläufigen Betrieb festlegen, um Mehrdeutigkeiten in der Abarbeitungsreihenfolge sowohl aufzulösen, als auch in bestimmten Fällen aufrechtzuerhalten und dadurch Spielraum für Optimierungen zu schaffen.

2.3.1

Verbesserungen am Sprachkern

Zu den weiter reichenden Spracherweiterungen gehören die "Konzepte" (engl. concepts) zur Verbesserung der Handhabung von Templates, Typinferenz zur Ableitung von Ergebnistypen aus Ausdrücken und die R-Wert-Referenzen, mit deren Hilfe sich als Ergänzung zu dem bereits vorhandenen Kopieren von Objekten dann auch ein Verschieben realisieren lässt.

14

2.3.2

Erweiterung der Programmbibliothek

Im April 2006 gab das C++-Standardisierungskomitee den so genannten ersten technischen Report (TR1) heraus, eine nichtnormative Ergänzung zur aktuell gültigen, 1998 definierten Bibliothek, mit der Erweiterungsvorschläge vor einer möglichen Übernahme in die C++-Standardbibliothek auf ihre Praxistauglichkeit hin untersucht werden sollen. Viele Compiler-Hersteller liefern den TR1 mit ihren Produkten aus. Enthalten sind im TR1 u.a. reguläre Ausdrücke, verschiedene intelligente Zeiger, ungeordnete assoziative Container, eine Zufallszahlenbibliothek, Hilfsmittel für die C++-Metaprogrammierung, Tupel sowie numerische und mathematische Bibliotheken. Die meisten dieser Erweiterungen stammen aus der Boost-Bibliothek, woraus sie mit minimalen Änderungen übernommen wurden. Außerdem sind viele Bibliothekserweiterungen der 1999 überarbeiteten Programmiersprache C (C99) in einer an C++ angepassten Form enthalten. Mit Ausnahme der numerischen und mathematischen Bibliotheken wurde die Übernahme aller TR1-Erweiterungen in die kommende Sprachnorm C++0x bereits vom C++-Standardisierungskomitee beschlossen. Ein weiterer Bibliothekszusatz namens TR2, mit Funktionalität für den nebenläufigen Betrieb (Threads), ist in Vorbereitung und soll nach dem kommenden Standard veröffentlicht werden.

Kapitel 3 Compiler Dieses Kapitel ist noch nicht vollständig Kurz: was ist ein Compiler? Präprozessor? Linker?

3.1

Hilfsmittel

1. Compiler Liste (mit Betriebssystem) 2. IDE Liste (mit Betriebssystem und möglichen Compilern)

3.2

Die GCC

GCC steht für Gnu Compiler Collection und ist eine Sammlung von freien Compilern. GCC stellt neben dem C++-Compiler g++, noch viele andere Compiler für verschiedene Sprachen bereit. Der C-Compiler ist etwa gcc und der Java-Compiler heißt gcj. GCC steht unter der GNU General Public License (GNU GPL), das heißt, GCC ist Opensource und jeder ist berechtigt, den Quellcode einzusehen, zu verändern und natürlich auch GCC zu verwenden. Da GCC auf sehr viele Plattformen portiert wurde und unter nahezu allen Betriebssystemen verfügbar ist, eignet er sich prächtig, um ihn in einem Buch wie diesem zu verwenden. Auf fast allen Linux-, Unix- und Unixartigen-Systemen ist GCC schon standardmäßig installiert. Falls nicht, können Sie ihn mit dem Paketmanager Ihrer (Linux15

16 )Distribution nachinstallieren oder ihn von [gcc.gnu.org] herunterladen und manuell installieren. Auf Windows können Sie MinGW (ein Portierung von GCC) verwenden. Sie ist zwar nicht so aktuell wie die originale GCC-Version, aber für den Anfang immer noch ausreichend. Alternativ können Sie GCC auf Windows auch über Cygwin nutzen. Aber jetzt ist Schluss mit der Theorie. Schauen wir uns erst einmal an, wie g++ benutzt wird. Im folgenden wird angenommen, dass eine Datei mit dem Namen prog.cpp vorhanden ist. In dieser Datei könnte zum Beispiel folgendes stehen: #include using namespace std; int main(){ cout "