O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

C++ für Dummies, 6., vollständig überarbeitete Auflage

Book Description

C++ muss nicht schwierig sein. Stephen Randy Davis erklärt Ihnen Schritt für Schritt anhand zahlreicher Programmschnipsel und vollständiger Programme die Syntax von C++. Begriffe wie Vererbung, Zeiger oder Klasse werden Ihnen schon bald kein Rätsel mehr sein. Mit CD.

Note: The ebook version does not provide access to the companion files.

Table of Contents

  1. Cover
  2. Title
  3. Copyright
  4. Inhaltsverzeichnis
  5. Einführung
    1. Zu diesem Buch
    2. Über die CD
    3. Was ist C++?
    4. Konventionen in diesem Buch
    5. Wie dieses Buch aufgebaut ist
    6. Das ist noch nicht alles
    7. Teil I: Einführung in die C++-Programmierung
    8. Teil II: Ein brauchbarer C++-Programmierer werden
    9. Teil III: Eine Einführung in Klassen
    10. Teil IV: Vererbung
    11. Teil V: Optionale Funktionen
    12. Teil VI: Der Top-Ten-Teil
    13. Icons in diesem Buch
    14. Wie geht's weiter?
  6. Teil I Einführung in die C++-Programmierung
    1. Kapitel 1 Ihr erstes C++-Programm
      1. Was ist ein Programm?
      2. Code::Blocks unter Windows installieren
      3. Ihr erstes C++-Programm erstellen
        1. Ein Projekt anlegen
        2. Den C++-Code eingeben
        3. Ihr Programm erstellen
        4. Ihr Programm ausführen
      4. Kommentierte Programme lesen
        1. Das gemeinsame Gerüst aller C++-Programme
        2. Sourcecode durch Kommentare erläutern
        3. Programme bestehen aus C++-Anweisungen
        4. Deklarationen schreiben
        5. Ausgaben erzeugen
      5. Ausdrücke berechnen
        1. Das Ergebnis eines Ausdrucks speichern
        2. Den Rest des Programms untersuchen
    2. Kapitel 2 Variablen verwenden
      1. Variablen deklarieren
      2. Verschiedene Variablentypen für alle Fälle
        1. Überblick über die Einschränkungen der Ganzzahlen in C++
        2. Das Rundungsproblem lösen
        3. Die Einschränkungen von Fließkommazahlen
      3. Variablentypen deklarieren
        1. Konstantentypen
        2. Wertebereiche von numerischen Typen
        3. Sonderzeichen
        4. Zeichen mit doppelter Spurbreite
      4. Sind diese Berechnungen wirklich logisch?
      5. Mixed-Mode-Ausdrücke
        1. Automatische Deklarationen
    3. Kapitel 3 Mathematische Operationen ausführen
      1. Einfache binäre Operationen ausführen
      2. Ausdrücke zerlegen
      3. Die Reihenfolge von Operationen bestimmen
      4. Unäre Operationen ausführen
      5. Mit Zuweisungsoperatoren arbeiten
    4. Kapitel 4 Logische Operationen ausführen
      1. Warum brauchen wir überhaupt logische Operationen?
      2. Mit den einfachen logischen Operatoren arbeiten
        1. Logische Werte speichern
        2. Mit logischen int-Variablen arbeiten
        3. Vorsicht bei logischen Operationen mit Fließkommavariablen
      3. Binärzahlen repräsentieren
        1. Das dezimale Zahlensystem
        2. Andere Zahlensysteme
        3. Das binäre Zahlensystem
      4. Bitweise logische Operationen ausführen
        1. Die bitweisen Operatoren
        2. Die bitweisen Operatoren verwenden
        3. Ein einfacher Test
        4. Etwas Logisches mit logischen Berechnungen tun
    5. Kapitel 5 Den Programmablauf steuern
      1. Den Programmablauf mit Verzweigungsbefehlen steuern
      2. Schleifen in einem Programm ausführen
        1. Eine Schleife ausführen, während eine Bedingung true ist
        2. Die Autoinkrement- und Autodekrement-Funktionen verwenden
        3. Mit der for-Schleife arbeiten
        4. Die gefürchtete Endlosschleife vermeiden
        5. Spezielle Schleifenkontrollen anwenden
      3. Steuerbefehle verschachteln
      4. Die Mehrwege-Verzweigung: switch
  7. Teil II Ein brauchbarer C++-Programmierer werden
    1. Kapitel 6 Funktionen erstellen
      1. Eine Funktion schreiben und verwenden
        1. Unsere erste Funktion definieren
        2. Die Funktion sumSequence() definieren
        3. Die Funktion sumSequence() aufrufen
        4. Teile und herrsche
      2. Die Details von Funktionen verstehen
        1. Einfache Funktionen verstehen
        2. Funktionen mit Argumenten verstehen
      3. Funktionsnamen überladen
      4. Funktionsprototypen definieren
      5. Variable Speichertypen
    2. Kapitel 7 Sequenzen in Arrays speichern
      1. Wozu werden Arrays benötigt?
        1. Ein Array verwenden
        2. Ein Array initialisieren
        3. Mit einem zu großen Indexwert auf ein Array zugreifen
        4. Mit Arrays arbeiten
        5. Arrays von Arrays definieren und verwenden
      2. Arrays von Zeichen verwenden
        1. Ein Array von Zeichen erstellen
        2. Einen String von Zeichen erstellen
      3. Zeichenstrings manipulieren
      4. Ein paar Bibliotheksfunktionen
      5. Mehr Platz für Wide-Strings
    3. Kapitel 8 Ein erster Blick auf C++-Zeiger
      1. Variablengröße
      2. Was ist in einer Adresse enthalten?
      3. Adressoperatoren
      4. Zeigervariablen verwenden
        1. Verschiedene Typen von Zeigern verwenden
      5. Zeiger an Funktionen übergeben
        1. Übergabe als Wert
        2. Zeigerwert übergeben
        3. Übergabe per Referenz
      6. Konstante Irritationen
      7. Einen Speicherblock namens Heap nutzen
        1. Begrenzter Gültigkeitsbereich
        2. Das Problem des Gültigkeitsbereichs untersuchen
        3. Mit Hilfe des Heaps eine Lösung finden
    4. Kapitel 9 Ein zweiter Blick auf C++-Zeiger
      1. Operationen für Zeigervariablen definieren
        1. Arrays im Licht von Zeigervariablen noch einmal betrachten
        2. Operatoren auf die Adresse eines Arrays anwenden
        3. Zeigeroperationen auf einen String ausdehnen
        4. Gründe für die zeigerbasierte String-Manipulation
        5. Operatoren auf andere Zeigertypen als char anwenden
        6. Einen Zeiger mit einem Array vergleichen
      2. Wann gibt's einen Zeiger nicht?
      3. Arrays von Zeigern deklarieren und verwenden
        1. Arrays von Zeichenstrings nutzen
        2. Auf die Argumente von main() zugreifen
    5. Kapitel 10 Der C++-Präprozessor
      1. Was ist ein Präprozessor?
      2. Einbinden von Dateien
      3. Die #Definition von Dingen
        1. Und wenn ich nichts #definieren will?
        2. Ein paar Alternativen aufzählen
        3. Dinge mit einem »ja aber« einbinden
      4. Vordefinierte Objekte
      5. Typendefinitionen mit typedef
  8. Teil III Eine Einführung in Klassen
    1. Kapitel 11 Ein Blick auf die objektorientierte Programmierung
      1. Die Abstraktion und der Mikrowellenherd
        1. Nachos prozedural zubereiten
        2. Nachos objektorientiert zubereiten
      2. Klassenbildung und Mikrowellen
      3. Wozu Klassen bilden?
    2. Kapitel 12 Klassen in C++
      1. Einführung der Klasse
      2. Das Format einer Klasse
      3. Auf die Elemente einer Klasse zugreifen
      4. Objekte aktivieren
        1. Reale Objekte simulieren
        2. Wozu dienen Elementfunktionen?
      5. Eine Elementfunktion hinzufügen
      6. Eine Elementfunktion aufrufen
        1. Von einer Elementfunktion auf andere Elemente zugreifen
      7. Auflösung des Gültigkeitsbereichs
      8. Eine Elementfunktion in der Klasse definieren
      9. Elementfunktionen separat definieren
      10. Elementfunktionen überladen
    3. Kapitel 13 Objekte mit Zeigern manipulieren
      1. Arrays aus Objekten deklarieren
      2. Zeiger auf Objekte deklarieren
        1. Einen Objektzeiger dereferenzieren
        2. Der Pfeiloperator
      3. Objekte an Funktionen übergeben
        1. Eine Funktion mit einem Objektwert aufrufen
        2. Eine Funktion mit einem Objektzeiger aufrufen
        3. Eine Funktion mit dem Referenzoperator aufrufen
      4. Wozu Zeiger oder Referenzen?
      5. Zurück zum Heap
        1. Viele Objekte auf dem Heap anlegen
      6. Zeiger und Referenzen vergleichen
      7. Verknüpfungen mit verketteten Listen erstellen
        1. Andere Operationen auf eine verkettete Liste anwenden
        2. Das LinkedListData-Beispielprogramm
      8. Ein Hoffnungsstrahl: Eine Liste von Containern, die mit der C++-Library verknüpft sind
    4. Kapitel 14 Nicht stören: Elemente schützen
      1. Elemente schützen
        1. Wozu benötigen Sie geschützte Elemente?
        2. Wie geschützte Elemente funktionieren
      2. Argumente für den Einsatz geschützter Elemente
        1. Den internen Status einer Klasse schützen
        2. Eine Klasse mit eingeschränkter Schnittstelle verwenden
      3. Nicht-Elementfunktionen Zugriff auf geschützte Elemente geben
    5. Kapitel 15 Objekte konstruieren und zerstören
      1. Objekte erstellen
      2. Konstruktoren verwenden
        1. Ein einzelnes Objekt konstruieren
        2. Mehrere Objekte konstruieren
        3. Ein Duplex konstruieren
      3. Einen Destruktor analysieren
        1. Warum Sie den Destruktor benötigen
        2. Mit Destruktoren arbeiten
    6. Kapitel 16 Konstruktoren mit Argumenten
      1. Konstruktoren mit Argumenten ausstatten
        1. Einen Konstruktor verwenden
      2. Konstruktoren überladen
      3. Standardmäßige Standardkonstruktoren
      4. Klassenelemente konstruieren
        1. Ein komplexes Datenelement konstruieren
        2. Ein konstantes Datenelement konstruieren
      5. Die Reihenfolge der Konstruktion
        1. Lokale Objekte werden der Reihenfolge nach konstruiert
        2. Statische Objekte werden nur einmal konstruiert
        3. Alle globalen Objekte werden vor main() konstruiert
        4. Globale Objekte werden in keiner bestimmten Reihenfolge konstruiert
        5. Elemente werden in der Reihenfolge konstruiert, in der sie deklariert werden
        6. Destruktoren werden in der umgekehrten Reihenfolge der Konstruktoren aufgerufen
      6. Konstruktoren als Form der Konvertierung
    7. Kapitel 17 Der Copy-Konstruktor
      1. Ein Objekt kopieren
        1. Warum Sie Copy-Konstruktoren brauchen
        2. Die Copy-Konstruktoren verwenden
      2. Der automatische Copy-Konstruktor
      3. Flache oder tiefe Kopien erstellen
      4. Temporäre Objekte
        1. Temporäre Objekte dauerhaft vermeiden
    8. Kapitel 18 Statische Elemente
      1. Ein statisches Element definieren
        1. Warum Sie statische Elemente benötigen
        2. Statische Elemente verwenden
        3. Statische Datenelemente referenzieren
        4. Verwendungsmöglichkeiten statischer Datenelemente
      2. Statische Elementfunktionen deklarieren
      3. Was ist überhaupt this?
  9. Teil IV Vererbung
    1. Kapitel 19 Eine Klasse erben
      1. Brauche ich Vererbung?
      2. Wie funktioniert die Vererbung einer Klasse?
        1. Eine Unterklasse verwenden
        2. Eine Unterklasse konstruieren
        3. Eine Unterklasse zerstören
      3. Die HAS_A-Beziehung
    2. Kapitel 20 Virtuelle Elementfunktionen
      1. Warum Sie Polymorphismus brauchen
      2. Wie funktioniert Polymorphismus?
      3. Wann ist eine Funktion virtuell und wann nicht?
      4. Virtuelle Betrachtungen
    3. Kapitel 21 Klassen faktorisieren
      1. Das Faktorisieren
      2. Abstrakte Klassen implementieren
        1. Das Konzept der abstrakten Klasse
        2. Wie man aus einer abstrakten Klasse eine wirkliche Klasse macht
        3. Abstrakte Klassen übergeben
  10. Teil V Optionale Funktionen
    1. Kapitel 22 Ein neuer Zuweisungsoperator
      1. Operatoren mit Funktionen vergleichen
      2. Einen neuen Operator einfügen
      3. Flache Kopien zu erstellen ist ein tiefes Problem
      4. Den Zuweisungsoperator überladen
      5. Den Indexoperator überladen
    2. Kapitel 23 Mit Stream-I/O arbeiten
      1. Wie funktioniert Stream-I/O?
        1. Default Stream-Objekte
      2. Die fstream-Unterklassen
        1. Vielfältiges Öffnen
        2. Datei, was machst Du gerade?
        3. Kann ich ein Beispiel sehen?
      3. Andere Methoden der Stream-Klassen
        1. Streams direkt lesen und schreiben
        2. Das Format kontrollieren
        3. Was ist mit endl?
        4. Positionierung des Zeigers innerhalb einer Datei
      4. Die stringstream-Unterklassen verwenden
      5. Manipulatoren manipulieren
    3. Kapitel 24 Fehler verarbeiten – Ausnahmen
      1. Warum brauche ich einen neuen Fehlermechanismus?
      2. Den Ausnahmemechanismus untersuchen
      3. Welche Dinge sind »throw«-fähig?
      4. Einfach mal durchreichen
    4. Kapitel 25 Mehrfachvererbung
      1. Wie funktioniert die Mehrfachvererbung?
      2. Vererbungsmehrdeutigkeiten beseitigen
      3. Virtuelle Vererbung hinzufügen
      4. Objekte der Mehrfachvererbung erzeugen
      5. Eine gegenteilige Meinung
    5. Kapitel 26 C++-Templates durchleuchten
      1. Eine Funktion in einem Template verallgemeinern
      2. Template-Klassen
      3. Tipps für die Verwendung von Templates
    6. Kapitel 27 Die Standard Template Library als Standard verwenden
      1. Der string-Container
      2. Die list-Container
        1. Listen durchwandern
        2. Operationen auf ganzen Listen
        3. Beispiel, bitte!
  11. Teil VI Der Top-Ten-Teil
    1. Kapitel 28 Zehn Methoden, um Fehler in einem Programm zu vermeiden
      1. Aktivieren Sie alle Warnungen und Fehlermeldungen
      2. Pflegen Sie einen sauberen und konsistenten Programmierstil
      3. Schränken Sie die Sichtbarkeitsbereiche ein
      4. Kommentieren Sie Ihren Code
      5. Durchlaufen Sie jeden Pfad mindestens einmal im Einzelschrittmodus
      6. Vermeiden Sie es, Operatoren zu überladen
      7. Mit dem Heap arbeiten
      8. Fehler mit Ausnahmen behandeln
      9. Deklarieren Sie Destruktoren virtuell
      10. Vermeiden Sie die Mehrfachvererbung
    2. Kapitel 29 (Fast) Zehn Websites zu allen Fragen rund um C++
      1. C-plusplus.de (deutsch)
      2. Cplusplus.com (englisch)
      3. Code::Blocks
      4. Visual C++ Express Edition
      5. Forum zur Visual C++ Express Edition
      6. Referenz zur Windows-Programmierung mit C++
      7. Referenz zu C (englisch)
      8. Referenz zu C (deutsch)
      9. Informationen zu C++11
  12. Anhang A Über die CD
    1. Systemanforderungen
    2. Die CD benutzen
    3. Der Inhalt der CD
      1. Entwicklungswerkzeug
      2. Programm-Quellcode
    4. Falls Sie Probleme mit der CD haben
  13. Stichwortverzeichnis