Norbert Michelmann, Rolf Hettwer
Programmentwicklung in C/C++ mit Visual Studio 6. Auflage
Bestellnummer 6800
Die in diesem Werk aufgeführten Internetadressen sind auf dem Stand zum Zeitpunkt der Drucklegung. Die ständige Aktualität der Adressen kann vonseiten des Verlages nicht gewährleistet werden. Darüber hinaus übernimmt der Verlag keine Verantwortung für die Inhalte dieser Seiten.
[email protected] www.bildungsverlag1.de Bildungsverlag EINS GmbH Ettore-Bugatti-Straße 6–14, 51149 Köln ISBN 978-3-8237-6800-5 © Copyright 2016: Bildungsverlag EINS GmbH, Köln Das Werk und seine Teile sind urheberrechtlich geschützt. Jede Nutzung in anderen als den gesetzlich zugelassenen Fällen bedarf der vorherigen schriftlichen Einwilligung des Verlages. Hinweis zu § 52a UrhG: Weder das Werk noch seine Teile dürfen ohne eine solche Einwilligung eingescannt und in ein Netzwerk eingestellt werden. Dies gilt auch für Intranets von Schulen und sonstigen Bildungseinrichtungen.
Vorwort Dieser Band aus der Reihe Basiswissen IT-Berufe hat den Teil „Programmentwicklung“ des Lernfeldes 6 „Entwickeln und Bereitstellen von Anwendungssystemen“ zum Inhalt. Das Buch ist in drei Hauptkapitel gegliedert:
üü Grundlagen der prozeduralen Programmierung mit C/C++ üü Einführung in die objektorientierte Programmierung mit C++ üü Windowsprogrammierung mit Visual Studio C++ Die Beispiele wurden mit Visual Studio Community 2015 erstellt. Visual Studio ist eine Marke der Firma Microsoft. Die Programme zur prozeduralen und objektorientierten Programmierung lassen sich jedoch prinzipiell mit jedem C/C++-Compiler realisieren. Für die Windowsprogrammierung ist Visual Studio erforderlich. Aus didaktischen Gründen wurden einerseits die Beispiele stark vereinfacht (z. B. fehlende Plausibilitätsprüfungen und Fehlerroutinen), andererseits ist nicht immer der effizienteste Lösungsweg implementiert. Zum Beispiel formulieren wir aufwendige, dafür aber leicht verständliche Anweisungen und Bedingungen und verzichten in Windowsprogrammen meist auf implizite Typumwandlungen. Zur Sicherung des Lernerfolges und zur Vertiefung enthalten die Kapitel Übungsaufgaben, die Fragestellungen aus den kaufmännischen Lernfeldern aufgreifen. Am Ende der drei Hauptkapitel sind Projektaufträge beschrieben, die ein offenes, handlungsorientiertes und lernfeldübergreifendes Arbeiten in einem Projekt ermöglichen. In den Tabellen zur Erläuterung von Funktionen, .NET-Objekten und Eigenschaften dieser Objekte wurden Auszüge aus der Onlinehilfe von Visual Studio verwendet. Weitere Informationen und Beispieldateien finden Sie im Internet auf der Seite www.bildungsverlag1.de unter der Rubrik BuchPlusWeb. Die Verfasser
3
Inhaltsverzeichnis Vorwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1
Prozedurale Programmierung
1.1 Allgemeine Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 1.1.1 Einführung in die Programmierung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 1.1.2 Geschichte der Programmiersprache C/C++ . . . . . . . . . . . . . . . . . . . . . . . . . 9 1.1.3 Visual Studio C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 1.2 Anwendungen mit Visual Studio C++ erstellen. . . . . . . . . . . . . . . . . . . . . . . . 11 1.2.1 Die Visual Studio C++-Entwicklungsumgebung. . . . . . . . . . . . . . . . . . . . . . . 11 1.2.1.1 Projekt anlegen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 1.2.1.2 Quelltext der Anwendung verfassen und bearbeiten. . . . . . . . . . . . . . . . . . . 12 1.2.1.3 Projekt erstellen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 1.2.1.4 Ausführen und Testen der Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 1.2.1.5 Konfiguration der IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 1.2.2 Konsolenanwendungen erstellen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 1.2.2.1 Aufbau eines C/C++-Programms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 1.2.2.2 Beispiel eines einfachen Programms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 1.3 Grundlagen der Programmiersprache C/C++. . . . . . . . . . . . . . . . . . . . . . . . . 23 1.3.1 Deklarationen von Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 1.3.2 Bezeichner. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 1.3.3 Elementare Datentypen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 1.3.4 Konstanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 1.3.5 Bildschirmausgabe und Tastatureingabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 1.3.5.1 Bildschirmausgaben mit dem Objekt cout. . . . . . . . . . . . . . . . . . . . . . . . . . . 26 1.3.5.2 Tastatureingaben mit dem Objekt cin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 1.3.6 Grundlegende Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 1.3.7 Formatierte Ausgabe mit Manipulatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 1.3.8 Phasen der Programmentwicklung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 1.4 Kontrollstrukturen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 1.4.1 Folgestruktur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 1.4.1.1 Beispiel zur Folge. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 1.4.2 Auswahlstruktur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 1.4.2.1 Vergleichsoperatoren und logische Operatoren. . . . . . . . . . . . . . . . . . . . . . . 37 1.4.2.2 Arten von Auswahlstrukturen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 1.4.2.3 Entscheidungstabellen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 1.4.3 Wiederholungsstrukturen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 1.4.4 Pseudocode. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 1.4.5 Debuggen in Visual Studio C++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 1.5 Weitere Elemente der Sprache C/C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 1.5.1 Zeiger (Pointer). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 1.5.2 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 1.5.3 Einfache Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 1.5.4 Datenaustausch zwischen Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 1.5.4.1 Gültigkeitsbereich von Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 1.5.4.2 Funktion mit Rückgabewert. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 4
Inhaltsverzeichnis
1.5.4.3 Funktion mit Übergabeparameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5.5 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5.5.1 Eindimensionale Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5.5.2 Zweidimensionale Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5.6 Strings. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5.6.1 String-Variablen als Zeichenarray. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5.6.2 Funktionen zur String-Verarbeitung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5.7 Klasse string. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5.8 Strukturen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5.8.1 Einfache Strukturen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5.8.2 Strukturarrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.6 Dateiverarbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.6.1 Zugriff auf sequenzielle Dateien. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.6.2 Sequenzielle Auswertung einer Datei. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.7 Projektauftrag: Leasingverwaltung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
73 78 78 90 94 94 95 95 96 96 98 99 100 103 107
Objektorientierte Programmierung
2.1 Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 2.2 UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 2.2.1 Objektorientierte Modellierung mit UML-Diagrammen. . . . . . . . . . . . . . . . . 110 2.2.1.1 Einführung: UML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 2.2.1.2 Klassendiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 2.2.1.3 Objektdiagramm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 2.2.1.4 Anwendungsfalldiagramm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 2.2.1.5 Aktivitätsdiagramm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120 2.2.1.6 Sequenzdiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 2.3 Einführung: Objektorientierte Programmierung. . . . . . . . . . . . . . . . . . . . . . . 127 2.3.1 Objektorientierung anhand eines einfachen Beispiels. . . . . . . . . . . . . . . . . . . 127 2.3.2 Erzeugen und Verwenden von Klassen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 2.3.3 Methoden einer Klasse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130 2.3.4 Konstruktor und Destruktor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130 2.3.5 Erzeugung von Objekten und Zugriff auf Elemente. . . . . . . . . . . . . . . . . . . . 131 2.3.6 Überladen von Funktionen/Methoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 2.3.7 Strukturierung eines objektorientierten Programms. . . . . . . . . . . . . . . . . . . . 133 2.3.8 Dynamisches Erzeugen von Klasseninstanzen. . . . . . . . . . . . . . . . . . . . . . . . . 136 2.3.9 Dynamisches Erzeugen von Instanzen mit Zeigerarrays. . . . . . . . . . . . . . . . . 137 2.3.10 Vererbung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 2.3.11 Polymorphismus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147 2.4 Projektauftrag: Kontenverwaltung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
3
Windowsanwendungen mit Visual Studio C++
3.1 Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.1 Grundlagen eines fensterbasierten Betriebssystems. . . . . . . . . . . . . . . . . . . . 3.1.2 .NET Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2 Erstellen einer einfachen Windowsanwendung . . . . . . . . . . . . . . . . . . . . . . . 3.2.1 Typen von Eigenschaften. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
152 152 153 156 160 5
Inhaltsverzeichnis
3.2.1.1 Aufzählungstypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161 3.2.1.2 Boolscher Typ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161 3.2.1.3 Klassentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162 3.2.2 Eigenschaften des Objektes Formular. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162 3.2.3 Gestaltung eines Formulars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164 3.2.4 Komponenten des Formulars. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 3.2.4.1 Label-Komponente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 3.2.4.2 TextBox-Komponente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 3.2.4.3 Button-Komponente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166 3.2.5 Platzieren und Ausrichten der Komponenten. . . . . . . . . . . . . . . . . . . . . . . . . 167 3.2.6 Tabulatorreihenfolge. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168 3.2.7 Implementierung der Anwendungsfunktionalität. . . . . . . . . . . . . . . . . . . . . . 169 3.2.8 Ereignisse von Komponenten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170 3.3 Arbeiten mit Strings. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172 3.4 Verwendung von Standardsteuerelementen. . . . . . . . . . . . . . . . . . . . . . . . . . 175 3.4.1 RadioButton und GroupBox. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176 3.4.2 Arbeiten mit mehreren Fenstern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 3.4.3 Informationsdarstellung in Tabellen mit einer DataGridView-Komponente. . . 186 3.4.4 ListBox (Listfeld) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192 3.4.5 ComboBox (Kombinationsfeld). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 3.5 Windowsprogramme mit Menüs und Symbolleisten . . . . . . . . . . . . . . . . . . . 196 3.5.1 Menüleisten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196 3.5.2 Symbolleiste (Toolbar). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201 3.5.3 Aktivieren/Deaktivieren der Toolbar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202 3.6 Verwendung von Systemdialogen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203 3.7 Datenbankanwendungen erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207 3.7.1 Schritte einer Datenbankanwendungsentwicklung. . . . . . . . . . . . . . . . . . . . . 208 3.7.2 Navigieren mit Menüpunkten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214 3.7.3 Arbeiten mit Datenbanken. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216 3.7.4 Verwendung einer DataGridView-Komponente. . . . . . . . . . . . . . . . . . . . . . . 220 3.7.5 Weitere Datenbankoperationen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 3.7.6 Datenflussplan. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231 3.7.7 Zugriff auf eine Datenbank mit zur Laufzeit dynamisch erzeugten SQL-Anweisungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 3.7.7.1 SQL-Zugriff auf eine Datenbank mit Ergebnismenge. . . . . . . . . . . . . . . . . . . 233 3.7.7.2 SQL-Zugriff auf eine Datenbank ohne Ergebnismenge. . . . . . . . . . . . . . . . . . 238 3.8 Projektaufträge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240 3.8.1 Vokabeltrainer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240 3.8.2 SQL-Editor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241 Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242 Bildquellenverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
6
1010101010101010101010101010101010101001010101001010101010010101010 1010010101010010101010100101010101010101010100101010100101010100101 0101001010100101010100101010101010010101010010101010100101010101010 0101010101010101001100101010101001010010101010010101010010101001010 1 Prozedurale Programmierung 1001010010100101011010100101010101010101010101010101010100101001001 0100100101010101010100101010010110100101011010101010101001010111001
1.1
Allgemeine Einführung
In Kapitel 1 werden die Grundlagen der prozeduralen Programmierung mit C/C++ dargestellt. Nach einer allgemeinen Einführung in die Programmierung und die Sprache C werden die Kontrollstrukturen und weitere Elemente von C/C++ behandelt.
ü Einführung – Generationen von Programmiersprachen, C/C++, Visual Studio C++, Erstellen eines Programms – Datentypen, Variablen, Konstanten, Ein- und Ausgabe
ü Kontrollstrukturen – Folge, Auswahl, Wiederholung
ü Weitere Elemente – Zeiger, Funktionen, Arrays, Strukturen
ü Dateiverarbeitung – Verarbeitung sequenzieller Dateien
1.1.1
Einführung in die Programmierung
Ein Programm ist eine Folge von Anweisungen an einen Computer, bestimmte Operationen durchzuführen. Dazu müssen die Anweisungen in einer dem Rechner verständlichen Sprache formuliert werden. Man unterscheidet fünf Generationen von Programmiersprachen:
Programmiersprachen
1. Generation Maschinensprache
– interne Sprache eines Rechners
2. Generation Assembler
– interne Assemblersprache eines Rechners
3. Generation höhere Sprachen (prozedurale Sprachen) –C – FORTRAN – COBOL
4. Generation nicht prozedurale Sprachen
– SQL
5. Generation Wissens- und objektorientierte Sprachen C++ Java PHP
Die interne Sprache eines Computersystems ist die Maschinensprache (Sprache der 1. Generation). Diese Sprache verwendet nur die Symbole 0 und 1, ist also binär. Ursprünglich mussten Computerprogramme in dieser Form erstellt werden. Um die 7
1 Prozedurale Programmierung
1.2.1.3 Projekt erstellen Der Quellcode des Projekts muss im nächsten Schritt in Maschinencode (bzw. einen Zwischencode bei .NET-Anwendungen) übersetzt und gebunden werden. Die erforderlichen Tools werden in der IDE aufgerufen. Wählen Sie im Hauptmenü Erstellen – Projektmappe erstellen (erstellt werden alle Projekte der Projektmappe) oder Erstellen – (erstellt wird nur das gewählte Projekt). Gleiches erreichen Sie über die Kontextmenüs der Projektmappe bzw. des Projekts im Projektmappen-Explorer. Wenn Sie … erstellen auswählen, werden nur neue bzw. überarbeitete Quellcodedateien kompiliert; mit … neu erstellen wird der Quellcode aller Dateien neu kompiliert; … bereinigen entfernt Zwischenergebnisse aus früheren Einstellungen. Erkennt der Compiler beim Übersetzen des Quellcodes einen syntaktisch fehlerhaften Code, erscheint in einem Ausgabefenster eine Fehlermeldung mit näheren Erläuterungen zur Fehlerart. Mit einem Doppelklick auf eine Fehlermeldung springt der Cursor im Codeeditor in die Zeile, die den Fehler verursacht hat (siehe hierzu den Abschnitt 1.4.5 zum Debuggen). Fehler in der Syntax liegen vor, wenn in einem Programm gegen die „Grammatik“ einer Sprache verstoßen wird, d. h. formale Regeln zur Bildung von Wörtern/Sätzen aus bestimmten Zeichen werden nicht eingehalten (Beispiel: Anstelle der C-Anweisung
14
1 Prozedurale Programmierung
3. Anzahl der Blöcke (= Anzahl der Datensätze), die bei einem Lesevorgang einzulesen sind 4. Filepointer, auf den sich der Lesevorgang bezieht Sequenzielles Schreiben einer Datei Die Funktion zum Schreiben eines Datensatzes (fwrite()) ist mit der Funktion fread() zu vergleichen. Mit fwrite() kann ein Datensatz mit einem Funktionsaufruf sequenziell in eine Datei geschrieben werden. Der Aufbau des Datensatzes muss dazu in einer Struktur definiert werden.
Beispiel Prototyp: fwrite() unsigned fwrite(void *ptr, unsigned size, unsigned n, FILE *fistream) Beispiel:
fwrite(&Esatz, sizeof(Esatz), 1, Fpinput);
Die Bedeutung der vier Übergabeparameter der Funktion fwrite() sind den Erläuterungen zur Funktion fread() zu entnehmen.
1.6.2 Sequenzielle Auswertung einer Datei Eine sequenzielle Datei, in der Telefondaten abgespeichert sind, soll ausgewertet werden. Dazu ist eine Liste aller Telefonnummern (mit Nachnamen und Vornamen) auf dem Drucker auszugeben. Um die Logik eines Programms darzustellen, gibt es neben dem Struktogramm noch andere Formen der grafischen Darstellung, z. B. das Jackson-Strukturdiagramm.
Programm: Telefonliste
Programmvorlauf
Programmhauptteil*
Programmnachlauf
Ein Programm zur sequenziellen Auswertung einer Datei lässt sich in drei Module (Programmteile) unterteilen. Im Programmvorlauf werden alle Tätigkeiten ausgeführt, die einmalig zu Beginn einer Verarbeitung notwendig sind:
üü üü üü üü
Deklaration und Definition der Variablen Öffnen der Dateien (inklusive des Fehlerhandlings) Lesen des ersten Datensatzes Drucken des Listenkopfes
Das nächste Modul der Verarbeitung ist der Hauptteil des Programms. Der Hauptteil steht in einer Schleife und ist so lange zu durchlaufen, bis das Ende der Datei (EOF: end of file) erreicht ist. Im Strukturdiagramm wird die Schleife durch das Zeichen * dargestellt. Innerhalb dieses Programmteils erfolgt
üü die Verarbeitung des aktuellen Satzes (z. B. Berechnung, Summenbildung, Ausgabe) und üü das Lesen des nächsten Datensatzes. 103
1010101010101010101010101010101010101001010101001010101010010101010 1010010101010010101010100101010101010101010100101010100101010100101 0101001010100101010100101010101010010101010010101010100101010101010 0101010101010101001100101010101001010010101010010101010010101001010 2 Objektorientierte Programmierung 1001010010100101011010100101010101010101010101010101010100101001001 0100100101010101010100101010010110100101011010101010101001010100001
Kapitel 2 gibt einen Überblick über die Grundzüge des objektorientierten Ansatzes der Programmierung. Allgemeine Grundlagen der Objektorientierung ü Klassen, Objekte, Methoden ü Objektorientierte Analyse (Unified Notation) Objektorientierte Programmierung in C++ ü Klassendeklaration, Methodendefinitionen, Verwendung von Klassen ü Überladen von Funktionen ü Vererbung Seit Anfang der 90er-Jahre hat der Begriff objektorientierte Programmierung im Rahmen der Softwareentwicklung eine immer größere Bedeutung gewonnen. Dies ist vor allem dadurch zu erklären, dass die rein prozedurale Programmierung durch die erhöhten Softwareanforderungen (z. B. Integration aller betrieblichen Bereiche oder einheitliche grafische Oberflächen zur Bedienung der komplexen Software) an ihre Grenzen stieß. Bei kleinen Programmen ist die Funktionalität eines Programms noch recht einfach zu überschauen, aber mit der steigenden Komplexität wird es immer schwieriger, Programme zu erstellen und zu warten. Man kann zwar im Rahmen der strukturierten Programmierung Module (Funktionen) bilden und somit die Übersichtlichkeit erhöhen, aber letztlich bleibt die Produktivität der Programmierung weit hinter den Anforderungen zurück. Nicht nur die Neuerstellung von komplexen Programmen ist beim prozeduralen Programmieransatz problematisch, auch die Veränderung von Programmen (Wartung) führt zu enormen Kosten und Termindruck im Programmierbereich. Ein kleines Beispiel soll dies verdeutlichen. Wird beispielsweise der Datentyp eines Datenfeldes einer Datenbanktabelle geändert, so müssen alle Programme/Funktionen verändert werden, die auf diese Information zugreifen. Der zurückliegende Jahrtausendwechsel hat dies sehr deutlich gemacht. Der Grund hierfür liegt vor allem darin, dass man früher die prozedurale Programmierung von Funktionen (Anweisungsfolgen) in den Vordergrund der Arbeit gestellt hat. Viele Funktionen/Programme greifen auf die gleichen Daten zu. Die Anordnung der Daten kann nicht geändert werden, ohne gleichzeitig alle Funktionen zu modifizieren, die auf diese Daten zugreifen. Die Daten stehen bei dieser Form der Programmierung erst an zweiter Stelle. Genau hier setzt die objektorientierte Programmierung (= OOP) an.
108
2 Objektorientierte Programmierung
Man geht bei der OOP davon aus, dass die Daten der Grund sind, warum Programme existieren. KomponentBeispielsweise ist nicht ein Abschreibungsprofunktionen gramm mit den entsprechenden Algorithmen der Daten bedeutende Teil eines Programms, sondern die (z. B. Nachname, Daten der Anlagengüter, die abzuschreiben sind, Vorname, stehen im Mittelpunkt der Betrachtung. Deshalb Brutto) ist die grundlegende Idee der OOP, sowohl die Daten als auch die Funktionen, die mit diesen Daten arbeiten, in einer einzigen Einheit, einem Objekt (einer Klasse), zu kombinieren. Dabei wer(z. B. ZeigBrutto(), den die Daten gegenüber der Außenwelt gekapSchreibBrutto()) selt, d. h., es ist kein direkter Zugriff auf diese Informationen möglich, man kann lediglich über die Komponentfunktionen/Methoden eines Objektes auf diese Daten zugreifen. Die KompoAußenwelt nentfunktionen bilden somit die Schnittstelle zu anderen Programmen. Werden die Daten eines Objektes verändert, so muss man nur die Komponentfunktionen einer Klasse anpassen, da ja keine weiteren Funktionen direkt auf diese Daten zugreifen können. Wie das obige Schaubild zeigt, werden die Daten (z. B. eines Mitarbeiters) nach außen (gegenüber Programmen/Modulen) verborgen (= information hiding); nur die Methoden (Komponentfunktionen) des Objektes erhalten Zugriff auf diese Daten und können somit die Information an die Außenwelt weitergeben. Sie stellen die Schnittstelle zwischen den Datenfeldern einer Klasse und der Außenwelt dar. Will man also im Rahmen der OOP ein Programmierproblem lösen, so stellt sich zunächst nicht die Frage, wie diese Aufgabenstellung in Funktionen zu unterteilen ist, sondern welche Objekte in dem entsprechenden Bereich existieren, welche Datenstruktur diese Objekte beschreibt und welche Zugriffsnotwendigkeiten für diese Informationen bestehen.
2.1
Klassen
Ein Objekt (= Exemplar, Instanz) ist ein eindeutig identifizierbares Exemplar von Gegenständen, Personen oder abstrakten Elementen (z. B. eine Bestellung oder Rechnung). Es besitzt Eigenschaften/Attribute (= Daten) und hat ein bestimmtes Verhalten (= Methoden). Eine Klasse kann als Beschreibung einer Sammlung von gleichartigen Objekten bezeichnet werden. Man könnte sagen, eine Klasse dient als Mustervorlage. Sie legt fest, welche Daten und welche Funktionen (Methoden) in Objekten dieser Klasse enthalten sein werden. In einem Unternehmen kann man z. B. für die Angestellten eine Klasse deklarieren. Jeder Angestellte ist ein Objekt dieser Klasse. Beschrieben wird ein Angestellter (Objekt) z. B. durch folgende Datenfelder (vereinfachte Darstellung): Datenfelder der Objekte der Klasse Angestellter: Nachname Vorname Brutto
109
3 Windowsanwendungen mit Visual Studio C++
3.2
Erstellen einer einfachen Windowsanwendung
Eine neue Windowsanwendung können Sie über den Menüpunkt Datei – Neu – Projekt erstellen. Wählen Sie aus den installierten Vorlagen Visual C++ Windows – CLR – Leeres CLR-Projekt und legen Sie als Bezeichnung (Name des Projekts) HelloWin fest.
Im nächsten Schritt müssen Sie dem Projekt das Hauptfenster (Windows-Form) hinzufügen. Rufen Sie dazu den Menüpunkt Projekt – Neues Element hinzufügen auf und wählen Sie aus den Vorlagen von Visual C++ UI – Windows Form aus. Als Bezeichner für das Element (Name der Datei) legen Sie Form1.h fest.
156
3 Windowsanwendungen mit Visual Studio C++
Die Formatierung der Werte einer Spalte können Sie durch Starten eines weiteren Assistenten mit der Eigenschaft DefaultCellStyle vornehmen. Es lassen sich Vordergrund-und Hintergrundfarbe oder auch das Darstellungsformat für den Inhalt (Währungsformat, numerische Formatierung oder Datumsformat) festlegen. Im Quellcode des Hauptfensters müssen Sie die Headerdatei des zweiten Fensters einbinden und eine Instanz afaTabelle der Fensterklasse AfaGrid erzeugen. [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14]
public ref class Form1 : public System::Windows::Forms::Form { AfaGrid ^afaTabelle; public: Form1(void) { InitializeComponent(); // //TODO: Konstruktorcode hier hinzufügen. afaTabelle = gcnew AfaGrid(); // } ... }
In der Headerdatei des zweiten Fensters (AfaGrid.h) deklarieren wir im public-Bereich eine double-Variable aw und eine int-Variable nd für die Übergabe der Eingabewerte vom Hauptfenster zum Fenster zur Darstellung der Abschreibungstabelle. [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14] [15]
190
public ref class AfaGrid : public System::Windows::Forms::Form { public: double aw; int nd; public: AfaGrid(void) { InitializeComponent(); // //TODO: Konstruktorcode hier hinzufügen. // } ... }
Bildquellenverzeichnis Bildungsverlag EINS GmbH, Köln: S. 187, 188 Microsoft Deutschland GmbH, Unterschleißheim
244
