C++

eine Einführung
 
 
Hanser (Verlag)
  • 1. Auflage
  • |
  • erschienen am 6. Juni 2016
  • |
  • 398 Seiten
 
E-Book | PDF mit Wasserzeichen-DRM | Systemvoraussetzungen
978-3-446-44912-1 (ISBN)
 
In diesem Buch finden Sie alles, was Sie für den Einstieg brauchen - im praktischen Taschenbuchformat! Die vielen Beispiele sind leicht nachzuvollziehen. Dabei werden die seit C++11 und C++14 verfügbaren neuen Möglichkeiten genutzt. Die Beispiele sind zum großen Teil Spiele. So lernen Sie nicht nur die objektorientierte Programmierung kennen, sondern auch den ersten Umgang mit Mausklicks und Grafik, obwohl Grafik kein Bestandteil des C++-Standards ist. Das ist für diejenigen, die keine Spiele programmieren wollen, kein Nachteil. Spiele sind als realistische Anwendungen von C++ einfach interessanter als beliebige andere Beispiele. Am Ende vieler Kapitel gibt es ein C++-Quiz (mit Lösungen) zur Prüfung des Verständnisses.
Das Buch ist nicht nur für angehende Softwareentwickler, sondern auch für Studierende technischer Fächer ein idealer Einstieg.

Softwareentwicklung ist nicht nur Schreiben eines irgendwie funktionierenden Programms. Deshalb gibt es viele Tipps für einen guten Programmierstil, die die Qualität eines Programms erhöhen. Auch wird auf Fallstricke hingewiesen und wie man sie vermeidet.

Aus dem Inhalt:

Das erste Programm!
Grunddatentypen: Zahlen und Zeichen
Zahlen raten - Kontrollstrukturen zur Steuerung des Ablaufs
Ein- und Ausgabe, auch mit Dateien
Aufgaben strukturieren mit Funktionen
Das Spielfeld - Arrays und Vektoren
Beispiel TicTacToe
Spieler, Würfel und Klassen - objektorientierte Programmierung Grafik mit C++
Ereignisgesteuerte Programmierung
Bewegte Grafik
Dynamische Speicherplatzbeschaffung
Vererbung und Polymorphismus
TicTacToe reloaded
Fehlerbehandlung
Interaktives Spiel mit Grafik und Sound
Überladen von Operatoren
Die C++-Standardbibliothek
Templates Container, Iteratoren und Algorithmen
  • Deutsch
  • München
  • |
  • Deutschland
  • 6,65 MB
978-3-446-44912-1 (9783446449121)
http://dx.doi.org/10.3139/9783446449121
weitere Ausgaben werden ermittelt
Dr. Ulrich Breymann war Professor für Informatik an der Hochschule Bremen. Er engagierte sich im DIN-Arbeitskreis zur ersten Standardisierung von C++ und ist ein renommierter Autor zum Thema C++.
1 - Inhalt [Seite 6]
2 - Vorwort [Seite 14]
3 - 1 Erste Grundlagen [Seite 16]
3.1 - 1.1 Historisches [Seite 16]
3.2 - 1.2 Die Programmiersprache C++ und die Maschine [Seite 17]
3.3 - 1.3 Werkzeuge zum Programmieren [Seite 19]
3.3.1 - 1.3.1 Der Editor [Seite 19]
3.3.2 - 1.3.2 Der Compiler [Seite 20]
3.4 - 1.4 Die Beispiele [Seite 21]
3.5 - 1.5 Wo gibt es Hilfe? [Seite 21]
3.6 - 1.6 Das erste Programm! [Seite 22]
3.6.1 - 1.6.1 Fehlermeldungen [Seite 25]
3.7 - 1.7 Eingaben und Kommentare [Seite 27]
3.7.1 - 1.7.1 Kommentare und Namen [Seite 29]
3.8 - 1.8 Zahltypen und -bereiche [Seite 30]
3.8.1 - 1.8.1 Ganze Zahlen [Seite 30]
3.8.2 - 1.8.2 Kommazahlen [Seite 34]
3.8.3 - 1.8.3 Bit-Operatoren [Seite 0]
3.8.4 - 1.8.4 Vorsicht Falle: Umwandlung des Zahltyps [Seite 36]
3.9 - 1.9 Zeichen und Zeichenketten [Seite 39]
3.9.1 - 1.9.1 Eingabe [Seite 42]
3.9.2 - 1.9.2 Zeichen und Zahlen [Seite 44]
3.10 - 1.10 C++-Quiz [Seite 45]
4 - 2 Zahlen raten - Kontrollstrukturen anwenden [Seite 48]
4.1 - 2.1 Fallunterscheidung mit if [Seite 48]
4.1.1 - 2.1.1 Vergleichsoperatoren [Seite 50]
4.1.2 - 2.1.2 Logische Verknüpfungen [Seite 51]
4.1.3 - 2.1.3 Bedingungsoperator [Seite 53]
4.1.4 - 2.1.4 if und Fehler bei der Eingabe [Seite 54]
4.1.5 - 2.1.5 Fehler in Verbindung mit if [Seite 56]
4.1.6 - 2.1.6 C++-Quiz [Seite 57]
4.2 - 2.2 Wiederholungen [Seite 58]
4.2.1 - 2.2.1 while-Schleife [Seite 58]
4.2.2 - 2.2.2 do-while-Schleife [Seite 60]
4.2.3 - 2.2.3 for-Schleife [Seite 62]
4.2.4 - 2.2.4 Abbruch mit break [Seite 63]
4.2.5 - 2.2.5 Abbruch mit boolescher Variable [Seite 64]
4.2.6 - 2.2.6 continue - zurück an den Anfang [Seite 64]
4.2.7 - 2.2.7 C++-Quiz [Seite 65]
4.3 - 2.3 Der Zufall kommt ins Spiel [Seite 67]
4.3.1 - 2.3.1 Bereich für Zufallszahlen definieren [Seite 70]
4.4 - 2.4 Konstante [Seite 72]
4.5 - 2.5 Auswahl mit switch [Seite 74]
4.6 - 2.6 Aufzählungstyp [Seite 77]
4.7 - 2.7 C++-Quiz [Seite 79]
5 - 3 Ein- und Ausgabe [Seite 80]
5.1 - 3.1 Standardein- und -ausgabe [Seite 81]
5.1.1 - 3.1.1 Umleitung auf Betriebssystemebene [Seite 82]
5.2 - 3.2 Ein- und Ausgabe mit Dateien [Seite 83]
5.2.1 - 3.2.1 Schreiben einer Textdatei (Spielerdatenbank) [Seite 83]
5.2.2 - 3.2.2 Einlesen der Spielerdatenbank [Seite 85]
5.2.3 - 3.2.3 Binärdatei [Seite 87]
5.3 - 3.3 Formatierung der Ausgabe [Seite 89]
5.4 - 3.4 C++-Quiz [Seite 90]
6 - 4 Aufgaben strukturieren [Seite 92]
6.1 - 4.1 Deklaration und Definition [Seite 93]
6.1.1 - 4.1.1 Übergabe per Wert [Seite 94]
6.1.2 - 4.1.2 Überladen einer Funktion [Seite 96]
6.2 - 4.2 Trennung von Schnittstelle und Implementation [Seite 97]
6.2.1 - 4.2.1 Namensräume [Seite 101]
6.2.2 - 4.2.2 Präprozessoranweisungen [Seite 102]
6.3 - 4.3 Übergabe per Referenz [Seite 103]
6.4 - 4.4 Dateiübergreifende Sichtbarkeit [Seite 105]
6.5 - 4.5 Rekursion [Seite 107]
6.6 - 4.6 Einschränkung der Sichtbarkeit [Seite 110]
6.7 - 4.7 C++-Quiz [Seite 113]
7 - 5 Das Spielfeld [Seite 114]
7.1 - 5.1 Eine Zeile [Seite 114]
7.1.1 - 5.1.1 Zeilen mit array [Seite 115]
7.1.2 - 5.1.2 Zeilen mit vector [Seite 117]
7.2 - 5.2 Das Spielfeld - viele Zeilen [Seite 118]
7.2.1 - 5.2.1 Spielfeld mit vector [Seite 120]
7.2.2 - 5.2.2 Feld vorbesetzen [Seite 121]
7.3 - 5.3 Die Anwendung - TicTacToe [Seite 122]
7.4 - 5.4 C++-Quiz [Seite 131]
8 - 6 Spieler, Würfel und Klassen [Seite 134]
8.1 - 6.1 Objektorientierung [Seite 135]
8.2 - 6.2 Klasse Spieler [Seite 137]
8.2.1 - 6.2.1 explicit [Seite 142]
8.2.2 - 6.2.2 private oder public? [Seite 143]
8.3 - 6.3 Trennung von Schnittstelle und Implementation [Seite 144]
8.4 - 6.4 Mehr über Konstruktoren [Seite 146]
8.4.1 - 6.4.1 Allgemeiner Konstruktor [Seite 146]
8.4.2 - 6.4.2 Standardkonstruktor [Seite 146]
8.4.3 - 6.4.3 Kopierkonstruktor [Seite 147]
8.4.4 - 6.4.4 Einheitliche Initialisierung [Seite 150]
8.5 - 6.5 Die Zerstörung von Objekten [Seite 151]
8.5.1 - 6.5.1 Der Laufzeit-Stack [Seite 151]
8.5.2 - 6.5.2 Destruktor [Seite 152]
8.6 - 6.6 Klasse Würfel [Seite 154]
8.7 - 6.7 Würfelspiel: Mensch gegen Maschine [Seite 156]
8.7.1 - 6.7.1 Der Computer spielt gegen sich selbst [Seite 157]
8.8 - 6.8 C++-Quiz [Seite 162]
9 - 7 Grafik mit C++ [Seite 164]
9.1 - 7.1 Ereignisgesteuerte Programmierung [Seite 165]
9.2 - 7.2 Einfache Grafik [Seite 166]
9.3 - 7.3 Klassenvariablen und -funktionen [Seite 170]
9.4 - 7.4 Ereignisse [Seite 172]
9.5 - 7.5 Bewegte Grafik [Seite 174]
9.6 - 7.6 Grafikerzeugung [Seite 182]
9.7 - 7.7 C++-Quiz [Seite 188]
10 - 8 Dynamische Speicherbeschaffung [Seite 190]
10.1 - 8.1 Zeiger [Seite 191]
10.1.1 - 8.1.1 Zeiger auf Zeichen [Seite 193]
10.1.2 - 8.1.2 Zeigerarithmetik und Wahrheitswerte [Seite 194]
10.2 - 8.2 C-Arrays [Seite 196]
10.2.1 - 8.2.1 Parameterübergabe per Zeiger [Seite 198]
10.3 - 8.3 Speicherbeschaffung [Seite 199]
10.3.1 - 8.3.1 Die beste Art! [Seite 199]
10.3.2 - 8.3.2 new und delete - tun Sie es nicht! [Seite 200]
10.3.3 - 8.3.3 unique_ptr [Seite 203]
10.3.4 - 8.3.4 shared_ptr [Seite 205]
10.4 - 8.4 Grafische Objekte dynamisch erzeugen [Seite 207]
10.4.1 - 8.4.1 Speicherplatz besser nutzen [Seite 209]
10.5 - 8.5 Zeiger als Beobachter [Seite 210]
10.6 - 8.6 C++-Quiz [Seite 212]
11 - 9 Vererbung [Seite 214]
11.1 - 9.1 Generalisierung und Spezialisierung [Seite 214]
11.2 - 9.2 Vererbung am Beispiel [Seite 215]
11.2.1 - 9.2.1 Statische Auswertung [Seite 221]
11.3 - 9.3 Konstruktor erben [Seite 221]
11.4 - 9.4 Polymorphismus [Seite 222]
11.4.1 - 9.4.1 Polymorphismus und >>die großen Drei<< [Seite 224]
11.4.2 - 9.4.2 Überschreiben oder nicht überschreiben? [Seite 224]
11.4.3 - 9.4.3 Polymorphismus-Anwendung [Seite 226]
11.4.4 - 9.4.4 Herausfiltern bestimmter Klassen [Seite 227]
11.5 - 9.5 Abstrakte Klassen [Seite 228]
11.6 - 9.6 Mehrfachvererbung [Seite 229]
11.7 - 9.7 Polymorphismus und SFML - TicTacToe reloaded [Seite 230]
11.8 - 9.8 Probleme der Modellierung mit Vererbung [Seite 237]
11.9 - 9.9 C++-Quiz [Seite 238]
12 - 10 Fehlerbehandlung [Seite 240]
12.1 - 10.1 Fehler erkennen und signalisieren [Seite 241]
12.2 - 10.2 Fehler behandeln [Seite 241]
12.3 - 10.3 Vordefinierte Exceptions [Seite 245]
12.4 - 10.4 Eigene Exception-Klasse [Seite 246]
12.5 - 10.5 C++-Quiz [Seite 248]
13 - 11 Interaktives Spiel mit Grafik und Sound [Seite 250]
13.1 - 11.1 Anzeige des Spielergebnisses [Seite 252]
13.2 - 11.2 Einfache grafische Komponenten [Seite 254]
13.2.1 - 11.2.1 Der Mond [Seite 254]
13.2.2 - 11.2.2 Die fallenden Objekte [Seite 255]
13.3 - 11.3 Sprites [Seite 257]
13.3.1 - 11.3.1 Der Vogel [Seite 260]
13.4 - 11.4 Spielablauf [Seite 261]
14 - 12 Überladen von Operatoren [Seite 270]
14.1 - 12.1 Zeiger als Beobachter: Operatoren -> und * [Seite 273]
14.2 - 12.2 ++, ==, << und weitere [Seite 275]
14.2.1 - 12.2.1 Typumwandlung [Seite 280]
14.2.2 - 12.2.2 ++ vorangestellt (Präfix) [Seite 280]
14.2.3 - 12.2.3 ++ nachgestellt (Postfix) [Seite 282]
14.2.4 - 12.2.4 Gleichheitsoperator [Seite 283]
14.2.5 - 12.2.5 Subtraktion [Seite 285]
14.2.6 - 12.2.6 Ausgabeoperator << [Seite 285]
14.2.7 - 12.2.7 Eingabeoperator >> [Seite 287]
14.2.8 - 12.2.8 Objekte als Funktion [Seite 288]
14.2.9 - 12.2.9 Indexoperator [] [Seite 288]
14.2.10 - 12.2.10 Arithmetische Operatoren += und + [Seite 290]
14.2.11 - 12.2.11 Zuweisungsoperator [Seite 292]
14.2.12 - 12.2.12 new, delete und die großen Drei [Seite 295]
14.3 - 12.3 Empfehlungen [Seite 299]
14.4 - 12.4 C++-Quiz [Seite 300]
15 - 13 Die C++-Standardbibliothek [Seite 302]
15.1 - 13.1 Templates [Seite 303]
15.1.1 - 13.1.1 Funktions-Template [Seite 304]
15.1.2 - 13.1.2 Template-Spezialisierung [Seite 306]
15.1.3 - 13.1.3 Klassen-Template [Seite 308]
15.2 - 13.2 Funktionsobjekte und Lambda-Funktionen [Seite 310]
15.2.1 - 13.2.1 Funktionsobjekte [Seite 311]
15.2.2 - 13.2.2 Lambda-Funktionen [Seite 315]
15.3 - 13.3 Paare [Seite 316]
15.4 - 13.4 Iteratoren [Seite 318]
15.4.1 - 13.4.1 Iterator-Kategorien [Seite 322]
15.5 - 13.5 Algorithmen [Seite 323]
15.5.1 - 13.5.1 Funktionsweise [Seite 323]
15.5.2 - 13.5.2 sort [Seite 325]
15.5.3 - 13.5.3 find [Seite 325]
15.5.4 - 13.5.4 binary_search und lower_bound [Seite 327]
15.5.5 - 13.5.5 copy [Seite 329]
15.5.6 - 13.5.6 remove und erase [Seite 330]
15.5.7 - 13.5.7 fill [Seite 331]
15.5.8 - 13.5.8 Folge mit fortlaufenden Werten füllen [Seite 332]
15.5.9 - 13.5.9 generate [Seite 332]
15.5.10 - 13.5.10 min und max [Seite 333]
15.5.11 - 13.5.11 min_element und max_element [Seite 334]
15.5.12 - 13.5.12 accumulate [Seite 334]
15.5.13 - 13.5.13 Skalarprodukt [Seite 336]
15.6 - 13.6 Container [Seite 337]
15.6.1 - 13.6.1 Gemeinsame Eigenschaften [Seite 337]
15.6.2 - 13.6.2 Sequentielle Container [Seite 340]
15.6.3 - 13.6.3 array [Seite 342]
15.6.4 - 13.6.4 vector [Seite 342]
15.6.5 - 13.6.5 list [Seite 343]
15.6.6 - 13.6.6 deque [Seite 344]
15.6.7 - 13.6.7 stack [Seite 345]
15.6.8 - 13.6.8 Assoziative Container [Seite 345]
15.6.9 - 13.6.9 map [Seite 346]
15.6.10 - 13.6.10 set [Seite 350]
15.6.11 - 13.6.11 unordered_map [Seite 351]
15.6.12 - 13.6.12 unordered_set [Seite 352]
15.7 - 13.7 Zeitmessung und Datum/Uhrzeit [Seite 353]
15.8 - 13.8 Komplexe Zahlen [Seite 355]
16 - 14 Referenzsemantik [Seite 358]
16.1 - 14.1 Compiler-generierte Funktionen [Seite 359]
16.2 - 14.2 Empfehlungen [Seite 360]
16.3 - 14.3 Praktische Umsetzung [Seite 361]
17 - 15 Ausblick [Seite 364]
17.1 - 15.1 Template-Erweiterungen [Seite 364]
17.2 - 15.2 Die C++-Standardbibliothek [Seite 365]
17.3 - 15.3 Test von C++-Programmen [Seite 367]
18 - A Anhang [Seite 368]
18.1 - A.1 Installationshinweise für Windows [Seite 369]
18.1.1 - A.1.1 Compiler [Seite 369]
18.1.2 - A.1.2 Entwicklungsumgebung [Seite 369]
18.1.3 - A.1.3 SFML [Seite 371]
18.2 - A.2 Installationshinweise für Linux [Seite 372]
18.2.1 - A.2.1 Compiler [Seite 372]
18.2.2 - A.2.2 Entwicklungsumgebung [Seite 372]
18.2.3 - A.2.3 SFML [Seite 373]
18.3 - A.3 Installationshinweise für OS X [Seite 374]
18.3.1 - A.3.1 Compiler und Entwicklungsumgebung [Seite 374]
18.3.2 - A.3.2 SFML [Seite 375]
18.4 - A.4 ASCII-Tabelle [Seite 377]
19 - Glossar [Seite 380]
20 - Literatur [Seite 392]
21 - Stichwortverzeichnis [Seite 394]

Dateiformat: PDF
Kopierschutz: Wasserzeichen-DRM (Digital Rights Management)

Systemvoraussetzungen:

Computer (Windows; MacOS X; Linux): Verwenden Sie zum Lesen die kostenlose Software Adobe Reader, Adobe Digital Editions oder einen anderen PDF-Viewer Ihrer Wahl (siehe E-Book Hilfe).

Tablet/Smartphone (Android; iOS): Installieren Sie die kostenlose App Adobe Digital Editions oder eine andere Lese-App für E-Books (siehe E-Book Hilfe).

E-Book-Reader: Bookeen, Kobo, Pocketbook, Sony, Tolino u.v.a.m. (nur bedingt: Kindle)

Das Dateiformat PDF zeigt auf jeder Hardware eine Buchseite stets identisch an. Daher ist eine PDF auch für ein komplexes Layout geeignet, wie es bei Lehr- und Fachbüchern verwendet wird (Bilder, Tabellen, Spalten, Fußnoten). Bei kleinen Displays von E-Readern oder Smartphones sind PDF leider eher nervig, weil zu viel Scrollen notwendig ist. Mit Wasserzeichen-DRM wird hier ein "weicher" Kopierschutz verwendet. Daher ist technisch zwar alles möglich - sogar eine unzulässige Weitergabe. Aber an sichtbaren und unsichtbaren Stellen wird der Käufer des E-Books als Wasserzeichen hinterlegt, sodass im Falle eines Missbrauchs die Spur zurückverfolgt werden kann.

Weitere Informationen finden Sie in unserer E-Book Hilfe.


Download (sofort verfügbar)

7,99 €
inkl. 7% MwSt.
Download / Einzel-Lizenz
PDF mit Wasserzeichen-DRM
siehe Systemvoraussetzungen
E-Book bestellen