Listing R1.1 - Rückblick auf die erste Woche
1: #include <iostream.h>
2: intintboolfalsetrue
3: enum CHOICE { DrawRect = 1, GetArea,
4: GetPerim, ChangeDimensions, Quit};
5: // Deklaration der Klasse Rectangle
6: class Rectangle
7: {
8: public:
9: // Konstruktoren
10: Rectangle(int width, int height);
11: ~Rectangle();
12:
13: // Zugriffsfunktionen
14: int GetHeight() const { return itsHeight; }
15: int GetWidth() const { return itsWidth; }
16: int GetArea() const { return itsHeight * itsWidth; }
17: int GetPerim() const { return 2*itsHeight + 2*itsWidth; }
18: void SetSize(int newWidth, int newHeight);
19:
20: // Verschiedene Methoden
21:
22:
23: private:
24: int itsWidth;
25: int itsHeight;
26: };
27:
28: // Implementierungen der Methoden
29: void Rectangle::SetSize(int newWidth, int newHeight)
30: {
31: itsWidth = newWidth;
32: itsHeight = newHeight;
33: }
34:
35:
36: Rectangle::Rectangle(int width, int height)
37: {
38: itsWidth = width;
39: itsHeight = height;
40: }
41:
42: Rectangle::~Rectangle() {}
43:
44: int DoMenu();
45: void DoDrawRect(Rectangle);
46: void DoGetArea(Rectangle);
47: void DoGetPerim(Rectangle);
48:
49: int main ()
50: {
51: // ein Rechteck mit den Werten 30,5 initialisieren
52: Rectangle theRect(30,5);
53:
54: int choice = DrawRect;
55: int fQuit = false;
56:
57: while (!fQuit)
58: {
59: choice = DoMenu();
60: if (choice < DrawRect || choice > Quit)
61: {
62: cout << "\nAuswahl ungueltig. Bitte neu versuchen.\n\n";
63: continue;
64: }
65: switch (choice)
66: {
67: case DrawRect:
68: DoDrawRect(theRect);
69: break;
70: case GetArea:
71: DoGetArea(theRect);
72: break;
73: case GetPerim:
74: DoGetPerim(theRect);
75: break;
76: case ChangeDimensions:
77: int newLength, newWidth;
78: cout << "\nNeue Breite: ";
79: cin >> newWidth;
80: cout << "Neue Hoehe: ";
81: cin >> newLength;
82: theRect.SetSize(newWidth, newLength);
83: DoDrawRect(theRect);
84: break;
85: case Quit:
86: fQuit = true;
87: cout << "\nVerlassen...\n\n";
88: break;
89: default:
90: cout << "Fehler beim Auswaehlen!\n";
91: fQuit = true;
92: break;
93: } // Ende von switch
94: } // Ende von while
95: return 0;
96: } // Ende von main
97:
98: int DoMenu()
99: {
100: int choice;
101: cout << "\n\n *** Menue *** \n";
102: cout << "(1) Rechteck zeichnen\n";
103: cout << "(2) Flaeche\n";
104: cout << "(3) Umfang\n";
105: cout << "(4) Groesse veraendern\n";
106: cout << "(5) Beenden\n";
107:
108: cin >> choice;
109: return choice;
110: }
111:
112: void DoDrawRect(Rectangle theRect)
113: {
114: int height = theRect.GetHeight();
115: int width = theRect.GetWidth();
116:
117: for (int i = 0; i<height; i++)
118: {
119: for (int j = 0; j< width; j++)
120: cout << "*";
121: cout << "\n";
122: }
123: }
124:
125:
126: void DoGetArea(Rectangle theRect)
127: {
128: cout << "Flaeche: " << theRect.GetArea() << endl;
129: }
130:
131: void DoGetPerim(Rectangle theRect)
132: {
133: cout << "Umfang: " << theRect.GetPerim() << endl;
134: }
*** Menue ***
(1) Rechteck zeichnen
(2) Flaeche
(3) Umfang
(4) Groesse veraendern
(5) Beenden
1
******************************
******************************
******************************
******************************
******************************
*** Menue ***
(1) Rechteck zeichnen
(2) Flaeche
(3) Umfang
(4) Groesse veraendern
(5) Beenden
2
Flaeche: 150
*** Menue ***
(1) Rechteck zeichnen
(2) Flaeche
(3) Umfang
(4) Groesse veraendern
(5) Beenden
3
Umfang: 70
*** Menue ***
(1) Rechteck zeichnen
(2) Flaeche
(3) Umfang
(4) Groesse veraendern
(5) Beenden
4
Neue Breite: 10
Neue Hoehe: 8
**********
**********
**********
**********
**********
**********
**********
**********
*** Menue ***
(1) Rechteck zeichnen
(2) Flaeche
(3) Umfang
(4) Groesse veraendern
(5) Beenden
2
Flaeche: 80
*** Menue ***
(1) Rechteck zeichnen
(2) Flaeche
(3) Umfang
(4) Groesse veraendern
(5) Beenden
3
Umfang: 36
*** Menue ***
(1) Rechteck zeichnen
(2) Flaeche
(3) Umfang
(4) Groesse veraendern
(5) Beenden
5
Verlassen...
In diesem Programm finden Sie fast alle Techniken, die Sie diese Woche gelernt haben. Sie sollten dieses Programm nicht nur eingeben, kompilieren, linken und starten können, sondern inzwischen auch aufgrund der erworbenen Kenntnisse verstehen, was das Programm macht und wie es abläuft.
In den ersten sechs Zeilen finden Sie alle Typen und Definitionen, die im Programm verwendet werden.
Die Zeilen 6 bis 26 deklarieren die Klasse Rectangle. Öffentliche Zugriffsmethoden ermöglichen
es, die Breite und Höhe des Rechtecks abzufragen und neu zu setzen sowie
die Fläche und den Umfang zu berechnen. Die Zeilen 29 bis 40 enthalten die Definitionen
der Elementfunktionen, die nicht inline deklariert wurden.
Die Funktionsprototypen für die Funktionen, die keine Elementfunktionen sind, befinden sich in den Zeilen 44 bis 47. Das Hauptprogramm beginnt in Zeile 49. Ziel dieses Programms ist es, ein Rechteck zu erzeugen und dann ein Menü mit fünf Optionen auszugeben: Rechteck zeichnen, Fläche berechnen, Umfang berechnen, Größe des Rechtecks verändern und Beenden.
In Zeile 55 wird eine Flag-Variable eingerichtet. Solange dieses Flag auf false gesetzt
ist, durchläuft das Menü eine Schleife. Erst durch Auswahl der Option Beenden wird
das Flag auf true gesetzt.
Für die anderen Optionen - mit Ausnahme von ChangeDimensions - wird jeweils eine
passende Funktion aufgerufen. Der Aufbau der switch-Anweisung wird dadurch übersichtlicher.
ChangeDimensions kann keine Funktion aufrufen, da die Größe des Rechtecks
geändert werden soll. Würde das Rechteck einer Funktion wie DoChangeDimensions()
(als Wert) übergeben, beträfen die Änderungen der Abmessungen die lokale
Kopie des Rechtecks in DoChangeDimensions() und nicht in main(). In Kapitel 8, »Zeiger«,
und Kapitel 10, »Funktionen - weiterführende Themen«, zeige ich Ihnen, wie Sie
diese Beschränkung umgehen. Im Moment begnügen wir uns damit, die Änderung in
der main()-Funktion vorzunehmen.
Durch die Anwendung der Aufzählung wird die switch-Anweisung wesentlich übersichtlicher
und besser lesbar. Würde die switch-Anweisung nach Zahlenwerten verzweigen,
die der Anwender eingibt, müßten Sie ständig zur Beschreibung des Menüs
zurückgehen, um herauszufinden, welche Auswahl welche ist.
Zeile 60 prüft, ob die vom Anwender gewählte Option auch tatsächlich vorhanden ist.
Wenn nicht, wird eine Fehlermeldung ausgegeben. Beachten Sie, daß die switch-Anweisung
im default-Block den »unmöglichen« Fall abfängt. Damit soll das Debuggen
erleichtert werden. Funktioniert das Programm, wird diese Anweisung nie erreicht.
Meinen Glückwunsch! Damit wäre die erste Woche geschafft. Jetzt können Sie bereits anspruchsvollere C++-Programme erstellen und verstehen. Es gibt jedoch noch eine Menge zu lernen, und die nächste Woche beginnt mit einem der schwierigsten Themen in C++: den Zeigern. Geben Sie jetzt bloß nicht auf, denn jeden Tag steigen Sie tiefer in die Materie der objektorientierten Programmierung, der virtuellen Funktionen und der vielen fortgeschrittenen Themen dieser leistungsstarken Programmiersprache ein.
Machen Sie jetzt erst einmal eine Pause, und sonnen Sie sich in dem Gefühl, bereits etwas geleistet zu haben. Danach können Sie weiterblättern und mit Woche 2 fortfahren.
© Markt&Technik Verlag, ein Imprint der Pearson Education Deutschland GmbH