C++ programmieren lernen für Dummies

Über den Autor 9
<p>Widmung 10</p>
<p>Einf&uuml;hrung 23</p>
<p>&Uuml;ber dieses Buch 23</p>
<p>T&ouml;richte Annahmen &uuml;ber den Leser 24</p>
<p>Wie dieses Buch organisiert ist 25</p>
<p>Teil I: Programmieren in C++ die ersten Schritte 25</p>
<p>Teil II: Ein Programm schreiben: Entscheidungen, Entscheidungen 25</p>
<p>Teil III: Prozedural programmieren 25</p>
<p>Teil IV: Datenstrukturen 25</p>
<p>Teil V: Objektorientierte Programmierung 26</p>
<p>Teil VI: F&uuml;r Fortgeschrittene 26</p>
<p>Teil VII: Der Top–Ten–Teil 26</p>
<p>Symbole in diesem Buch 26</p>
<p>Wie es weitergeht 27</p>
<p>Teil I Programmieren in C++ die ersten Schritte 29</p>
<p>Kapitel 1 Was ist ein Programm? 31</p>
<p>Worin unterscheidet sich mein Sohn von einem Computer? 31</p>
<p>Einen &raquo;menschlichen Computer&laquo; programmieren 33</p>
<p>Den Algorithmus erstellen 33</p>
<p>Die Entwicklung der Reifenwechsel–Sprache 34</p>
<p>Das Programm erstellen 34</p>
<p>Computerprozessoren 38</p>
<p>Computersprachen 38</p>
<p>H&ouml;here Sprachen 40</p>
<p>Die Sprache C++ 40</p>
<p>Kapitel 2 Code::Blocks installieren 43</p>
<p>Der Kompilierungsvorgang 43</p>
<p>Code::Blocks installieren 45</p>
<p>Installation unter Windows 45</p>
<p>Installation unter Ubuntu Linux 48</p>
<p>Installation unter Mac OS 50</p>
<p>Code::Blocks einrichten 54</p>
<p>Die Code::Blocks–Installation testen 57</p>
<p>Das Projekt anlegen 57</p>
<p>Ihr Standardprojekt testen 62</p>
<p>Kapitel 3 Ihr erstes Programm 65</p>
<p>Ein neues Projekt anlegen 65</p>
<p>Dateinamenerweiterungen 67</p>
<p>Die Eingabe Ihres Programms 69</p>
<p>Das Programm erstellen 71</p>
<p>Was alles schiefgehen kann 71</p>
<p>Falsch geschriebene Befehle 71</p>
<p>Fehlendes Semikolon 73</p>
<p>Die Beispieldateien verwenden 74</p>
<p>Das Programm ausf&uuml;hren 75</p>
<p>Wie das Programm funktioniert 75</p>
<p>Die Vorlage 76</p>
<p>Das Conversion–Programm 77</p>
<p>Teil II Ein Programm schreiben: Entscheidungen, Entscheidungen 79</p>
<p>Kapitel 4 Integer–Ausdr&uuml;cke f&uuml;r ganze Zahlen 81</p>
<p>Variablen deklarieren 81</p>
<p>Variablennamen 82</p>
<p>Einer Variablen einen Wert zuweisen 83</p>
<p>Eine Variable bei der Deklaration initialisieren 83</p>
<p>Ganzzahlige Konstanten 84</p>
<p>Ausdr&uuml;cke 85</p>
<p>Bin&auml;re Operatoren 86</p>
<p>Zusammengesetzte Ausdr&uuml;cke aufl&ouml;sen 87</p>
<p>Un&auml;re Operatoren 88</p>
<p>Die speziellen Zuweisungsoperatoren 90</p>
<p>Kapitel 5 Zeichenausdr&uuml;cke 93</p>
<p>Character–Variablen definieren 93</p>
<p>Zeichen codieren 93</p>
<p>Beispiel f&uuml;r die Zeichencodierung 96</p>
<p>Zeichenketten codieren 98</p>
<p>Sonderzeichen–Konstanten 98</p>
<p>Kapitel 6 Entscheidungen, Entscheidungen! 101</p>
<p>Die if–Anweisung 101</p>
<p>Vergleichsoperatoren 102</p>
<p>Geschweifte Klammern sind kein Luxus 104</p>
<p>Und andernfalls? 106</p>
<p>Verschachtelte if–Anweisungen 108</p>
<p>Zusammengesetzte bedingte Ausdr&uuml;cke 111</p>
<p>Kapitel 7 Ausf&uuml;hrungspfade wechseln 113</p>
<p>Mit der switch–Anweisung den Programmablauf steuern 113</p>
<p>Durchgerasselt: Habe ich es kaputtgemacht? 116</p>
<p>Implementierung eines einfachen Taschenrechners mit der switch–Anweisung 117</p>
<p>Kapitel 8 Programme debuggen, Teil I 121</p>
<p>Fehlertypen identifizieren 121</p>
<p>Fehler vermeiden 122</p>
<p>Codieren mit Stil 122</p>
<p>Namenskonventionen f&uuml;r Variablen festlegen 123</p>
<p>Den ersten Fehler finden mit ein bisschen Unterst&uuml;tzung 124</p>
<p>Den Laufzeitfehler finden 125</p>
<p>Testdaten formulieren 125</p>
<p>Tests durchf&uuml;hren 126</p>
<p>Sehen wir nach, was das Programm macht 126</p>
<p>Teil III Prozedural programmieren 129</p>
<p>Kapitel 9 while ein ewiger Kreislauf 131</p>
<p>while–Schleifen 131</p>
<p>Aus einer Schleife ausbrechen 134</p>
<p>Verschachtelte Schleifen 137</p>
<p>Kapitel 10 Weiter mit for–Schleifen 143</p>
<p>Die vier Teile jeder Schleife 143</p>
<p>Wir betrachten ein Beispiel 145</p>
<p>Mit dem Komma–Operator mehr erledigen 146</p>
<p>Kapitel 11 Funktionen 151</p>
<p>Aufgaben in Funktionen zerlegen 151</p>
<p>Die Arbeitsweise von Funktionen verstehen 152</p>
<p>Eine Funktion schreiben und verwenden 153</p>
<p>Dinge zur&uuml;ckgeben 154</p>
<p>Ein Beispiel 155</p>
<p>An Funktionen Argumente &uuml;bergeben 158</p>
<p>Funktion mit Argumenten 158</p>
<p>Funktionen mit mehreren Argumenten 160</p>
<p>main() 161</p>
<p>Funktionsprototyp–Deklarationen definieren 161</p>
<p>Kapitel 12 Programme in Module unterteilen 165</p>
<p>Programme aufsplitten 165</p>
<p>Teilen ist gar nicht so schwer 166</p>
<p>Factorial.cpp erstellen 166</p>
<p>Eine #include–Datei erstellen 169</p>
<p>#include–Dateien einbinden 171</p>
<p>main.cpp erstellen 172</p>
<p>Das Ergebnis erstellen 174</p>
<p>Verwendung der C++–Standardbibliothek 174</p>
<p>G&uuml;ltigkeitsbereiche von Variablen 175</p>
<p>Kapitel 13 Programme debuggen, Teil 2 177</p>
<p>Debugging eines Programms mit Rechenschw&auml;che 177</p>
<p>Einheitentests durchf&uuml;hren 179</p>
<p>Eine Funktion f&uuml;r Tests ausstatten 180</p>
<p>Zur&uuml;ck zum Einheitentest 184</p>
<p>Teil IV Datenstrukturen 187</p>
<p>Kapitel 14 Andere numerische Variablentypen 189</p>
<p>Die Grenzen von Integern in C++ 189</p>
<p>Integer–Abrundung 189</p>
<p>Begrenzter Wertebereich 190</p>
<p>Ein &raquo;doppelter&laquo; Typ f&uuml;r reelle Zahlen 191</p>
<p>Eine L&ouml;sung f&uuml;r das Abrundungsproblem 191</p>
<p>Wenn ein Integer kein Integer ist 192</p>
<p>Die Grenzen eines double erkennen 193</p>
<p>Variablengr&ouml;&szlig;e die lange und die kurze Form 195</p>
<p>Wie weit reichen Zahlen? 197</p>
<p>Konstantentypen 198</p>
<p>Funktionen unterschiedliche Typen &uuml;bergeben 199</p>
<p>Funktionsnamen &uuml;berladen 199</p>
<p>Gemischtes &Uuml;berladen 200</p>
<p>Kapitel 15 Arrays 203</p>
<p>Was ist ein Array? 203</p>
<p>Ein Array deklarieren 204</p>
<p>Array–Elemente &uuml;ber einen Index ansprechen 204</p>
<p>Ein Beispiel 206</p>
<p>Ein Array initialisieren 208</p>
<p>Kapitel 16 Arrays mit Charakter 211</p>
<p>Das ASCII–Zero–Character–Array 211</p>
<p>Ein ASCIIZ–Array deklarieren und initialisieren 212</p>
<p>Ein Beispiel 213</p>
<p>Ein detaillierteres Beispiel 215</p>
<p>Hackerabwehr 218</p>
<p>Muss ich das wirklich alles machen? 220</p>
<p>Kapitel 17 Zeiger in C++ 223</p>
<p>Was ist ein Zeiger? 223</p>
<p>Einen Zeiger deklarieren 224</p>
<p>Einer Funktion Argumente &uuml;bergeben 226</p>
<p>Argumente als Wert &uuml;bergeben 226</p>
<p>Argumente als Referenz &uuml;bergeben 229</p>
<p>Das gro&szlig;e Ganze 231</p>
<p>Typen von Referenzargumenten 233</p>
<p>Speicherstapel 233</p>
<p>Brauchen Sie wirklich ein neues Schl&uuml;sselwort? 234</p>
<p>Vergessen Sie nicht, zum Schluss wieder aufzur&auml;umen! 235</p>
<p>Ein Beispiel 236</p>
<p>Kapitel 18 C++–Zeiger auf den zweiten Blick 239</p>
<p>Zeiger und Arrays 239</p>
<p>Operationen f&uuml;r Zeiger 239</p>
<p>Zeiger–Addition im Vergleich zur Indizierung eines Arrays 242</p>
<p>Der Inkrementoperator f&uuml;r Zeiger 244</p>
<p>Warum plagen wir uns mit Array–Zeigern? 247</p>
<p>Operationen f&uuml;r verschiedene Zeigertypen 248</p>
<p>Die Sache mit den Konstanten 248</p>
<p>Unterschiede zwischen Zeigern und Arrays 249</p>
<p>Meine Argumente von main() 250</p>
<p>Zeigerarrays 250</p>
<p>Arrays mit Argumenten 251</p>
<p>Kapitel 19 Programmieren mit Klasse 259</p>
<p>Daten gruppieren 259</p>
<p>Die Klasse 260</p>
<p>Das Objekt 261</p>
<p>Arrays von Objekten 262</p>
<p>Ein Beispiel 263</p>
<p>Kapitel 20 Programme debuggen, Teil 3 271</p>
<p>Ein neuer Ansatz f&uuml;r das Debugging 271</p>
<p>Die L&ouml;sung 272</p>
<p>Debuggen Schritt f&uuml;r Schritt 272</p>
<p>Den Debugger starten 275</p>
<p>Navigation durch ein Programm mit dem Debugger 278</p>
<p>Den (ersten) Fehler korrigieren 282</p>
<p>Den zweiten Fehler finden und korrigieren 284</p>
<p>Teil V Objektorientierte Programmierung 287</p>
<p>Kapitel 21 Was ist objektorientierte Programmierung? 289</p>
<p>Abstraktion und Mikrowellen&ouml;fen 289</p>
<p>Prozedurale Nachos 290</p>
<p>Objektorientierte Nachos 291</p>
<p>Klassifizierung und Mikrowellen&ouml;fen 291</p>
<p>Warum sollten wir Objekte auf diese Weise aufbauen? 292</p>
<p>Abgeschlossene Klassen 293</p>
<p>Kapitel 22 Strukturiertes Spiel: Wie Klassen Dinge erledigen 295</p>
<p>Unsere Objekte aktivieren 295</p>
<p>Eine Elementfunktion erstellen 296</p>
<p>Eine Elementfunktion definieren 297</p>
<p>Namen f&uuml;r Klassenelemente 298</p>
<p>Aufruf einer Elementfunktion 299</p>
<p>Zugriff auf andere Elemente von einer Elementfunktion aus 300</p>
<p>Eine Elementfunktion hinter der Klasse halten 301</p>
<p>Elementfunktionen &uuml;berladen 302</p>
<p>Kapitel 23 Zeiger auf Objekte 305</p>
<p>Zeiger auf Objekte 305</p>
<p>Pfeilsyntax 306</p>
<p>Aufruf aller Elementfunktionen 306</p>
<p>Funktionen Objekte &uuml;bergeben 307</p>
<p>Aufruf einer Funktion mit einem Objektwert 307</p>
<p>Aufruf einer Funktion mit einem Objektzeiger 309</p>
<p>Ein Beispiel 310</p>
<p>Objekte auf dem Stapel reservieren 314</p>
<p>Kapitel 24 Bitte nicht st&ouml;ren: Gesch&uuml;tzte Elemente 317</p>
<p>Elemente sch&uuml;tzen 317</p>
<p>Warum Sie gesch&uuml;tzte Elemente brauchen 317</p>
<p>Elemente sch&uuml;tzen 318</p>
<p>Also? 321</p>
<p>Ein Freund, ein guter Freund . . . 322</p>
<p>Kapitel 25 Objekten einen guten Start verschaffen 325</p>
<p>Der Konstruktor 325</p>
<p>Einschr&auml;nkungen von Konstruktoren 327</p>
<p>Kann ich ein Beispiel sehen? 327</p>
<p>Datenelemente konstruieren 330</p>
<p>Destruktoren 333</p>
<p>Ein Beispiel 334</p>
<p>Datenelemente zerst&ouml;ren 337</p>
<p>Kapitel 26 Konstruktive Argumente 341</p>
<p>Konstruktoren mit Argumenten 341</p>
<p>Ein Beispiel 342</p>
<p>Den Konstruktor &uuml;berladen 346</p>
<p>Der Standard–Standardkonstruktor 350</p>
<p>Datenelemente konstruieren 352</p>
<p>Datenelemente mit dem Standardkonstruktor initialisieren 352</p>
<p>Datenelemente mit einem anderen Konstruktor initialisieren 354</p>
<p>Ein Beispiel 357</p>
<p>Neu in C++ 2011 360</p>
<p>Kapitel 27 Kopieren mit dem Copy–Konstruktor 361</p>
<p>Ein Objekt kopieren 361</p>
<p>Der Standard–Copy–Konstruktor 362</p>
<p>Ein Beispiel 363</p>
<p>Einen Copy–Konstruktor erstellen 366</p>
<p>Kopien vermeiden 369</p>
<p>Teil VI F&uuml;r Fortgeschrittene 371</p>
<p>Kapitel 28 Eine Klasse vererben 373</p>
<p>Vorteile der Vererbung 373</p>
<p>Die Sprachbesonderheiten 374</p>
<p>Vererbung in C++ implementieren 375</p>
<p>Ein Beispiel 376</p>
<p>Eine HAT—EIN–Beziehung 380</p>
<p>Kapitel 29 Virtuelle Funktionen Realit&auml;t? 383</p>
<p>Elementfunktionen &uuml;berschreiben 383</p>
<p>Fr&uuml;hes Binden 384</p>
<p>Mehrdeutiger Fall 386</p>
<p>Eine sp&auml;te Bindung eingehen 388</p>
<p>Wann nicht virtuell? 391</p>
<p>Virtuelle Aspekte 393</p>
<p>Kapitel 30 Zuweisungsoperatoren &uuml;berladen 397</p>
<p>Einen Operator &uuml;berladen 397</p>
<p>Das &Uuml;berladen des Zuweisungsoperators ist kritisch 398</p>
<p>Ein Beispiel 400</p>
<p>Ihren Eigenen schreiben (oder nicht) 403</p>
<p>Kapitel 31 Stream–I/O 405</p>
<p>Wie Stream–I/O funktioniert 405</p>
<p>Stream–Eingabe/Ausgabe 407</p>
<p>Ein Eingabe–Objekt erstellen 407</p>
<p>Ein Ausgabe–Objekt erstellen 408</p>
<p>&Ouml;ffnen–Modi 409</p>
<p>Was ist der Bin&auml;rmodus? 410</p>
<p>Und in welchem Status ist eine Datei? 410</p>
<p>Weitere Elementfunktionen der fstream–Klassen 415</p>
<p>Streams direkt lesen und schreiben 415</p>
<p>Formatsteuerung 419</p>
<p>Und was macht eigentlich endl? 422</p>
<p>Manipulatoren manipulieren 422</p>
<p>Die stringstream–Klassen 423</p>
<p>Kapitel 32 Machen wir eine Ausnahme! 429</p>
<p>Der Ausnahmemechanismus 429</p>
<p>Betrachten wir den Ausnahmemechanismus im Detail! 432</p>
<p>Spezielle Aspekte f&uuml;r das Aufwerfen von Ausnahmen 433</p>
<p>Eine benutzerdefinierte Ausnahmeklasse erstellen 433</p>
<p>Einschr&auml;nkungen von Ausnahmeklassen 437</p>
<p>Teil VII Der Top–Ten–Teil 439</p>
<p>Kapitel 33 Zehn Methoden, Fehler zu vermeiden 441</p>
<p>Aktivieren Sie alle Warnungen und Fehlermeldungen! 441</p>
<p>Gew&ouml;hnen Sie sich einen klaren und konsistenten Programmierstil an! 442</p>
<p>Kommentieren Sie den Code, w&auml;hrend Sie ihn schreiben! 442</p>
<p>Durchlaufen Sie jeden Pfad mindestens einmal im Einzelschrittmodus im Debugger! 443</p>
<p>Begrenzen Sie die Sichtbarkeit! 443</p>
<p>Verwalten Sie Ihren Stapel! 444</p>
<p>&Uuml;berschreiben Sie Zeiger mit 0, nachdem Sie gel&ouml;scht haben, worauf sie zeigen! 444</p>
<p>Verarbeiten Sie Fehler mit Ausnahmen! 445</p>
<p>Deklarieren Sie Destruktoren als virtuell! 445</p>
<p>Stellen Sie einen Copy–Konstruktor und einen &uuml;berladenen Zuweisungsoperator bereit! 445</p>
<p>Kapitel 34 Zehn Dinge, die in diesem Buch nicht abgedeckt sind 447</p>
<p>Der goto–Befehl 447</p>
<p>Der tern&auml;re Operator 448</p>
<p>Bin&auml;re Logik 448</p>
<p>Aufz&auml;hlungstypen 448</p>
<p>Namensr&auml;ume 449</p>
<p>Rein virtuelle Funktionen 449</p>
<p>Die string–Klasse 450</p>
<p>Mehrfachvererbung 450</p>
<p>Templates und die Standard Template Library 450</p>
<p>Lambda–Funktionen 451</p>
<p>Stichwortverzeichnis 453</p>