C++ Alles in einem Band für Dummies

 
 
Wiley-VCH (Verlag)
  • erschienen am 15. Januar 2016
  • |
  • 828 Seiten
 
E-Book | ePUB mit Adobe-DRM | Systemvoraussetzungen
978-3-527-69259-0 (ISBN)
 
Dieses Buch ist für alle, die tief in die C++-Programmierung einsteigen möchten. Dennoch werden keine Programmierkenntnisse vorausgesetzt. John Paul Mueller und Jeff Cogswell erklären Ihnen zunächst, wie Sie C++ installieren. Sie erfahren, was Klassen und Objekte sind, was Sie mit Entwurfsmustern anfangen und wie Sie Ihre Programme debuggen. Aus Anfängern werden Entwickler mit Erfahrung und dann fortgeschrittene Programmierer. Diese finden in diesem Buch Informationen zu dynamischen Arrays, Lambda-Ausdrücken, Streams, UML, der Standardbibliothek, zu Boost und vielem mehr. Alle Codebeispiele des Buchs stehen zum Download zur Verfügung.
1. Auflage
  • Deutsch
  • Berlin
  • |
  • Deutschland
  • 10,06 MB
978-3-527-69259-0 (9783527692590)
weitere Ausgaben werden ermittelt
John Paul Mueller ist Autor von 94 Büchern und mehr als 300 Zeitschriftenartikeln. Seine Themen reichen von Netzwerken bis zur künstlichen Intelligenz, von der Datenbankverwaltung bis zur professionellen Programmierung.
Jeff Cogswell ist Autor, Trainer und Softwareentwickler. Zu seinen fachlichen Fähigkeiten gehören nicht nur C++, sondern auch andere Sprachen und Plattformen wie C# und ASP.NET.
  • Intro
  • Schummelseite
  • Titelei
  • Inhaltsverzeichnis
  • Über die Autoren
  • Einführung
  • Sie benötigen keinerlei Erfahrung
  • Und auch die erste Wahl für erfahrene Leute!
  • Für alle Computer
  • Konventionen
  • Wie das Buch aufgebaut ist
  • Haufenweise Symbole
  • Wie geht es weiter?
  • Was danach kommt
  • Teil I Los geht's mit C++
  • 1 Ihr System einrichten
  • An C++ 14 gelangen
  • Sich Code::Blocks besorgen
  • Code::Blocks installieren
  • Mit Windows arbeiten
  • Mit Mac OS/X arbeiten
  • Eine Standardinstallation unter Linux
  • Die grafische Linux-Installation verwenden
  • Die wesentlichen Programmfunktionen von Code::Blocks kennenlernen
  • Code::Blocks zum ersten Mal starten
  • Die Beispielprojekte öffnen
  • Die wichtigsten Fenster
  • Das Fenster »Start here«
  • Andere Entwicklungsumgebungen verwenden
  • 2 Die erste C++-Anwendung erstellen
  • Ein Projekt mit Code::Blocks erstellen
  • Was sind Projekte?
  • Das erste Projekt definieren
  • Die erste Anwendung erstellen und ausführen
  • Den Code eingeben
  • Mit »main« beginnen
  • Informationen anzeigen
  • Ein bisschen Rechnen
  • Die Ausgabe mit Tabulatoren versehen
  • Lassen Sie Ihre Anwendung laufen
  • 3 Daten in C++ speichern
  • Ablageorte für Daten: Variablen
  • Eine Integervariable erstellen
  • Mehrere Variablen definieren
  • Werte ändern
  • Eine Variable mit einer anderen gleichsetzen
  • Eine Variable initialisieren
  • Vergeben Sie selbst großartige Namen
  • Mit Integervariablen rechnen
  • Mit Integervariablen addieren
  • Ganzzahlige Werte subtrahieren
  • Integervariablen multiplizieren
  • Integervariablen dividieren
  • Allgemeine Zeichen oder Characters
  • Das Null-Zeichen
  • Nicht druckbare und andere Zeichen
  • Zeichenfolgen (Strings)
  • Einen Teil eines Strings auslesen
  • Einen Teil eines Strings ändern
  • Einen String erweitern
  • Zwei Strings »addieren«
  • Zwischen bedingten Operatoren entscheiden
  • Mit Boole'schen Variablen die Wahrheit sagen
  • Die Konsole auslesen
  • 4 Den Ablauf der Anwendung steuern
  • Dies oder jenes tun
  • Bedingungen in C++ auswerten
  • Den richtigen C++-Operator herausfinden
  • Mehrere Bedingungen kombinieren
  • Evaluierungen in bedingte C++-Anweisungen einbinden
  • Festlegen, was wäre wenn und was ansonsten wäre
  • Mit »if« und »else« eine Etage weiter gehen
  • Aktionen mit Anweisungen wiederholen
  • Schleifenbildung
  • for-Schleifen
  • »While«-Schleifen
  • Etwas tun, während .
  • Unterbrechen und fortfahren
  • Schleifen verschachteln
  • 5 Ihr Werk mit Funktionen aufteilen
  • Teilen Sie Ihr Werk auf
  • Eine Funktion aufrufen
  • Eine Variable übergeben
  • Mehrere Variablen übergeben
  • Eigene Funktionen schreiben
  • Mehrere oder keine Parameter
  • Nichts zurückgeben
  • Lokale Variablen
  • Vorwärtsreferenzen und Funktionsprototyp
  • Zwei Versionen derselben Funktion schreiben
  • Funktionen für große Strings aufrufen
  • Was ist »main()«?
  • 6 Quellcodedateien aufteilen
  • Mehrere Quellcodedateien erstellen
  • Ein Projekt in Code::Blocks in mehrere Quellcodedateien aufteilen
  • In Code::Blocks ein Projekt mit mehreren Dateien erstellen
  • Mehrere Quellcodedateien in anderen Compilern
  • Mehrere Dateien erstellen
  • Headerdateien gemeinsam nutzen
  • Den Header nur einmal hinzufügen
  • Spitze Klammern oder Anführungszeichen?
  • Variablen in mehreren Quellcodedateien nutzen
  • Die mysteriösen Header-Wrapper verwenden
  • 7 Mit Zeigern auf die Daten verweisen
  • Variablen »anhäufen« und »stapeln«
  • Die Adresse einer Variablen erhalten
  • Eine Variable mithilfe eines Zeigers ändern
  • Auf einen String zeigen
  • Auf etwas anderes zeigen
  • Tipps für Zeigervariablen
  • Dynamisches Zuweisen mit »new«
  • »new« verwenden
  • Eine Initialisierungsanweisung verwenden
  • Ein neuer String
  • Zeiger freigeben
  • Zeigervariablen an Funktionen übergeben
  • Werte von Variablen mit Zeiger ändern
  • Stringparameter ändern
  • Zeigervariablen von Funktionen zurückerhalten
  • Einen Zeiger als Nicht-Zeiger zurückgeben
  • Per Referenz übergeben
  • Als konstante Referenz übergeben
  • An die Regeln denken
  • 8 Mit Klassen arbeiten
  • Objekte und Klassen verstehen
  • Klassen und Objekte klassifizieren
  • Mitgliedsfunktionen und Memberdaten beschreiben
  • Eine Klasse implementieren
  • Den Code von Mitgliedsfunktionen aufteilen
  • Die Bestandteile einer Klasse
  • Mit einer Klasse arbeiten
  • Auf Mitglieder zugreifen
  • Klassen und Zeiger verwenden
  • Objekte an Funktionen übergeben
  • Konstante Parameter in Funktionen verwenden
  • Den Zeiger »this« verwenden
  • Mitgliedsfunktionen überladen
  • Mit Konstruktoren und Destruktoren anfangen und aufhören
  • Mit Konstruktoren starten
  • Etwas mit Destruktoren beenden
  • Beispiele für Konstruktoren und Destruktoren
  • Den Konstruktoren Parameter hinzufügen
  • Klassenhierarchien bilden
  • Eine Hierarchie in C++ erstellen
  • Vererbungstypen verstehen
  • Aliasse von Objekten erstellen und verwenden
  • 9 Erweiterte C++-Funktionen nutzen
  • Den Code mit Kommentaren ergänzen
  • Typen umwandeln
  • Aus der Konsole lesen
  • Die Direktiven eines Präprozessors verstehen
  • Konstanten verwenden
  • »switch«-Anweisungen verwenden
  • Aufzählungen mit Klassen überladen
  • Mit Zufallszahlen arbeiten
  • Daten in Arrays speichern
  • Ein Array aus Zeigern
  • Arrays an Funktionen übergeben
  • Zeiger addieren und subtrahieren
  • Teil II Objekte und Klassen verstehen
  • 10 Objekte planen und erstellen
  • Objekte erkennen
  • Die Klasse »Briefkaesten« beobachten
  • Die Klasse »Briefkasten« beobachten
  • Andere Objekte finden
  • Objekte kapseln
  • Hierarchien aufbauen
  • Eine Bibliothek einrichten
  • Mitglieder bei Vererbung schützen
  • Mitgliedsfunktionen überschreiben
  • Spezialisierung durch Polymorphie
  • Dinge abstrakt sehen
  • Klassen entdecken
  • Software entwickeln
  • Diese nervenden Klassen finden
  • 11 Mit Entwurfsmustern entwickeln
  • Eine Einführung in einfache Muster: das Singleton
  • Eine Instanz mit einem Beobachter überwachen
  • Einen Beobachter automatisch hinzufügen
  • Mit einem Muster vermitteln
  • Teil III Fortgeschrittene Programmierung
  • 12 Mit Arrays, Zeigern und Referenzen arbeiten
  • Arrays verstehen
  • Arrays definieren
  • Arrays und Zeiger
  • Mehrdimensionale Arrays einsetzen
  • Mehrdimensionale Arrays initialisieren
  • Mehrdimensionale Arrays übergeben
  • Arrays und Befehlszeilenparameter
  • Ein Array auf dem Heap anlegen
  • Arrays aus Zeigern und Arrays aus Arrays speichern
  • Konstante Arrays erstellen
  • Mit Zeigern zeigen
  • Immer diese furchtbare Komplexität
  • Zeiger auf Funktionen
  • Eine Variable auf eine Mitgliedsfunktion zeigen lassen
  • Auf statische Mitgliedsfunktionen zeigen
  • Auf Referenzen referenzieren
  • Variablen referenzieren
  • Eine Referenz aus einer Funktion zurückgeben
  • 13 Datenstrukturen erstellen
  • Mit Daten arbeiten
  • Variablen, Variablen und noch mehr Variablen
  • Variablen auf beiden Seiten der Macht
  • Ihre Daten verzaubern
  • Strukturieren Sie Ihre Daten
  • Strukturen als Komponenten-Datentypen
  • Strukturen gleichsetzen
  • Strukturtypen zurückgeben
  • Geben Sie Ihrem Raum einen Namen
  • Variablen und Teile eines Namensraums verwenden
  • 14 Konstruktoren, Destruktoren und Exceptions
  • Objekte mit Konstruktor und Destruktor erschaffen und zerstören
  • Konstruktoren überladen
  • Mitglieder initialisieren
  • Einen Standardkonstruktor hinzufügen
  • Funktionskonstruktoren
  • Einen Konstruktor von einem anderen aus aufrufen
  • Instanzen mithilfe von Copy-Konstruktoren kopieren
  • Wenn Konstruktoren Ärger machen: Fehlerhafte Konstruktoren
  • Instanzen zerstören
  • Destruktoren virtuell erben
  • Die Ausnahme von der Regel
  • Direkte Instanzen werfen
  • Beliebige Exceptions fangen
  • Eine Exception weiterwerfen
  • 15 Fortgeschrittene Klassen-Techniken
  • Schöner erben
  • Verwandeln Sie Ihre Vererbung
  • Die Zugriffsregeln anpassen
  • Geben Sie doch mal etwas anderes zurück
  • Mehrfachvererbung
  • Virtuelle Vererbung
  • Freundklassen und Freundfunktionen
  • Klassen und Typen in Klassen nutzen
  • Eine Klasse verschachteln
  • Typen innerhalb von Klassen
  • 16 Klassen mit Templates erzeugen
  • Eine Klasse zum Template machen
  • Ein Template vom Code der Funktionen trennen
  • Statische Mitglieder in ein Template einsetzen
  • Ein Template parametrisieren
  • Verschiedene Parametertypen
  • Mehrere Parameter verwenden
  • Ein »typedef« für ein Template
  • Templates ableiten
  • Eine Klasse von einem Klassen-Template ableiten
  • Ein Klassen-Template von einer Klasse ableiten
  • Ein Klassen-Template von einem Klassen-Template ableiten
  • Ein Funktionstemplate erstellen
  • Funktionstemplates überladen
  • Eine Mitgliedsfunktion mit einem Template versehen
  • 17 Mit der Standardbibliothek programmieren
  • Aufbau der Standardbibliothek
  • Container für Ihre Klassen
  • In einem Vektor abspeichern
  • Daten per »map« ablegen
  • Instanzen, Zeiger oder Referenzen im Container verwalten
  • Instanzen vergleichen
  • Durch einen Container iterieren
  • Viele kleine Pärchen
  • Das große Container-Finale
  • Mit einem »set« zuweisen und speichern
  • Mit »set« Vereinigungs- und Schnittmengen bilden
  • Eine Liste mit »list«
  • Stapeln Sie auf der Deque
  • Mit Stacks und Queues schön in einer Reihe warten
  • Container kopieren
  • Dynamische Arrays erzeugen und einsetzen
  • Die IDE konfigurieren
  • Ein dynamisches Array deklarieren
  • Mit ungeordneten Daten arbeiten
  • Mit »std::unordered_set« ein ungeordnetes Set erstellen
  • Ungeordnete Sets bearbeiten
  • 18 Mit Lambda-Ausdrücken arbeiten
  • Besser lesbaren und prägnanteren C++-Code schreiben
  • Einen einfachen Lambda-Ausdruck definieren
  • Die Teile eines Lambda-Ausdrucks definieren
  • Den Compiler den Rückgabewert ermitteln lassen
  • Einen bestimmten Rückgabetyp verwenden
  • Das Schlüsselwort »auto« verwenden
  • Anwendungen mit Lambda-Ausdrücken entwickeln
  • Lambda-Ausdrücke mit mehreren Eingabeparametern erstellen
  • Mit der Capture-Klausel arbeiten
  • Daten mit einem Lambda-Ausdruck sortieren
  • Festlegen, dass der Lambda-Ausdruck Exceptions wirft
  • Teil IV Probleme beheben
  • 19 Mit Bugs umgehen
  • Das ist kein Bug, das ist ein Feature
  • Die Features einer Anwendung wie Features aussehen lassen
  • Etwas (fast) vorhersehen
  • Kurz und bündig: Fehler vermeiden
  • 20 Eine Anwendung debuggen
  • Mit Debuggern programmieren
  • Der Code::Blocks-Debugger im Überblick
  • Die Debuggingfenster des Code::Blocks-Debuggers
  • Mit anderen Werkzeug debuggen
  • Standarddebugger
  • Eine Code::Blocks-Anwendung mit Argumenten auf der Befehlszeile debuggen
  • 21 Den Code anhalten und untersuchen
  • Haltepunkte für Fortgeschrittene
  • Haltepunkt in Code::Blocks setzen
  • Haltepunkte aktivieren und deaktivieren
  • Variablen beobachten, untersuchen und ändern
  • Variablen beobachten
  • Objekte beobachten
  • Werte ändern
  • 22 Der Stack
  • Ihre Daten stapeln
  • Im Stack herumreisen
  • Lokale Variablen speichern
  • Mit weitergehenden Programmfunktionen debuggen
  • In Assemblercode einer Spur nachgehen
  • Teil V Dateien lesen und schreiben
  • 23 Informationen mit der Bibliothek »Streams« ablegen
  • Warum Streams notwendig sind
  • Mit der Streams-Bibliothek programmieren
  • Die richtige Headerdatei erhalten
  • Eine Datei öffnen
  • Umgang mit Fehlern beim Öffnen einer Datei
  • Hissen Sie die ios-Flaggen
  • 24 Mit Output-Streams schreiben
  • Mit dem &&-Operator einfügen
  • Formatieren Sie Ihre Ausgabe
  • Mit Flags formatieren
  • Die Präzision festlegen
  • Felder erstellen und ihre Breite setzen
  • 25 Aus Input-Streams lesen
  • Mit Operatoren extrahieren
  • Mit dem Dateiende umgehen
  • Verschiedene Typen einlesen
  • Formatierte Eingabewerte einlesen
  • 26 Mit Verzeichnissen und Dateien arbeiten
  • Mit Verzeichnissen arbeiten
  • Ein Verzeichnis erstellen
  • Ein Verzeichnis löschen
  • Den Inhalt eines Verzeichnisses ermitteln
  • Dateien kopieren
  • Dateien und Verzeichnisse verschieben und umbenennen
  • 27 Streamen Sie Ihre eigenen Klassen
  • Eine Klasse als Text streamen
  • Einen Stream manipulieren
  • Was ist ein Manipulator?
  • Schreiben Sie Ihren eigenen Manipulator
  • Teil VI Anwendungen planen und entwerfen
  • 28 Das Programm mit UML beschreiben
  • Zu UML aufsteigen
  • Mit UML modellieren
  • Mit UML schematisiert darstellen und entwerfen
  • Mit UML und dem Rational Unified Process entwickeln
  • Iterativ sprechen
  • Rein in die Phase, raus aus der Phase
  • Die Konzeptionsphase
  • Die Entwurfsphase
  • Die Konstruktionsphase
  • Die Übergabephase
  • Und weiter geht's mit UML
  • 29 Die Klasse mit UML strukturieren
  • Klassen zeichnen
  • Klassen mit UML abbilden
  • UML und Vererbung
  • Klassen aggregieren und zusammensetzen
  • Komponenten erstellen
  • Die Software verteilen
  • 30 Mit UML ein Verhalten aufzeigen
  • Objekte zeichnen
  • Anwendungsfälle inspizieren
  • Anwendungsfälle erweitern
  • Anwendungsfälle und Anforderungen in Übereinstimmung bringen
  • Sequenzdiagramme
  • Sequenzdiagramme mit Anmerkungen versehen
  • Schleifen und Vergleiche in Sequenzdiagrammen
  • Kollaborationsdiagramme
  • Aktivitätsdiagramme
  • Zustandsdiagramme
  • 31 Anwendungen mit UML modellieren
  • UML-Schmankerl
  • Symbole packen
  • Diagramme mit Anmerkungen versehen
  • Symbole kennzeichnen
  • Frei zu sein bedarf es wenig
  • C++ und UML
  • Aufzählungen zeichnen
  • Statische Mitglieder einbinden
  • Klassen über Templates mit Parametern versorgen
  • Teil VII Fortgeschrittenes C++
  • 32 Eine Reise durch die Standardbibliothek
  • Kategorien der Standardbibliothek
  • Container
  • Iteratoren
  • Algorithmen
  • Funktoren
  • Utilities
  • Allokatoren
  • Polymorphe Allokatoren
  • Strings mit einem Hash parsen
  • Informationen über einen Iterator mit wahlfreiem Zugriff abrufen
  • Werte mit dem Find-Algorithmus ermitteln
  • Den Zufallszahlengenerator verwenden
  • Mit min und max arbeiten
  • 33 Eigene Templates erstellen
  • Ein einfaches Mathematik-Template erstellen
  • Ein Struktur-Template erstellen
  • Ein Klassen-Template entwickeln
  • Template-Spezialisierung
  • Eine Bibliothek erstellen
  • Das Bibliotheksprojekt definieren
  • Das Bibliotheksprojekt konfigurieren
  • Schreiben Sie den Code für die Bibliothek
  • Setzen Sie Ihre Bibliothek ein
  • 34 Boost erforschen
  • Boost verstehen
  • Features von Boost
  • Lizenzen
  • Bezahlter Support
  • Boost herunterladen und für Code::Blocks installieren
  • Packen Sie Boost aus
  • Setzen Sie die Header-Only-Bibliotheken ein
  • Bauen Sie die Bibliotheken
  • Testen Sie die Installation
  • Bauen Sie Ihre erste Boost-Anwendung mit DateTime
  • Die Boost-Tools erstellen
  • Boost.Build einsetzen
  • Einen erfolgreichen Build durchführen
  • Die Beispiele einsetzen
  • Regression verwenden
  • Inspect einsetzen
  • BoostBook verstehen
  • QuickBook einsetzen
  • »bcp« einsetzen
  • Wave einsetzen
  • 35 Mit Boost weitergehen
  • Strings mit RegEx durchsuchen
  • Die RegEx-Bibliothek hinzufügen
  • Den RegEx-Code schreiben
  • Strings mit dem Tokenizer aufteilen
  • Numerische Umwandlungen vornehmen
  • Bessere Schleifen mit Foreach schreiben
  • Mit Filesystem auf das Betriebssystem zugreifen
  • Anhang Automatisieren Sie Ihre Anwendungen durch Makefiles
  • Kompilieren und Linken
  • Automatisieren Sie Ihre Arbeit
  • Mit Inferenz-Regeln Anwendungen bauen
  • Regeln verwenden, die von anderen Regeln abhängen
  • Bestimmte Elemente erstellen
  • Von mehreren Dateien abhängig sein
  • Kompilieren und Linken mit make
  • Aufräumen
  • Makros einsetzen
  • Das Beste aus Makefiles herausholen
  • Stichwortverzeichnis
  • End User License Agreement

 Einführung


C++ ist die Sprache des Jahrtausends. Warum ist C++ so beliebt?

Es ist leistungsstark. Sie können damit so gut wie jedes Programm schreiben.

Es ist schnell, und es wird vollständig kompiliert, was eine gute Sache ist.

Es ist nicht schwer, es zu verwenden - wenn Sie dieses Buch besitzen.

Es ist objektorientiert. Wenn Sie nicht genau wissen, was das ist, machen Sie sich nichts daraus. Was das ist, finden Sie sehr schnell heraus, wenn Sie dieses Buch lesen.

Es ist portierbar. Es gibt für so gut wie jeden Computer die entsprechende Version.

Es ist standardisiert. Das American National Standards Institute (ANSI) und die International Standards Organization (ISO) haben einer offiziellen Version ihren Segen gegeben.

Es wird ständig aktualisiert, um den sich laufend ändernden Herausforderungen der Computergemeinde zu entsprechen.

Es ist beliebt. Viele setzen auf C++, weil es von vielen anderen verwendet wird.

Natürlich gibt es auch C++-Kritiker, von denen aber die meisten diese Programmiersprache nicht verstehen oder einfach nur einen schlechten Tag haben. Oder es kommt beides zusammen.

Sie benötigen keinerlei Erfahrung

Dieses Buch enthält kein leeres Gerede über C++. Es ist ein interaktives Rollen-Sie-die-Ärmel-hoch-Buch, mit dessen Hilfe Sie C++ wirklich erlernen können.

Sie erfahren in dieser Auflage, wie Sie an eine erstklassige C++-Installation gelangen. Viele Leser früherer, englischsprachiger Versionen dieses Buches haben uns geschrieben, dass Sie es einfach nicht geschafft haben, C++ dazu zu bringen, mit ihnen zusammenzuarbeiten, und wir haben reagiert und in Kapitel 1 Konfigurationsanleitungen hinzugefügt. Sie finden im Buch Anleitungen für das Arbeiten mit dem Mac und mit Linux und Windows. Auch die Beispiele sind auf allen drei Plattformen positiv getestet worden.

Wir beginnen am Nullpunkt. Wir setzten keinerlei Programmierkenntnisse voraus. Jeder fängt schließlich irgendwann einmal an. Sie können das hier machen. Wir wollen nicht prahlen, aber Sie haben sich in die Hände von ziemlich erfolgreichen C++-Anwendern begeben, die Tausenden von Personen gezeigt haben, wie programmiert wird, und von denen viele ebenfalls bei null angefangen haben.

Und auch die erste Wahl für erfahrene Leute!

Sie kennen C++ bereits? Dann ist dieses Buch auch für Sie genau das Richtige, denn auch wenn wir mit den Grundlagen von C++ beginnen, nehmen wir uns die ganze Sprache vor.

Sie wollen wissen, wie aus einem Klassen-Template eine nicht mehr als Template dienende Klasse abgeleitet wird? Schauen Sie sich Kapitel 16 an.

Sie wollen sehen, wie in C++ ein Observer-Muster erstellt wird? Siehe Kapitel 15.

Sie wollen in der C++-Standardbibliothek den Unterschied zwischen deque und vector herausfinden? Schauen Sie sich Kapitel 17 an.

Sie wollen wissen, wie Sie eine Klasse dauerhaft machen? Siehe Kapitel 27.

Sie wollen wissen, was es mit der Bibliothek Boost auf sich hat, der Bibliothek, die der Standard Template Library (STL) mehr hinzugefügt hat als jede andere Quelle? Beschäftigen Sie sich mit den Kapiteln 35 und 36. Wenn Sie nur C++ und nicht Boost verwenden, verpassen Sie einiges.

Dieses Buch behandelt die neuesten Erweiterungen von C++. Sie wollen zum Beispiel wissen, wie Lambda-Ausdrücke verwendet werden? Schauen Sie sich Kapitel 18, an. In Kapitel 20 finden Sie eine interessante Beleuchtung des Themas Debuggen von Anwendungen mithilfe von Argumenten auf der Befehlszeilenebene, und auch die dynamischen Arrays werden nicht vergessen (Kapitel 17).

Für alle Computer

C++ für Dummies. Alles-in-einem-Band. ist so aufgebaut, dass Sie überall dort mit C++ arbeiten können, wo Ihnen der Sinn danach steht. C++ ist mittlerweile standardisiert, und Sie können die Informationen, die dieses Buch liefert, auf vielen verschiedenen Plattformen nutzen. Wir haben die Beispiele auf Systemen unter Mac OS X, SUSE Linux (einige der »Beta«-Leser verwendeten andere Linux-Versionen) und Windows geschrieben. Damit das auch klappte, haben wir einen Compiler verwendet, der Code::Blocks heißt und auf so gut wie allen Computern (Windows, Linux und Macintosh) läuft. Damit gibt es keine Vorgaben, was den Computer angeht, den Sie verwenden!

Der gesamte Code in diesem Buch ist auf Mac, Windows und Linux getestet worden. (Lassen Sie sich durch die Windows-Screenshots nicht täuschen: Code::Blocks funktioniert problemlos auf allen Plattformen.) Die Beispiele sind nicht auf anderen Plattformen getestet worden, aber da C++ standardisiert ist, sind wir sicher, dass Sie zumindest die ersten Beispiele auf beliebigen Systemen verwenden können.

Konventionen

Auch wenn wir eigentlich wenig mit Konventionen am Hut haben, meinen wir doch, dass es nicht schlecht wäre, wenn wir uns auf ein paar kleine Übereinkünfte einigen könnten, die dieses Buch betreffen. Hier geht es darum, wie der Text in diesem Buch formatiert worden ist:

Wenn Sie etwas im Listingformat sehen, handelt es sich um etwas, das Sie in den Computer eingeben oder auf seinem Bildschirm lesen. Wenn es um etwas geht, das Sie nicht in den Computer eingeben sollen, wird dieser Ausdruck ganz normal formatiert. Wir verwenden diese Formatierung auch für Datei- und Verzeichnisnamen, für URLs und für E-Mail-Adressen.

Code, der auf einer oder mehreren Zeilen steht, sieht so aus:

MeineKlasse.IstCool();

UndDas.IstAuchIhre():

Längere Programmlistings haben einen Titel und eine laufende Nummer, auf die im Text Bezug genommen wird. Es handelt sich dabei um komplette Programme, die Sie eingeben und die dann ausgeführt werden können. Sie können aber viel Zeit und Mühen sparen, indem Sie den Code verwenden, den Sie von der Webseite dieses Buches unter www.wiley-vch.de/publish/dt/books/ISBN3-527-71170-8 herunterladen können.

Wie das Buch aufgebaut ist

Dieses Buch besteht aus sieben Teilen. Jeder von ihnen behandelt ein eigenständiges Thema und enthält Kapitel, von denen sich jedes mit einem eigenständigen Bereich des Hauptthemas beschäftigt.

Sie können das Buch entweder von vorn bis hinten durcharbeiten, oder Sie schauen sich gezielt einzelne Themen an und behandeln das Buch als eine Art Leitfaden - suchen Sie sich aus, was Ihren Bedürfnissen am besten entspricht. Legen Sie das Buch griffbereit in ein Regal und nehmen Sie es zur Hand, wenn Sie etwas nachschlagen müssen. Dies sind die sieben Teile und ihre Inhalte:

Teil I, Los geht's mit C++: Hier fangen wir bei null an und zeigen Ihnen, was Sie benötigen, um mit C++ loslegen zu können und es zum Laufen zu bringen. Gleichzeitig zeigen wir Ihnen in diesem Teil, wie Code::Blocks eingerichtet wird. Wenn Sie Code::Blocks noch nicht auf Ihrem System installiert haben, müssen Sie sich auf jeden Fall um Kapitel 1 kümmern. Dieses erste Kapitel nimmt Sie auch auf eine Reise durch die Features von Code::Blocks mit.

Teil II, Objekte und Klassen verstehen: Wir stellen in diesem Teil wichtige Informationen über die objektorientierte Programmierung vor. Sie erfahren, was Klassen und Objekte sind und was Sie mit Entwurfsmustern anfangen können.

Teil III, Fortgeschrittene Programmierung: Wir schauen uns in diesem Teil anspruchsvollere C++-Themen an. Wenn Sie Teil III gelesen haben, werden aus Anfängern Entwickler mit etwas Erfahrung oder fortgeschrittene Programmierer, und Programmierer mit mittlerer oder größerer Erfahrung beherrschen danach die Sprache C++. Sie finden in diesem Teil Informationen zur neuesten Version von C++, zu denen auch dynamische Arrays, das Arbeiten mit unsortierten Daten und die Verwendung von Lambda-Ausdrücken gehören, die den Code kleiner und besser lesbar machen.

Teil IV, Probleme beheben: Hier zeigen wir Ihnen, wie Sie Ihre Programme debuggen, indem Sie ein spezielles Programm verwenden, das als Debugger bezeichnet wird. Wenn Sie nur über geringe Programmiererfahrung verfügen, also Anfänger sind, zeigt Ihnen dieser Teil, wie Sie Probleme mit Ihren Programmen beheben können. Wenn Sie ein erfahrener Benutzer sind, genießen Sie den Umgang mit dem Debugger, der zusammen mit Code::Blocks ausgeliefert wird, um die Probleme zu lokalisieren, die in Ihren Programmen auftauchen können.

Teil V, Dateien lesen und schreiben: Ja, der gesamte Teil ist dem Auslesen und Schreiben von Dateien gewidmet. Wir behandeln in diesem Buch die Stream-Programmierung, bei der es sich um einen besonderen Weg handelt, wie C++ mit Dateien umgeht.

Teil VI, Anwendungen planen und entwerfen: In diesem Teil geht es um die Planung Ihrer Anwendung, das heißt um die Vorarbeiten, auf die Sie eigentlich nur bei kleinen Projekten verzichten können - und das auch nur dann, wenn Sie bereits über Programmiererfahrung verfügen. Wir stellen in diesem...

Dateiformat: ePUB
Kopierschutz: Adobe-DRM (Digital Rights Management)

Systemvoraussetzungen:

Computer (Windows; MacOS X; Linux): Installieren Sie bereits vor dem Download die kostenlose Software Adobe Digital Editions (siehe E-Book Hilfe).

Tablet/Smartphone (Android; iOS): Installieren Sie bereits vor dem Download die kostenlose App Adobe Digital Editions (siehe E-Book Hilfe).

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

Das Dateiformat ePUB ist sehr gut für Romane und Sachbücher geeignet - also für "fließenden" Text ohne komplexes Layout. Bei E-Readern oder Smartphones passt sich der Zeilen- und Seitenumbruch automatisch den kleinen Displays an. Mit Adobe-DRM wird hier ein "harter" Kopierschutz verwendet. Wenn die notwendigen Voraussetzungen nicht vorliegen, können Sie das E-Book leider nicht öffnen. Daher müssen Sie bereits vor dem Download Ihre Lese-Hardware vorbereiten.

Bitte beachten Sie bei der Verwendung der Lese-Software Adobe Digital Editions: wir empfehlen Ihnen unbedingt nach Installation der Lese-Software diese mit Ihrer persönlichen Adobe-ID zu autorisieren!

Weitere Informationen finden Sie in unserer E-Book Hilfe.


Download (sofort verfügbar)

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