Artikel werden geladen
Autoren:
Verlag:
Galileo Press Weitere Titel dieses Verlages anzeigen
| Auf einen Blick | ||||||
| 1 | Einstieg in die Programmierung | 15 | ||||
| 2 | Ablaufsteuerung | 71 | ||||
| 3 | Datentypen und -strukturen | 113 | ||||
| 4 | Funktionen | 155 | ||||
| 5 | Klassen | 203 | ||||
| 6 | Programmierwerkzeuge | 271 | ||||
| 7 | Weitere Sprachelemente von C++ | 303 | ||||
| 8 | Bibliotheken | 337 | ||||
| 9 | Die Standard Template Library (STL) | 389 | ||||
| A | C++ für Hektiker | 427 | ||||
| B | Compilereinrichtung | 463 | ||||
| C | Musterlösungen | 473 | ||||
| D | Glossar | 493 | ||||
| E | Literatur | 497 | ||||
| Inhalt | ||||||
| Vorwort | 13 | |||||
| 1 | Einstieg die Programmierung | 15 | ||||
| 1.1 | Programmieren | 15 | ||||
| 1.1.1 | Starteines Programms | 15 | ||||
| 1.1.2 | Eintippen, übersetzen, ausführen | 16 | ||||
| 1.1.3 | Der Algorithmus | 18 | ||||
| 1.1.4 | Die Sprache C++ | 19 | ||||
| 1.1.5 | Fragen zur Selbstkontrolle | 24 | ||||
| 1.2 | Grundgerüst eines Programms | 24 | ||||
| 1.2.1 | Kommentare | 25 | ||||
| 1.2.2 | Anweisungen | 27 | ||||
| 1.2.3 | Blöcke | 27 | ||||
| 1.3 | Variablen | 28 | ||||
| 1.3.1 | Variablendefinition | 29 | ||||
| 1.3.2 | Geltungsbereich | 31 | ||||
| 1.3.3 | Namensregeln und Syntaxgraph | 32 | ||||
| 1.3.4 | Typen | 34 | ||||
| 1.3.5 | Syntax der Variablendefinition | 45 | ||||
| 1.3.6 | Konstanten | 46 | ||||
| 1.4 | Verarbeitung | 56 | ||||
| 1.4.1 | Zuweisung | 56 | ||||
| 1.4.2 | Rechenkünstler | 57 | ||||
| 1.4.3 | Abkürzungen | 59 | ||||
| 1.4.4 | Funktionen am Beispiel der Zufallsfunktion | 61 | ||||
| 1.4.5 | Typumwandlung | 63 | ||||
| 1.5 | Ein- und Ausgabe | 65 | ||||
| 1.5.1 | Ausgabestrom nach cout | 65 | ||||
| 1.5.2 | Formatierte Ausgabe | 67 | ||||
| 1.5.3 | Eingabestrom aus ein | 68 | ||||
| 1.6 | Übungen | 69 | ||||
| 2 | Ablaufsteuerung | 71 | ||||
| 2.1 | Verzweigungen | 72 | ||||
| 2.1.1 | Nur unter einer Bedingung: if | 72 | ||||
| 2.1.2 | Andernfalls: eise | 74 | ||||
| 2.1.3 | Fall für Fall: switch case | 78 | ||||
| 2.1.4 | Kurzabfrage mit dem Fragezeichen | 81 | ||||
| 2.2 | Boolesche Ausdrücke | 83 | ||||
| 2.2.1 | Variablen und Konstanten | 83 | ||||
| 2.2.2 | Operatoren | 83 | ||||
| 2.2.3 | Verknüpfung von booleschen Ausdrücken | 86 | ||||
| 2.3 | Immer diese Wiederholungen: Schleifen | 92 | ||||
| 2.3.1 | Kopfgesteuert: while | 93 | ||||
| 2.3.2 | Fußgesteuert: do... while | 96 | ||||
| 2.3.3 | Abgezählt: for | 97 | ||||
| 2.3.4 | Schleifensprünge: break und continue | 100 | ||||
| 2.3.5 | Der brutale Sprung: goto | 102 | ||||
| 2.4 | Beispiele | 103 | ||||
| 2.4.1 | Primzahlen | 104 | ||||
| 2.4.2 | Größter gemeinsamer Teiler | 109 | ||||
| 2.5 | Übungen | 111 | ||||
| 3 | Datentypen und -strukturen | 113 | ||||
| 3.1 | Das Array | 113 | ||||
| 3.1.1 | Beispiel Bubblesort | 118 | ||||
| 3.1.2 | Zuweisung von Arrays | 122 | ||||
| 3.1.3 | C-Zeichenketten | 123 | ||||
| 3.1.4 | Beispiel: Zahleneingabe auswerten | 124 | ||||
| 3.1.5 | Mehrere Dimensionen | 127 | ||||
| 3.1.6 | Beispiel: Bermuda | 127 | ||||
| 3.2 | Der Zeiger und die Adresse | 130 | ||||
| 3.2.1 | Indirekter Zugriff | 134 | ||||
| 3.2.2 | Arrays und Zeiger | 135 | ||||
| 3.2.3 | Zeigerarithmetik | 137 | ||||
| 3.2.4 | Konstante Zeiger | 139 | ||||
| 3.2.5 | Anonyme Zeiger | 140 | ||||
| 3.3 | Der Variablenverbund: struct | 141 | ||||
| 3.3.1 | Beispiel: Bermuda | 144 | ||||
| 3.4 | Dynamische Strukturen | 146 | ||||
| 3.4.1 | Anlegen und Freigeben von Speicher | 147 | ||||
| 3.4.2 | Zur Laufzeit erzeugte Arrays | 148 | ||||
| 3.4.3 | Verkettete Listen | 149 | ||||
| 3.5 | Die Union | 151 | ||||
| 3.6 | Aufzählungstyp en um | 152 | ||||
| 3.7 | Typen definieren | 153 | ||||
| 4 | Funktionen | 155 | ||||
| 4.1 | Parameter | 160 | ||||
| 4.1.1 | Prototypen | 163 | ||||
| 4.1.2 | Zeiger als Parameter | 164 | ||||
| 4.1.3 | Arrays als Parameter | 166 | ||||
| 4.1.4 | Referenzparameter | 168 | ||||
| 4.1.5 | Beispiel: Stack | 169 | ||||
| 4.1.6 | Vorbelegte Parameter | 171 | ||||
| 4.1.7 | Die Parameter der Funktion main | 172 | ||||
| 4.1.8 | Variable Anzahl von Parametern | 174 | ||||
| 4.2 | Überladen von Funktionen | 176 | ||||
| 4.3 | Kurz und schnell: Inline-Funktionen | 177 | ||||
| 4.4 | Top-Down | 178 | ||||
| 4.4.1 | Beispiel: Bermuda | 179 | ||||
| 4.5 | Geltungsbereich von Variablen | 183 | ||||
| 4.5.1 | Globale Variablen | 184 | ||||
| 4.5.2 | Lokale Variablen | 185 | ||||
| 4.5.3 | Statische Variablen | 186 | ||||
| 4.6 | Selbstaufrufende Funktionen | 188 | ||||
| 4.6.1 | Einsatzbereich | 189 | ||||
| 4.6.2 | Beispiel: binärer Baum | 190 | ||||
| 4.6.3 | Türme von Hanoi | 193 | ||||
| 4.6.4 | Beispiel: Taschenrechner | 196 | ||||
| 4.7 | Funktionszeiger | 201 | ||||
| 5 | Klasssen | 203 | ||||
| 5.1 | Die Klasse als Datenstruktur | 204 | ||||
| 5.1.1 | Funktion und Datenstruktur heiraten | 205 | ||||
| 5.1.2 | Zugriff auf Klassenelemente | 208 | ||||
| 5.2 | Geburt und Tod eines Objekts | 209 | ||||
| 5.2.1 | Konstruktor und Destruktor | 210 | ||||
| 5.2.2 | Konstruktor und Parameter | 212 | ||||
| 5.3 | Öffentlichkeit und Privatsphäre | 214 | ||||
| 5.3.1 | private und public | 215 | ||||
| 5.3.2 | Beispiel: Stack | 218 | ||||
| 5.3.3 | Freunde | 220 | ||||
| 5.4 | Kopierkonstruktor | 221 | ||||
| 5.5 | Überladen von Elementfunktionen | 225 | ||||
| 5.6 | Kür: Überladen von Operatoren | 226 | ||||
| 5.6.1 | Addition | 227 | ||||
| 5.6.2 | Globale Operatorfunktionen | 229 | ||||
| 5.6.3 | Inkrementieren und Dekrementieren | 230 | ||||
| 5.6.4 | Der Zuweisungsoperator | 232 | ||||
| 5.6.5 | Die Vergleichsoperatoren | 235 | ||||
| 5.6.6 | Der Ausgabeoperator | 237 | ||||
| 5.6.7 | Der Indexoperator | 238 | ||||
| 5.6.8 | Der Aufrufoperator () | 240 | ||||
| 5.6.9 | Der Konvertierungsoperator | 241 | ||||
| 5.7 | Attribute | 242 | ||||
| 5.7.1 | Statische Variablen und Funktionen in Klassen | 242 | ||||
| 5.7.2 | Konstanten | 244 | ||||
| 5.8 | Vererbung | 246 | ||||
| 5.8.1 | Zugriff auf die Vorfahren | 251 | ||||
| 5.8.2 | Konstruktoren und Zuweisung | 255 | ||||
| 5.8.3 | Mehrfachvererbung | 257 | ||||
| 5.8.4 | Polymorphie durch virtuelle Funktionen | 257 | ||||
| 5.9 | Klassendefinition und Syntaxgraph | 267 | ||||
| 6 | Programmierwerkzeuge | 271 | ||||
| 6.1 | Der C++-Compiler | 271 | ||||
| 6.1.1 | Compiler-Aufruf | 271 | ||||
| 6.1.2 | Compiler-Optionen | 272 | ||||
| 6.1.3 | Fehlermeldungen | 273 | ||||
| 6.2 | Präprozessor | 276 | ||||
| 6.2.1 | Einbinden von Dateien: #include | 276 | ||||
| 6.2.2 | Konstanten und Makros: #define | 276 | ||||
| 6.2.3 | Abfragen: #if | 279 | ||||
| 6.2.4 | Vordefinierte Makros | 280 | ||||
| 6.2.5 | Weitere Präprozessorbefehle | 281 | ||||
| 6.3 | Aufteilung der Quelltexte | 282 | ||||
| 6.3.1 | Beispiel Bermuda | 282 | ||||
| 6.3.2 | Dateikennungen | 285 | ||||
| 6.3.3 | Deklaration und Definition | 286 | ||||
| 6.3.4 | Header-Dateien | 287 | ||||
| 6.3.5 | Statische Funktionen | 288 | ||||
| 6.3.6 | Verborgene Implementierung | 289 | ||||
| 6.4 | Linker und Bibliotheken | 291 | ||||
| 6.4.1 | Einbinden von statischen Bibliotheken | 291 | ||||
| 6.4.2 | Dynamische Bibliotheken | 292 | ||||
| 6.5 | make | 295 | ||||
| 6.5.1 | Makros im Makefile | 298 | ||||
| 6.5.2 | Mehrere Ziele | 299 | ||||
| 6.6 | Debuggen mit dem gdb | 300 | ||||
| 7 | Weitere Sprachelemente von-C++ | 303 | ||||
| 7.1 | Generische Programmierung | 303 | ||||
| 7.1.1 | Template-Funktionen | 304 | ||||
| 7.1.2 | Template-Klassen | 307 | ||||
| 7.1.3 | Makro-Programmierung mit #define | 310 | ||||
| 7.2 | Namensräume | 312 | ||||
| 7.2.1 | Definition eines Namensraums | 313 | ||||
| 7.2.2 | Zugriff | 314 | ||||
| 7.2.3 | Besondere Namensräume | 314 | ||||
| 7.2.4 | Anonyme Namensräume | 315 | ||||
| 7.2.5 | Syntaxgraph | 316 | ||||
| 7.3 | Katastrophenschutz mit try und catch | 316 | ||||
| 7.3.1 | Eigene Ausnahmen erzeugen | 318 | ||||
| 7.3.2 | Erstellen von Fehlerklassen | 321 | ||||
| 7.3.3 | Die Ausnahmen der Standardbibliotheken | 324 | ||||
| 7.4 | Systemnahe Programmierung | 330 | ||||
| 7.4.1 | Bit-Operatoren | 330 | ||||
| 7.4.2 | Shift-Operatoren | 333 | ||||
| 7.4.3 | Zugriff auf Hardware-Adressen | 334 | ||||
| 7.4.4 | Bit-Strukturen | 334 | ||||
| 8 | Bibliotheken | 337 | ||||
| 8.1 | Zeichenketten und Strings | 337 | ||||
| 8.1.1 | Die Standardklasse string | 338 | ||||
| 8.1.2 | Andere String-Bibliotheken | 350 | ||||
| 8.1.3 | Klassische C-Funktionen | 351 | ||||
| 8.2 | iostream für Fortgeschrittene | 358 | ||||
| 8.2.1 | Eingabe über ein | 358 | ||||
| 8.2.2 | Manipulatoren | 359 | ||||
| 8.3 | Dateioperationen | 363 | ||||
| 8.3.1 | Öffnen und Schließen | 364 | ||||
| 8.3.2 | Lesen und Schreiben | 366 | ||||
| 8.3.3 | Zustandsbeobachtung | 371 | ||||
| 8.3.4 | Dateizugriffe nach ANSI-C | 373 | ||||
| 8.3.5 | Dateisystemkommandos | 376 | ||||
| 8.3.6 | Dateieigenschaften ermitteln | 378 | ||||
| 8.4 | Mathematische Funktionen | 381 | ||||
| 8.4.1 | Die mathematische Standardbibliothek | 382 | ||||
| 8.4.2 | Komplexe Zahlen | 384 | ||||
| 8.5 | Zeitfunktionen | 385 | ||||
| 8.5.1 | Datum und Uhrzeit | 385 | ||||
| 8.5.2 | Zeit stoppen | 387 | ||||
| 9 | Die Standard Template Library (STL) | 389 | ||||
| 9.1 | Die Container-Klasse vector | 389 | ||||
| 9.1.1 | Dimensionsänderung | 391 | ||||
| 9.1.2 | Iteratoren | 393 | ||||
| 9.1.3 | Weitere Funktionen | 394 | ||||
| 9.2 | Die Container-Klasse deque | 396 | ||||
| 9.3 | Die Container-Klasse list | 399 | ||||
| 9.3.1 | Einfügen und Löschen | 400 | ||||
| 9.3.2 | Umhängen von Elementen: splice | 402 | ||||
| 9.3.3 | Mischen sortierter Listen | 403 | ||||
| 9.3.4 | Sortierung und Reihenfolge | 403 | ||||
| 9.4 | Die Container-Klassen set und multiset | 405 | ||||
| 9.4.1 | Einfügen und Löschen | 405 | ||||
| 9.4.2 | Suchen und Sortieren | 406 | ||||
| 9.5 | Die Container-Klassen map und multimap | 408 | ||||
| 9.6 | Container-Adapter | 410 | ||||
| 9.6.1 | Der Container-Adapter stack | 411 | ||||
| 9.6.2 | Der Container-Adapter queue | 412 | ||||
| 9.6.3 | Der Container-Adapter priority_queue | 413 | ||||
| 9.7 | Iteratortypen | 414 | ||||
| 9.8 | Die Algorithmen der STL | 414 | ||||
| 9.8.1 | Suchen: find-O | 415 | ||||
| 9.8.2 | Sortieren | 416 | ||||
| 9.8.3 | Binäres Suchen | 417 | ||||
| 9.8.4 | Kopieren: copy() | 418 | ||||
| 9.8.5 | Umdrehen: reverse() | 418 | ||||
| 9.8.6 | Füllen: fill-O | 419 | ||||
| 9.8.7 | equal-O | 419 | ||||
| 9.8.8 | Funktion als Parameter: findjf-O | 419 | ||||
| 9.8.9 | for_each | 423 | ||||
| 9.9 | Die Template-Klasse bitset | 423 | ||||
| Anhang | 425 | |||||
| A | A C++ für Hektiker | 427 | ||||
| A.1 | Ein Programm | 427 | ||||
| A.2 | Abfrage und Schleifen | 432 | ||||
| A.2.1 | Abfrage und boolesche Ausdrücke | 432 | ||||
| A.2.2 | Die while-Schleife | 434 | ||||
| A.2.3 | Die for-Schleife | 435 | ||||
| A.3 | Arrays | 436 | ||||
| A.4 | Funktionen | 440 | ||||
| A.4.1 | Programmaufteilung | 440 | ||||
| A.4.2 | Rückgabewert | 443 | ||||
| A.4.3 | Parameter | 445 | ||||
| A.5 | Klassen | 448 | ||||
| A.5.1 | Konstruktor | 452 | ||||
| A.5.2 | Vererbung | 456 | ||||
| A.5.3 | Polymorphie | 458 | ||||
| A.6 | Templates | 460 | ||||
| B | Compilereinrichtung | 463 | ||||
| B.1 | KDevelop | 463 | ||||
| B.1.1 | Neues Projekt | 463 | ||||
| B.1.2 | Kompilieren und starten | 465 | ||||
| B.2 | Bloodshed Dev-C++ (CD) | 466 | ||||
| B.2.1 | Installation | 466 | ||||
| B.2.2 | Ein Projekt anlegen | 467 | ||||
| B.2.3 | Übersetzen und starten | 469 | ||||
| B.3 | CygWin | 471 | ||||
| C | Musterlösungen | 473 | ||||
| D | Glossar | 493 | ||||
| E | Literatur | 497 | ||||
| Index | 499 | |||||
Vorwort
Ja, ich weiß, es gibt schon das eine oder andere Buch über C++. Allerdings kann ein Buch über C++ mit vielen Intentionen geschrieben worden sein. Da gibt es das Buch »Die C++ Programmiersprache« von Bjarne Stroustrup, dem Erfinder von C++ - ein sehr exaktes, sehr umfassendes Buch.1 Es stellt den Maßstab für alle Compiler-Bauer dar. Aber für den Anfänger ist es leider nicht gedacht.
Mein Anspruch an dieses Buch ist, dass es leicht verständlich ist. Wenn ein Anfänger C++ lernen will, sollte er mit anschaulichen Beispielen an C++ herangeführt werden. Und wenn aus dem Anfänger ein Fortgeschrittener geworden ist, sollte er die meisten Fragen, die mit dem Handwerkszeug C++ zu tun haben, auch in diesem Buch beantwortet finden. Ich mag Bücher nicht, die bei der Hälfte aufhören.
Ich setze voraus, dass Sie wissen, was ein Computer ist, dass Sie damit grundlegend umgehen können, Lust haben, sich auf das Programmieren einzulassen, und natürlich lesen können. Ich gehe nicht davon aus, dass Sie bereits irgendeine Programmiersprache beherrschen.
Zum leichteren Verständnis der Sprachkonstrukte habe ich Syntaxgrafen verwendet. Diese sind in den letzten Jahren bedauerlicherweise aus der Mode gekommen. In der aktuellen Literatur sind sie jedenfalls kaum zu finden. Dennoch halte ich sie wegen ihrer Anschaulichkeit für eine wertvolle Hilfe, insbesondere für den Anfänger.
Auch die Nassi-Schneidermann-Diagramme habe ich wieder aufleben lassen, weil ich denke, dass sie besonders in Kapitel 2, »Ablaufsteuerung«, ein Gefühl für sauber strukturierte Abläufe vermitteln.
Sie finden im Anhang einen Schnelleinstieg in C++. Er ist für Leute gedacht, die etwas ungeduldig, gern schnell zu Ergebnissen kommen möchten. Er könnte auch als Basis-Skript für C++-Kurse dienen, die ja auch nicht jedes Detail berücksichtigen können. Da in diesem Kapitel manches sehr knapp behandelt wird, wird immer wieder auf die Stellen im Buch verwiesen, die ein Thema ausführlicher behandeln.
Sie finden bei vielen Listings hinter der Überschrift in Klammern einen Dateinamen. Dann befindet sich das Listing unter diesem Namen auf der beiliegenden CD.
Zur besseren Lesbarkeit sind folgende Konventionen eingeführt worden: Schlüsselwörter werden in nichtproportionaler Schrift gesetzt. Variablen und Klassen erscheinen in fetter Schrift. Funktionsaufrufe wie open( ) sind grundsätzlich mit Klammern dargestellt.
Ich arbeite als C++-Programmierer. Aus diesem Grund behält dieses Buch immer einen Bezug zur Praxis. Dabei hilft es auch sehr, dass immer wieder Leser auf Unklarheiten hinweisen oder sogar Fehler finden. Zum Glück werden es von Auflage zu Auflage immer weniger.
Neben meinen Lesern möchte ich auch meinem Lektor Stephan Mattescheck danken. Er und der Verlag Galileo Computing ließen mir weitestgehende Freiheiten. Friederike Daenecke bereinigte meine schlimmsten Verbrechen gegen die deutsche Sprache. Steffi Ehrentraut sorgte für das gute Aussehen des Buches. Christoph Kecher hat sich vor allem um die zweite Auflage verdient gemacht. Ansonsten bleibt mir noch zu erwähnen, dass ich durch Prof. Dr. Mario Dal Cin zum ersten Mal mit C++ in Berührung kam. Er machte mir viel Mut für dieses Buch. Ich danke auch Stephan Engelmann für seine Hinweise. Und vielen Dank an die vielen Käufer dieses Buches. Immerhin ist es in erster Linie ihnen zu verdanken, dass es eine vierte Auflage gibt.
Ich hoffe nun, dass das Buch Ihnen bei Ihren ersten Schritten zu C++ ein guter Begleiter ist und Ihnen später ein auskunftsfreudiges Nachschlagewerk wird.
Norgaardholz Arnold Willemer
Einstieg in C++
Galileo Computing
Als Leser dieses Buches finden Sie auf unserer Website zusätzliche Informationsangebote zum Themengebiet des Buches. Noch Fragen? Unser Autor steht Ihnen mit Rat und Tat zur Seite unter www.galileocomputing.de
Wenn Sie einen leichten Einstieg in C++ suchen, liegen Sie mit diesem Buch von Arnold Willemer richtig. Es hat sich seit vielen Jahren bewährt in Schulungen, in der Lehre und im Selbststudium. Sie müssen es auch dann nicht aus der Hand legen, wenn es schwierig wird. Dieser Einstieg in die Programmiersprache C++ begleitet Sie von Anfang an - auch bei professionellen Themen wie Vererbung, Objektorientierung, Polymorphie, Exceptions und Templates. Ebenso werden Sie umfassend und kompetent in den Umgang mit der Standard Template Library eingeführt. Damit erhalten Sie einen vollständigen Überblick, der Sie von A bis Z auf Ihrem Weg zum professionellen Programmierer begleiten wird. Praxisnahe Beispiele und Übungen bringen Ihnen auf anschauliche Weise die Programmierung mit C++ nah. Kenntnisse in C oder einer anderen Sprache werden nicht vorausgesetzt.
1 Lernen Sie die Grundlagen von C++
Variablen, Verzweigungen, boolesche Ausdrücke, Arrays, Funktionen und Klassen. Sie erhalten eine umfassende Einführung, die sich auch als Nachschlagewerk nutzen lässt.
2 Steigen Sie Schritt für Schritt in die Programmierung ein
Praxisnahe Beispiele und Übungen begleiten Sie auf Ihren ersten Schritten.
3 Einführung in die Objektorientierung
Sie erfahren alles Wissenswerte zur objektorientierten Programmierung - praxisorientiert und vollständig.
4 Unterstützung auch bei professionellen Themen
Unser Buch lässt Sie auch bei anspruchsvollen Themen wie generischer Programmierung, Namensräumen oder systemnaher Programmierung nicht allein.
5 Nutzen Sie die C++-Bibliotheken - inkl. STL
Lernen Sie, wie Sie mit den mitgelieferten Bibliotheken umgehen und diese für Ihre Programme nutzen können.
6 Damit Sie sofort loslegen können
Auf der CD-ROM finden Sie Compiler, Entwicklungsumgebungen und Beispiellistings - damit Sie sofort starten können.
Inhalt der CD-ROM
Compiler
Entwicklungsumgebungen
ISBN 978-3-8362-1385-1
Der Autor
Diplom-Informatiker Arnold Willemer studierte in Frankfurt am Main Informatik mit den Schwerpunkten Betriebssysteme, Netzwerke und systemnahe Programmierung. Bei Galileo Press hat er bereits ein erfolgreiches UNIX-Handbuch veröffentlicht.