Skip to main content

2017 | Buch

Softwareentwicklung mit C++

Einführung mit Visual Studio

insite
SUCHEN

Über dieses Buch

Mit Hilfe von Visual Studio, das im Buch ausführlich vorgestellt wird, werden die Anfänge von C++ erklärt. Der Leser erlernt in einer modernen Entwicklungsumgebung die Grundzüge der objektorientierten Programmierung anhand von C++. Dabei geht der Autor auf C++ 11 ein und erläutert spezifische Features von Visual Studio 2012 bzw. Visual Studio 2015. Mit beispielhaften Problemstellungen wird auf Schnittstellen zu anderen Programmiersprachen eingegangen (Files, Kommunikation). Im Buch werden neben den Grundlagen auch kleine MFC-Programme vorgestellt. In einem separaten Kapitel werden die Grundzüge von Threads erläutert. Damit ist das Buch für alle geeignet, die sich in C++ einarbeiten wollen und die Methoden der Softwareentwicklung erlernen möchten.

Inhaltsverzeichnis

Frontmatter
1. Die Entwicklungsumgebung
Zusammenfassung
Bevor wir richtig anfangen können, sollten wir uns mit einem Entwicklungswerkzeug beschäftigen. Das Entwicklungssystem ist wichtig, weil ein Einsteiger auf dem Gebiet der Softwareentwicklung unbedingt lernen muss, mit mächtigen Systemen umzugehen. Als Entwicklungssystem hatten wir in der Erstauflage das Visual Studio 2012 gewählt; nun wollen wir auch auf das Visual Studio 2015 eingehen. Sie werden sehen, dass dies keine große Umstellung bedeutet. In diesem Kapitel lernen wir, wie man Tabulatoren nutzt, ohne dass sie ärgerliche Nebeneffekte bei anderen Editoren erzielen. Wir werden – zur Vermeidung eines Mouse-Armes – wichtige Hotkeys des Visual Studios 2015 kennenlernen. Außerdem lernen wir, wie man Projekte anlegt und sie sichert. Eine gute Projektverwaltung – zum Beispiel mit dem Werkzeug Visual SourceSafe – ist von enormer Bedeutung. Zuletzt werden wir einige Features des Visual Studios 2015 auflisten.
Dieter Duschl
2. Geschichte und Eigenschaften
Zusammenfassung
In diesem Kapitel werden wir kurz auf die Geschichte von C++ eingehen. Es handelt sich dabei um die wohl einflussreichste Entwicklung der Programmiersprachen der letzten 30 Jahre. Wir werden durch ein C-Programm einen Übergang von C nach C++ skizzieren. Wenn Sie keine C-Erfahrung haben, so müssen Sie einfach gewisse Dinge so akzeptieren, wie sie dargestellt sind. Es wäre allerdings günstig, wenn Ihnen der Begriff der Struktur (struct), der bei diesem Übergang fundamental ist, bekannt ist. Anderenfalls verweisen wir auf die Folgekapitel oder Sekundärliteratur.
Dieter Duschl
3. Grundlagen
Zusammenfassung
In diesem Kapitel werden wir wiederholen, was wir von der Sprache C her kennen müssten. Wir werden die fünf Grunddatentypen in C/C++ kennenlernen. Zum besseren Verständnis dieser Typen werden wir Variablen dieser Typen auf der Konsole darstellen. Dafür benötigen wir das erste Objekt: cout. Das nutzen wir, um Texte auf der Konsole ausgeben zu können. Außerdem lernen wir das Objekt cin kennen. Zur Darstellung der Daten auf der Konsole benötigen wir auch die hier vorgestellten Escapesequenzen und Umwandlungszeichen. Bitte denken Sie daran, dass die Konsolenausgabe für Sie auch so etwas wie eine Verifikation Ihres Programmes ist; sie ist also so etwas wie ein Debugger für Sie.
Dieter Duschl
4. Konstanten - Variablen - Strukturen
Zusammenfassung
In diesem Kapitel beschäftigen wir uns mit Konstanten, Variablen und Strukturen. In dieser Reihenfolge bilden diese drei Grundelemente wichtiges Rüstzeug für die Softwareentwicklung. Besonderes Augenmerk legen wir dabei auf Strukturen. In Strukturen fassen wir verschiedene Variablen zusammen, die für eine Systembeschreibung geeignet sind. Wir erinnern in diesem Zusammenhang an das Beispielprogramm 2.1 auf Seite 29. Der Begriff der Struktur ist von fundamentaler Bedeutung und geht in der OO in den Begriff der Klasse über.
Dieter Duschl
5. Verzweigungen und Schleifen
Zusammenfassung
In diesem Kapitel werden wir uns mit grundlegenden Schlüsselwörtern der Sprache C/C++ beschäftigen, die zu Programmverzweigungen führen. Viele davon haben wir bereits in den vergangenen Kapiteln genutzt. Sie sind in der Tabelle 4.1 auf Seite 70 zusammengefasst. Ganz konkret wird es in diesem Kapitel um die folgenden Anweisungen gehen:
• Die if-Anweisung
• Der ternäre Operator
• Die switch-Anweisung
• Die for-Anweisung
• Die while-Anweisung (kopflastige while-Schleife)
• Die do-Anweisung (fußlastige while-Schleife)
• Die break-Anweisung
• Die continue-Anweisung
• Die goto-Anweisung
Selbstverständlich gilt auch für dieses Kapitel: man kann sich all diese Schlüsselwörter mit der Hilfe F1 klarmachen.
Dieter Duschl
6. Klassen und Objekte
Zusammenfassung
In diesem Kapitel werden wir das zentrale Schlüsselwort der OOP kennenlernen: class. Wir werden sehen wie dieser Begriff aus dem Begriff struct erwuchs und werden erkennen, dass ein Objekt nichts anderes ist als eine Variable, eine Instanz einer Klasse. Somit wird klar werden, dass OO-Programmierung eine sinnvolle Erweiterung der modularen Programmierung ist; mehr noch: wir werden erkennen, dass – in gewissen Maßen – die OOP auch schon mit modularen Sprachen möglich und teilweise auch sinnvoll gewesen wäre.
Dieter Duschl
7. Exceptionhandling in C++
Zusammenfassung
In allen bisher besprochenen Kapiteln sind wir davon ausgegangen, dass immer alles so funktioniert, wie wir es erhoffen. Nun ist die gelebte Realität bei weitem nicht so. Ein einfaches new kann einmal nicht funktionieren; der Speicher ist einfach defekt und es kann deshalb kein Speicher reserviert werden. Was tun? Wie geht man damit um? Die allgemein angetroffene These ist dann meist, dass man da auch nichts tun kann. Sicherlich, Sie können nicht verhindern, dass es zu so einem Ausfall kommt, aber Sie können Vorkehrungen treffen, dass bei einem solchen Ausfall das Programm nicht gleich terminiert. Und Sie sollten sich ”workarounds” ”stricken”, die sicherstellen, dass Sie einen solchen Ausfall leicht im Nachhinein detektieren können. Oder stellen Sie sich einfach vor, Sie haben einen Softwarefehler gemacht – niemand ist vollkommen. Wie können Sie diesen feststellen? Oder ein Nutzer Ihrer Software bedient diese so, wie er es nicht tun sollte; das Programm stürzt ab. Wie detektieren Sie eine derartige ”Fehlbedienung”? In diesem Kapitel wollen wir solche Fehlersituationen behandeln und Lösungen kennenlernen, wie man in bestimmten Situationen reagieren sollte.
Dieter Duschl
8. Arbeiten mit Files
Zusammenfassung
Bisher haben wir Programme geschrieben, die auf der Konsole Ausgaben erzeugt haben. Ein Großteil dieser Ausgaben wäre Ihnen aber in einem File hilfreicher gewesen. Sie können davon ausgehen, dass das Arbeiten mit Files eine unabdingbare Voraussetzung ist, erfolgreiche Software zu entwickeln. Sie werden in Ihrer Software immer wieder Daten generieren, die nach dem Ausschalten des Rechners nicht verlorengehen dürfen. In diesem Zusammenhang sprechen wir von der Persistenz der Daten. Die Sicherung solcher Daten erfolgt üblicherweise in Files, die im Allgemeinen auf der Festplatte gespeichert werden. Natürlich können Sie diese Daten auch auf anderen nicht flüchtigen Medien wie USB, SD-Cards, MO Disks etc. sichern. Um solche Sicherungen durchführen zu können, brauchen Sie Kenntnisse, wie man Daten in Files schreibt, wie man diese Daten wieder lesen kann und ggf. wieder ändern kann. Sie sollten wissen, wie man Files
• erzeugt,
• sie wieder löscht,
• sie prüft, ob sie vorhanden sind
• und wie man Files lesen und schreiben kann.
Damit wollen wir uns in diesem Kapitel beschäftigen.
Dieter Duschl
9. Vererbung und Overloading
Zusammenfassung
Eine der hervorragendsten Eigenschaft der OOP ist die Vererbung. Dabei können Sie Methoden und Member einer Basis-Klasse einer spezielleren Klasse zuführen. Der tiefere Sinn besteht darin, dass man Code der Basis-Klasse in der spezielleren Klasse – wir nennen sie fortan abgeleiteten Klasse – nutzen kann. Damit umgeht man Code-Redundanzen und macht somit das Programm wartbarer, übersichtlicher, verständlicher (bei vernünftiger Nutzung dieses Features!) und letztlich auch weniger fehleranfällig; denn doppelter Code verdoppelt auch die Fehlerwahrscheinlichkeit. Neben der einfachen Vererbung werden wir uns auch mit virtuellen Methoden beschäftigen. Das sind Methoden einer Klasse, die erst zur Laufzeit des Programmes ihren Code ”erhalten”. Am Ende dieses Kapitels wollen wir uns mit Overloading beschäftigen. Dabei lernen Sie das Überladen von Funktionen und von Operatoren kennen.
Dieter Duschl
10. Polymorphismus
Zusammenfassung
Der Begriff Polymorphie ist aus dem Griechischen entlehnt und bedeutet soviel wie Vielgestaltigkeit. In der OOP versteht man unter Polymorphie die Möglichkeit, verschiedene Member unabhängig von ihrer Verwendung mit dem gleichen Namensbezeichner zu verwenden. Das mag verwirrend klingen, dient aber auch nur der Vereinfachung und der Transparenz Ihrer Software. Wir lernen in diesem Kapitel den Unterschied zwischen früher Bindung (early binding) und später Bindung (late Binding) kennen. Außerdem werden wir den Begriff der abstrakten Klasse kennenlernen.
Dieter Duschl
11. Templates
Zusammenfassung
Ein grundlegendes Ziel der OOP ist, mit minimalem Codeaufwand ein optimales Ergebnis zu erzielen. Wir sollten immer davon ausgehen, dass die Anzahl der Fehler einer Software in der Regel in direkter Proportionalität zu den ”lines of code” (LOC) steht. Das heißt: je weniger Sie codieren, desto sicherer wird Ihre Software sein. Natürlich sollte dieser Gedanke nicht bis zum Extremum gedacht werden: wenn Sie gar nichts codieren, so haben Sie zwar keine Fehler, aber auch keinen Code. Sie haben also nichts produziert. Trotzdem wollen wir immer darauf achten, unseren Code kurz und transparent zu halten. Er sollte universell einsetzbar sein. Das Prinzip der Templates wird uns dabei helfen. Damit – mit dem Prinzip der Templates – wollen wir uns in diesem Kapitel beschäftigen. Das Wort Template kommt aus dem Englischen und bedeutet soviel wie Schablone oder Vorlage und beschreibt damit auch sehr gut den Sinn von Templates: wir wollen Code-Vorlagen erstellen, die es ermöglichen, prinzipiell identischen Code mit verschiedenen Typen bzw. Strukturen laufen zu lassen. Wir wiederholen in diesem Kapitel den Begriff des Makros, machen uns Funktions-Templates klar und beschäftigen uns mit Template-Klassen.
Dieter Duschl
12. Threads
Zusammenfassung
Viele praxisrelevante Probleme sind über Threads lösbar. Dazu sollte man wissen, was man unter einen Thread versteht. In diesem kleinen Kapitel wollen wir uns deshalb mit Threads beschäftigen. Wir wollen uns über Sinn und Bedeutung von Threads klar werden. An den Begriff Threads ist unmittelbar der Begriff des kritischen Abschnitts geknüpft (critical section). Sie werden verstehen, warum man dieses Feature benötigt. Und am Ende des Kapitels Threads werden wir sehen, wie man Objekte in Threads nutzen kann. Bevor wir uns mit Threads beschäftigen, wollen wir verstehen wie die Konsole funktioniert. Denn wir wollen den Begriff des Threads mit Hilfe von Zugriffen auf die Konsole erläutern. Bei dieser Gelegenheit werden Sie verstehen, wie man direkt auf die Hardware der Konsole zugreifen kann: Sie können Farben, Positionen und natürlich Zeichen setzen. Dieses Kapitel beschreibt weitestgehend die Nutzung von Threads unter Windows. Sie werden allerdings nach dem Studium dieses Kapitels die Thematik Threads auch in anderen Betriebssystemen anwenden können; die Begrifflichkeit ist ähnlich und der Sinn identisch.
Dieter Duschl
13. Abschluss und Ausblick
Zusammenfassung
Wir haben uns in diesem Buch mit objektorientierter Softwareentwicklung beschäftigt. Dabei ging es um zwei wesentliche Punkte:
1. Alle Beschreibungen sollten auch ohne C-Vorkenntnisse verstanden werden.
2. Alle Beispiele sollten mit dem VS 2012 leicht und in kurzer Zeit nachvollzogen werden können.
Wir haben – wo es sich anbot – Neuerungen von C++ 11 einfließen lassen. Aber das auch nur an einigen wenigen Beispielen. Schließlich ging es nicht vorrangig um C++ 11, sondern um Softwareentwicklung; natürlich am Beispiel von C++. In diesem abschließenden Kapitel werden wir noch weitere Schlüsselwörter von C++ kennenlernen. Außerdem wollen wir ein weiteres GUI-Projekt generieren.
Dieter Duschl
Backmatter
Metadaten
Titel
Softwareentwicklung mit C++
verfasst von
Dieter Duschl
Copyright-Jahr
2017
Electronic ISBN
978-3-658-18123-9
Print ISBN
978-3-658-18122-2
DOI
https://doi.org/10.1007/978-3-658-18123-9