Page 1

Einf端hrung in die Programmierung in C/C++

Manfred Mirsch


1

Programmierung und Software-Technik ..................................................3

1.1

Softwaretechnik ............................................................................................3

1.1.1

Ziele der Softwaretechnik .............................................................................3

1.2

Was ist ein Programm? ................................................................................3

1.2.1

Beispiele für Programme: .............................................................................3

1.3

Wie führen Computer Programme aus .........................................................5

1.3.1

Die Hardwarekomponenten eines Computers ..............................................5

1.3.2

Wie führt ein Rechner Programme aus?.......................................................5

1.3.3

Das Speichermodell eines Rechners............................................................5

1.3.4

Das Betriebssystem......................................................................................6

1.4

Wie wird ein C++–Programm ausführbar?....................................................6

1.4.1

Übersetzen und Linken.................................................................................6

1.5

Die C++ Entwicklungsumgebung..................................................................7

2

Erste Schritte zur C++-Programmierung ..................................................8

2.1

Allgemeine Grundlagen von Sprachen .........................................................8

2.1.1

Syntax versus Semantik ...............................................................................8

2.2

Die Struktur einfacher C++-Programme .......................................................8

2.2.1

C++-Fehlermeldungen..................................................................................8

2.2.2

Kommentare in C++......................................................................................9

2.2.3

Einfache Formen von Programmieranweisungen .........................................9

2.3

Deklarationen................................................................................................9

2.3.1

Bezeichner....................................................................................................9

2.3.2

Typen............................................................................................................9

2.3.3

Objekte und Deklarationen .........................................................................10

2.4

Zuweisungen ..............................................................................................11


Programmieren in C++

Manfred Mirsch

2.4.1

Zuweisung in allgemeinen Begriffen ...........................................................11

2.4.2

Zuweisung in C++.......................................................................................11

2.4.3

Werte und Ausdrücke .................................................................................11

2.4.4

Zuweisungen und Zustandsänderungen.....................................................12

2.5

E/A-Anweisungen .......................................................................................12

2.5.1

Eingabe-Anweisungen ................................................................................12

2.5.2

Ausgabe-Anweisungen ...............................................................................13

2.6

Programmschablone...................................................................................13

3

Werte und Ausdrücke...............................................................................14

3.1

Inkrement- und Dekrementoperatoren........................................................14

3.2

Boolesche Ausdrücke .................................................................................14

3.2.1

Boolesche Ausdrücke in C++......................................................................14

4

Steuerflußabstraktionen ..........................................................................17

4.1

Blockbildung in Programmen ......................................................................17

4.2

Auswahlanweisungen .................................................................................17

4.2.1

if-Anweisung...............................................................................................17

4.2.2

switch-Anweisung......................................................................................20

4.3

Wiederholungsanweisungen.......................................................................22

4.3.1

while-Schleife.............................................................................................22

4.3.2

do-Schleife .................................................................................................23

4.3.3

for-Schleife .................................................................................................24

4.4

Funktionsaufrufe .........................................................................................27

4.4.1

Funktionale Abstraktion ..............................................................................27

4.4.2

Parametrisierung von Funktionen ...............................................................27

4.5

Die Funktionsschnittstelle ...........................................................................27

5

Funktionsdefinitionen ..............................................................................29

5.1

Die Funktionsdeklaration ............................................................................29 1


Programmieren in C++

Manfred Mirsch

5.2

Die Funktionsdefinition ...............................................................................29

5.2.1

Der Funktionskopf.......................................................................................29

5.2.2

Der Funktionsrumpf ....................................................................................29

5.2.3

Die Parameter.............................................................................................30

5.2.4

Der Referenz-Typ .......................................................................................31

5.2.5

Wertparameter versus Referenzparameter ................................................32

2


Programmieren in C++

Manfred Mirsch

1 Programmierung und Software-Technik 1.1 Softwaretechnik Dokumentation

Zu Anforderungen lösendes Problem

SoftwareTechnik

Programme

Abfall Wartung und Entwicklung Klärung

Programmbibliothek

Wiederverwendung

1.1.1 Ziele der Softwaretechnik  Wiederverwendbare Softwarebausteine Durch Erstellen von Programmbibliotheken  Dokumentation Anwenderhandbuch, Wartungshandbuch

1.2 Was ist ein Programm?  Ein Weg, irgendein Problem zu lösen.  Eine Folge genauer Anweisungen, die erklären, wie ein gewünschtes Ergebnis erreicht wird.

1.2.1 Beispiele für Programme: Rumpsteak mit Pilzen 4 Portionen Zutaten: 4 Rumpsteaks 30 g Butter 1 Teelöffel (5 ml) Olivenöl 225 g geschnittene Champignons Tasse (125 ml) Sahne

Zubereitung 3


Programmieren in C++

Manfred Mirsch

 Die Steaks mit dem Öl bepinseln und auf einem Rost ruhen lassen.  Die Butter schmelzen und die Pilze hinzugeben. Schieben Sie die Pilze in die Mitte der Bratpfanne, und stellen Sie den Rost mit den Steaks darüber.  Gießen Sie die Sahne in eine ofenfeste Schüssel, und stellen Sie diese auf den Boden des Backofens.  Grillen Sie die Steaks bei 190OC Je nach Geschmack: ca. 20 Minuten für blutig, 25 Minuten für medium und 30 Minuten für durchgebraten.  Heben Sie die Pilze unter die Sahne, lassen Sie kurz ruhen und gießen Sie dann über die Steaks. Beispiel 1: Kochrezept

Motor ausbauen     

Die Haube entfernen, wie in Kapitel 11 beschrieben. Das Kabel vom Minuspol der Batterie entfernen. Den Luftfilter entfernen, wie in Kapitel 3 beschrieben. Den Kühler entfernen, wie in Kapitel 2 beschrieben. Die Klammer lösen und den oberen Schlauch vom Thermostatgehäuse entfernen.  Einen geeigneten Behälter unter den Motor stellen, dann den Ölwannenablaßverschluß abschrauben und das Öl abfließen lassen. Wenn es abgeflossen ist, den Verschluß und die Abflußdichtung reinigen und in der Ölwanne festschrauben. ...  Motor- und Getriebeblock aus dem Motorraum heben. Beispiel 2: Kfz–Reperaturhandbuch

Beispiel 1 (Kochrezept): 1. Festlegung der Zutaten (Objekte) für die Methode Zubereitung: Jedes Objekt ist von einem bestimmten Typ, welcher festlegt, welche Operationen Sie mit dem Objekt durchführen können (z.B. Sahne–gießen, Steak–braten). Einige Objekte haben Werte (1/2 Tasse Sahne). 2. Angabe der Methode: Die Methode (Algorithmus) selbst gibt eine Folge von Schritten an, die befolgt werden müssen, um die Zutaten in ein brauchbares Endergebnis umzuwandeln.

Beispiel 2 (Kfz–Reperaturhandbuch): 1. Benutzung von Funktionen: Unter Punkt 1 wird erwartet, dass der Mechaniker im Kapitel 11 nachschlägt, wie die Haube entfernt wird. Übung: Nicht-Rechner-Programme 4


Programmieren in C++

Manfred Mirsch

1.3 Wie führen Computer Programme aus 1.3.1 Die Hardwarekomponenten eines Computers    

Bildschirm Tastatur Maus Gehäuse mit Prozessor (CPU) Hauptspeicher (RAM) Sekundärspeicher (Festplatte, CD–ROM, Floppy)  Die Komponenten im Gehäuse sind miteinander und mit Tastatur und Maus durch einen Bus verbunden. Hauptspeicher und Sekundärspeicher unterscheiden sich durch: 1. Auf RAM kann wahlfrei zugegriffen werden, Daten von der Platte müssen erst von dort gelesen werden. 2. Daten im RAM gehen beim Abschalten des Rechners verloren. 3. Die Zugriffsgeschwindigkeit auf das RAM ist etwa 1000000 mal so schnell wie die der Festplatte.

1.3.2 Wie führt ein Rechner Programme aus?  Jede CPU hat eine Menge an Kommandos (Befehlssatz), mit denen sie arbeiten kann. Diese Befehle bestehen aus einer Folge von Dualzahlen (Maschinencode).  Maschinencode kann durch Assemblercode dargestellt werden.  Befehle höherer Programmiersprachen können nicht vom Rechner ausgeführt werden. Sie müssen erst in Maschinencode übersetzt werden. 10 Zeilen C++–Code entsprechen 200 Assembler–Befehlen.  Die Arbeit einer CPU besteht darin vom Zeitpunkt des Einschaltens des Rechners bis zum Ausschalten in einer Schleife das nächste Kommando aus dem RAM zu holen und es auszuführen.

1.3.3 Das Speichermodell eines Rechners  Alle Informationen werden in Bits (Binary Digit) dargestellt, einer Ziffer, die 0 oder 1 enthalten kann. 8 Bits werden zu einem Byte zusammengefaßt.  Sowohl die Daten, als auch die Befehle eines Programmes liegen als Folge von Bytes im Hauptspeicher.

5


Programmieren in C++

Manfred Mirsch

Beispiele: 01001110 – Ein Zeichen: Der Buchstabe N 00110000 – Ein Zeichen: Die Ziffer 0 00000000 \ 01001110 / Eine Ganzzahl: 78 00000000 \ 00110000 / Eine Ganzzahl: 48  Die richtige Interpretation des Speicherinhalts muss vom Programm gewährleistet werden. Im Maschinencode oder Assembler, muss der Programmierer dafür sorgen, in Hochsprachen sorgt das Übersetzungsprogramm dafür.

1.3.4 Das Betriebssystem  Das Betriebssystem (MS DOS, UNIX, Windows 95) übernimmt die Steuerung von Geräten. Es stellt Befehle zur Verfügung, um Ein- und Ausgaben zu tätigen.

1.4 Wie wird ein C++–Programm ausführbar? 1.4.1 Übersetzen und Linken  Übersetzer (Compiler) Der Compiler übersetzt den Quelltext in Objektcode (Maschinencode).  Linker Der Linker verbindet den Objektcode und benutzte Programmbibliotheken zum ausführbaren Programm (Executable).  Je nach Portierbarkeit des Quelltextes (Sprache, Betriebssystemspezifische Kommandos) kann ein Programm auf verschiedenen Rechnerplatformen laufen.

Objektcode

C++Quelltext

C++Compiler

Linker

C++Bibliotheken

ausführbares Programm

KomponentenBibliotheken

6


Programmieren in C++

Manfred Mirsch

1.5 Die C++ Entwicklungsumgebung 1. Die Entwicklungsumgebung (IDE) von Visual C++ 6.0 umfaßt die Komponenten  Editor  Compiler  Linker  Debugger  Execute

Übung: Start

7


Programmieren in C++

Manfred Mirsch

2 Erste Schritte zur C++-Programmierung 2.1 Allgemeine Grundlagen von Sprachen 2.1.1 Syntax versus Semantik  Syntax ist die Lehre vom Bau eines Satzes.  Semantik befaßt sich mit der Bedeutung sprachlicher Zeichen und Zeichenfolgen. Beispiele: Syntaktisch und semantisch korrekt: Geben Sie das Öl in die Pfanne. Syntaktisch falsch: Geben das Öl Sie in die Pfanne. Syntaktisch korrekt aber semantisch falsch: Geben Sie die Pfanne in das Öl. Syntaktisch mehrdeutig: Man reibe sechs Tage alte Semmeln. (sechs Tage reiben?)

Programmiersprachen sind syntaktisch eindeutig!

2.2 Die Struktur einfacher C++-Programme #include ... // Benutzte Bibliotheken int main(void) { // Hauptfunktion des Programms Anweisungen // Rumpf der Hauptfunktion } // Ende der Hauptfunktion

2.2.1 C++-Fehlermeldungen    

Der Compiler meldet Syntaxfehler. Er teilt die Stelle (Zeile, Spalte) im Quellcode mit, wo er einen Fehler erkennt. Teilweise wird ein Fehler erst in der folgenden Anweisung entdeckt. Teilweise hat ein Fehler Auswirkungen auf folgenden Programmtext. Deswegen ist es ratsam zu Beginn nur einen oder wenige Fehler zu korrigieren und dann erneut zu übersetzen. Übung: Compilerfehler

8


Programmieren in C++

Manfred Mirsch

2.2.2 Kommentare in C++ Ein Kommentar in C++ ist auf eine Zeile beschränkt und beginnt mit '//'. Der Programmentwurf kann als eine Folge von Kommentaren in ein C++-Programm umgesetzt werden. Die Kommentare können dann Schritt für Schritt durch C++Anweisungen realisiert werden.

2.2.3 Einfache Formen von Programmieranweisungen  Typ-Definitionen: Anweisungen, die neue Typen einführen;  Variablen-Deklarationen: Anweisungen, die neue Objekte einführen;  Wertzuweisungen: Anweisungen, die eine Wertveränderung eines Objekts bewirkt;  E/A-Anweisungen: Anweisungen, die eine Ein- oder Ausgabe bewirken.

2.3 Deklarationen 2.3.1 Bezeichner Beispiele:  Pipi Langstrumpf ist ein Mädchen mit roten Zöpfen, das ihr Pferd

hochstemmen kann.  Ein PC ist ein Rechner mit Bildschirm, Tastatur und Maus, welcher i.a. eine Windows-Oberfläche besitzt. Durch Bezeichner wird ein Objekt (Person, Gegenstand, Pflanze etc.) benannt, welches spezifische Eigenschaften hat.

Bezeichner in Programmiersprachen 1. In Programmiersprachen werden Bezeichner verwendet, um Objekten, Typen oder Funktionen zu repräsentieren. 2. Ein Bezeichner besteht aus einer Folge von Buchstaben, Ziffern und dem Unterstrich ‘_’, wobei das erste Zeichen ein keine Ziffer sein darf.

2.3.2 Typen Typen in Programmiersprachen 1. Programmiersprachen besitzen Standardtypen (Ganzzahlen, Fließkommazahlen und Zeichen). 2. Weiterhin bieten moderne Programmiersprachen dem Programmierer die Möglichkeit, eigene Typen (PDTs) zu definieren. Typen in C++: 9


Programmieren in C++

Manfred Mirsch

 Der Ganzzahl-Typ in C++ heißt int. Sein Wertebereich ist beschränkt auf die ganzen Zahlen zwischen MAXINT und MININT (i.a. -32768 – 32767). Die Operationen für Ganzzahlen sind u.a. die vier Grundrechenarten, der Vergleich zweier Ganzzahlen, sowie die Ein- und Ausgabe.  Der Zeichen-Typ in C++ heißt char. Sein Wertebereich umfaßt die Zeichen der ASCII-Tabelle (bzw. die Ganzzahlen von -128 – 127). An Operationen bietet er den Vergleich zweier Buchstaben und die Ein- und Ausgabe.  Der Fließkommazahl-Typ in C++ heißt float. Sein Wertebereich ist beschränkt auf die ganzen Zahlen zwischen ±2.225074*10-308 und ±1.797693*10308. Die Operationen für Fließkommazahlen entsprechen im wesentlichen denen der Ganzzahlen.

2.3.3 Objekte und Deklarationen Objekte werden durch einen Typ klassifiziert. Beispiele: Objekt Jan Ullrich

Typ

Bjarne Stroustrup

Variablendeklaration In einem Computerprogramm müssen Objekte (Variablen) eingeführt werden. Diese Einführung nennt man Variablendeklaration. Eine Deklarationsanweisung führt: 1. einen neuen Namen ein, den der Variable; 2. legt dessen Typ fest und 3. initialisiert diese eventuell mit einem Wert. C++-Beispiele: char buchstabe; int ganzzahl=0; float fliesskommaZahl=47.11;

Alle Objekte müssen vor ihrer Benutzung deklariert werden.

2.4 Zuweisungen 2.4.1 Zuweisung in allgemeinen Begriffen Unter Zuweisung versteht man eine Speicherung von Werten: 10


Programmieren in C++

Manfred Mirsch

 Termin in Terminkalender eintragen.  Akten in Aktenschrank einordnen. Um diese Aufgabe zu erfüllen (Aktenschrank) ist es sinnvoll, Benennungen für den Ablageort zu verwenden (Tag und Monat im Terminkalender, Fachgebiet für Aktenschrank).

2.4.2 Zuweisung in C++ Datenobjekten können ihren Wert verändern und werden deshalb in Programmiersprachen Variablen genannt. Um den Wert bzw. den Zustand eines Objektes zu ändern gibt es die Möglichkeit der Wertzuweisung durch den sogenannten Zuweisungsoperator (‘=’). Die Syntax einer Zuweisung in C++ lautet: Variablenname = Ausdruck ;

2.4.3 Werte und Ausdrücke Literale Neben den Datenobjekten gibt es sogenannte Literale, Werte eines Objekttyps. Beispiele für Literale: 42 (int) 'a' (char) 31.415926e-01 (float)

Ausdrücke Ausdrücke  erzeugen einen Wert,  können auf der rechten Seite einer Zuweisung stehen,  bestehen aus Literalen und Objekten, sowie Operatoren auf diesen.

Operatoren In C++ gibt es vier Standardoperatoren für die Grundrechenarten (+,-,*,/) sowie den Modulo-Operator % für die Restbestimmung bei Ganzzahldivisionen. Beispiele für Ausdrücke: radius * 2 durchmesser * 3.1415926 11


Programmieren in C++

Manfred Mirsch

(a + b) / 2 a % 2

2.4.4 Zuweisungen und Zustandsänderungen Beispiele: buchstabe = 'x'; monat = 10; kreisFlaeche = radius * radius * 3.14159;

2.5 E/A-Anweisungen 2.5.1 Eingabe-Anweisungen Mittels Eingabe-Anweisungen können Objekte einen neuen Wert erhalten. Die Syntax von Eingabeanweisungen in C++ lautet: cin >> Variablenname [ >> Variablenname ] ; Es können also auch mehrere Objekte mit einer einzigen Anweisungen Eingaben erhalten. Beispiele für Eingaben in C++: char buchstabe; int tag; int monat; int jahr; cin >> buchstabe; cin >> tag >> monat >> jahr;

2.5.2 Ausgabe-Anweisungen Mittels Ausgabe-Anweisungen kann der Wert eines Objekts auf ein externes Gerät ausgegeben werden. Die Syntax von Eingabeanweisungen in C++ lautet:

12


Programmieren in C++

Manfred Mirsch

cout << Ausdruck [ << Ausdruck ] ; Es können also auch mehrere Objekte mit einer einzigen Anweisungen ausgegeben werden. Beispiel für Ausgaben in C++: int tag=5; int monat=5; int jahr=1997; cout << ”Das Geburtsdatum von Jakob lautet: ” << tag << ‘.’ << monat << ‘.’ << jahr;

2.6 Programmschablone Für die Erstellung von C++-Programmen ist es hilfreich, eine Programmschablone zu benutzen, in die dann das konkrete Programm eingefügt wird. #include <iostream.h> int main(void) { // Fügen Sie Ihr Programm hier ein return 0; } // end main()

Übung: Gewichtsindex

13


Programmieren in C++

Manfred Mirsch

3 Werte und Ausdrücke 3.1 Inkrement- und Dekrementoperatoren Die beide Operatoren ++ und -- erhöhen bzw. vermindern eine Ganzzahl-Variable um 1. (Daher kommt auch der Name C++)! Beispiele für Inkrement- und Dekrementoperatoren: int heute=15; int gestern=heute; int morgen=heute; morgen++; gestern--; int a=1; int b=2; int c; c = a++ * b--; c /= a++ * b++;

Die Inkrement- und Dekrementoperatoren sollten nie, wie im Beispiel 2 innerhalb einer Zuweisung benutzt werden, weil die Seiteneffekte zu unübersichtlich sind. Übungen: Zinsen1 und Einkauf1

3.2 Boolesche Ausdrücke Boolesche Ausdrücke werden benutzt, wenn man ausdrücken möchte, ob etwas wahr oder nicht wahr ist. Beispiele: Befindet sich eine CD im CD-Player? Ist der 3. Titel der CD länger als der 4. Titel?

3.2.1 Boolesche Ausdrücke in C++ Um derartige Aussagen in C++ zu formalisieren, gibt es Vergleichsoperatoren. Die wichtigsten Vergleichsoperatoren sind: 14


Programmieren in C++

Manfred Mirsch

== (Gleichheit) != (Ungleichheit) < (Kleiner als) <= (Kleiner gleich) > (größer als) >= (größer gleich)

Der Wert eines booleschen Ausdrucks ist vom Typ bool. Er kann einen der beiden Werte true (wahr) oder false (nicht wahr) haben. Der Datentyp bool ist nicht Bestandteil der Sprache C++ ist aber im ANSII-Entwurf für die nächste Version von C++ akzeptiert worden. Beispiel für boolesche Ausdrücke: int i=15; char ch='P'; bool test=true; i == i != i <= i >= i < i > ch != ch <= test !=

15 15 15 15 14 14 'S' 'Z' false

// // // // // // // // //

true false true true false true true true true

Boolesche Operatoren Zur Verknüpfung von booleschen Ausdrücken gibt es verschiedene Operatoren: ! && ||

(Negation) (logisches und) (logisches oder)

Für die Auswertung boolescher Operatoren gelten folgende Wahrheitstafeln (bitte ausfüllen): A

B

true

true

false

true

true

false

false

false

!A

A && B A || B

15


Programmieren in C++

Manfred Mirsch

Übungen (Welcher Wahrheitswert ergibt sich?) int i=2; (i<j) && (i<j) || (i<j) || (j<i) && (i<j) ||

int j=-4; int k=7; (j<k) (j<k) ((j<k) && (!(j>k))) !(i<j) !(i<j)

Übung: Boolesche Ausdrücke

16


Programmieren in C++

Manfred Mirsch

4 Steuerflußabstraktionen Unter dem Begriff Steuerflußabstraktion werden die Anweisungen zusammengefaßt, die den linearen Ablauf eines Programmes verändern: 1. Auswahlanweisungen 2. Wiederholungsanweisungen 3. Funktionsaufrufe Zu jeder Steuerflußabstraktion werden wir ein Steuerflußabstraktionsdiagramm kennenlernen, welches für den Programmentwurf verwandt werden kann.

4.1 Blockbildung in Programmen Für die folgenden Auswahl- und Wiederholungsanweisungen ist eine Eigenschaft der Sprache C++ wichtig, die Blockbildung genannt wird. Man kann eine Gruppe von Anweisungen zu einem Anweisungsblock zusammenfassen. Eine solche Gruppierung nennt man Verbundanweisung oder Block. Für die Kennzeichnung des Beginns und des Endes werden spezielle Zeichen benötigt (in C++: { und }). Beispiel: { Anweisung 1; Anweisung 2; Anweisung 3; ... }

Eine derart gruppierte Folge von Anweisungen wird vom Compiler wie eine einzige Anweisung betrachtet.

4.2 Auswahlanweisungen Anweisungen, die bestimmen, ob eine oder mehrere Anweisungen ausgeführt werden (if-Anweisung, switch-Anweisung).

4.2.1 if-Anweisung Bedingte Ausführung (if) Die einfachste Form der if-Anweisung besteht aus einem Test und einer Folge von Anweisungen, die nur dann ausgeführt werden, wenn der Testausdruck das Ergebnis true hat. 17


Programmieren in C++

Manfred Mirsch

Boolescher Ausdruck

if (Boolescher Ausdruck) {

true

Anweisungen; Anweisungen

}

Beispiel (Vergleich): const int MAX=9; int zahl; cout << "Bitte << MAX << cin >> zahl; if (zahl <0 || cout << zahl }

geben Sie eine Zahl von 0 bis " "ein"; zahl >MAX) { << "liegt außerhalb der vorgesehenen Eingabe!";

Alternative (if-else) Meistens ist jedoch eine Auswahl gewünscht, in der mindestens zwei Fälle berücksichtigt werden sollen. Für solche Fälle gibt es die if-else-Anweisung. Boolescher Ausdruck

if (Boolescher Ausdruck){ Anweisung1;

true

Anweisung1 Anweisung2

Anweisung2; } else {

false

Anweisung3;

Anweisung3 Anweisung4

Anweisung4; }

Beispiel (Vergleich): const int MAX=9; int zahl; cout << "Bitte << MAX << cin >> zahl; if (zahl <0 || cout << zahl } else { cout << "Die ... }

geben Sie eine Zahl von 0 bis " "ein"; zahl >MAX) { << "liegt außerhalb der vorgesehenen Eingabe!"; Eingabe wird bearbeitet";

18


Programmieren in C++

Manfred Mirsch

Fallunterscheidung (else-if) Wenn man mehr als zwei Alternativen berücksichtigen will, so programmiert man eine geschachtelte if-else-Anweisung, indem man in den else-Teil weitere ifAnweisungen schreibt.

Boolescher Ausdruck 1

if (Boolescher Ausdruck 1){

true

Anweisung1;

Anweisung 1 false

} else if {(Boolescher Ausdruck 2){

Boolescher Ausdruck 2 true

Anweisung2;

Anweisung 2 } else if {(Boolescher Ausdruck 2){

false

Boolescher Ausdruck 3 Anweisung3;

true

Anweisung 3

} else {

Anweisung 4

}

false

Anweisung4;

Beispiel (Vergleich): const int MAX=9; int zahl; cout << "Bitte geben Sie eine Zahl von 0 bis " << MAX << "ein"; cin >> zahl; if (zahl <0) { cout << zahl << "ist kleiner als 0!"; } else if (b>MAX) { cout << zahl << "ist größer als " << MAX << "!"; } else { cout << "Die Eingabe wird bearbeitet"; ... }

Es empfiehlt sich aus Sicherheitsgründen, auch einzelne Anweisungen in geschweiften Klammern zu setzen.

Beispiele (if-else Fehler) Programm

Fehler

int i; if (i>=0) if (i==0) cout << "i gleich 0"; 19


Programmieren in C++

Manfred Mirsch

else cout << "i kleiner 0"; if (i=0) cout << "i gleich 0"; if (i==0); cout << "i gleich 0";

Übung Zinsen2

4.2.2 switch-Anweisung Für eine echte Fallunterscheidung, wenn also je nach Situation eine ganze Reihe von verschiedenen Funktionen ausgeführt werden sollen, ist die else-if-Anweisung unhandlich. Dafür gibt es die switch-Anweisung. Häufiger Anwendungsfall ist eine Menüauswahl. Ausdruck Wert1

Anweisung 1

Wert2

Anweisung 2

Wert3

Anweisung 3

Anweisung 4

switch (Ausdruck){ case wert1: Anweisung1; break; case wert2: Anweisung2; break; case wert3: Anweisung3; break; default: Anweisung4; }

Der Ausdruck muss einen einfachen Typ haben (char, int, float). Die Werte hinter den case-Labels müssen Konstante oder Literale dieses Typs sein. Die default-Anweisung muss nicht vorhanden sein. Sie wird immer dann ausgeführt, wenn keiner der vorher angegebenen Werte zutreffend war. Beispiel (Menü): char auswahl; cout << "Auswahl: (O)pen, (N)ew, (S)ave, (P)rint, (Q)uit "; cin >> auswahl; switch (auswahl) { case 'O': // Datei öffnen break; case 'N': 20


Programmieren in C++

Manfred Mirsch

// Datei anlegen break; case 'S': // Datei speichern break; case 'P': // Datei drucken break; case 'Q': // Abbruch break; default: cout << "Ungültige Auswahl" << endl; } // ende switch (auswahl)

Die break-Anweisung ist normalerweise für jeden Fall zu verwenden. Sie bewirkt, dass nach Beendigung eines Falls an das Ende der switch-Anweisung gesprungen wird. Wird ein break vergessen, so läuft das Programm anschließend in den nächsten Fall, ohne vorher dessen Wert zu überprüfen. Genau dies kann manchmal erwünscht sein. Beispiel (Abfrage): char antwort; cout << "Antworten Sie mit 'J' oder 'j' für JA, " << "und 'N' oder 'n' für NEIN: "; cin >> antwort; switch (antwort) { case 'J': case 'j': cout << "Die Antwort ist JA" << endl; break; case 'N': case 'n': cout << "Die Antwort ist NEIN" << endl; break; default: cout << "Ungültige Antwort" << endl; } // ende switch (antwort)

Übung: Römische Ziffern

21


Programmieren in C++

Manfred Mirsch

4.3 Wiederholungsanweisungen Anweisungen, die andere Anweisungen wiederholt ausführen (while-Anweisung, doAnweisung, for-Anweisung).

4.3.1 while-Schleife Funktion: Solange ein bestimmter Zustand andauert, soll eine Gruppe von Anweisungen wiederholt werden. Die while-Schleife besteht aus einem Schleifenkopf (einem booleschen Ausdruck) und einem Schleifenrumpf (einem Anweisungsblock). Die while-Schleife ist eine kopfgesteuerte Schleife, d.h., dass der boolesche Ausdruck geprüft wird, bevor die Schleife durchlaufen wird. Der boolesche Ausdruck stellt eine Bedingung dar, die erfüllt sein muss, damit die Schleife durchlaufen wird. Es handelt sich bei allen Schleifen in C++ um eine Gültigkeitsbedingung. Ist diese Bedingung beim ersten Test nicht erfüllt, so wird die Schleife nie durchlaufen. Boolescher Ausdruck Anweisung 1

Anweisung n

while (Boolescher Ausdruck){ Anweisung_1; . . . Anweisung_n; }

Beispiel (while): char eingabe; cout << "Bitte Auswahl eingeben (Ende mit 'q')"; cin >> eingabe; // Wenn hier 'q' eingegeben wurde, wird // die Schleife nie durchlaufen. while (eingabe!='q') { // hier die Auswahl Bearbeiten cout << "Bitte Auswahl eingeben (Ende mit 'q')"; cin >> eingabe; } // end while (!ende)

22


Programmieren in C++

Manfred Mirsch

Ein sinnvolles Mittel für die Gestaltung der Gültigkeitsbedingung ist die Verwendung einer sogenannten Wächter-Variablen, die vom Typ bool ist. Diese Variable wird in der Gültigkeitsbedingung geprüft und muss im Schleifenrumpf an irgendeiner Stelle modifiziert werden. Beispiel (while mit Wächter-Variable ende): bool ende=false; char eingabe; while (!ende) { cout << "Bitte Auswahl eingeben (Ende mit 'q')"; cin >> eingabe; if (eingabe=='q') { ende = true; } else { // hier die Auswahl Bearbeiten } } // end while (!ende)

4.3.2 do-Schleife Funktion: Eine Gruppe von Anweisungen soll wiederholt werden, solange ein bestimmter Zustand andauert. Die do-Schleife besteht aus einem Schleifenrumpf (einem Anweisungsblock) und einem Schleifenfuß (einem booleschen Ausdruck). Die do-Schleife unterscheidet sich von der while-Schleife einzig dadurch, dass der boolesche Ausdruck erst nach dem Schleifendurchlauf geprüft wird. Die do-Schleife nennt man deswegen auch eine fußgesteuerte Schleife. Boolescher Ausdruck Anweisung 1

Anweisung n

do { Anweisung_1; . . . Anweisung_n; } while (Boolescher Ausdruck);

Beispiel (do): char eingabe; do { cout << "Bitte Auswahl eingeben (Ende mit 'q')"; cin >> eingabe; if (eingabe!='q') { // hier die Auswahl Bearbeiten } } while (eingabe!='q'); 23


Programmieren in C++

Manfred Mirsch

4.3.3 for-Schleife Funktion: Eine Gruppe von Anweisungen soll eine festgelegt Anzahl mal durchlaufen werden. Die for-Schleife ist die mächtigste und gleichzeitig die allgemeinste Schleife in C++. Sie besteht aus einem komplexen Schleifenkopf und einem Schleifenrumpf.

Schleifeninitialisierung Aktualisierungsausdruck

Boolescher Ausdruck

Anweisung 1

Anweisung n

for (Schleifeninitialisierung; Boolescher Ausdruck; Aktualisierungsausdruck) { Anweisung 1; . . . Anweisung 1; }

Der Schleifenkopf besteht aus drei Teilen: 1. einer Schleifeninitialisierung; 2. einer Gülitgkeitsbedingung (Boolescher Ausdruck); 3. einem Aktualisierungsausdruck, der nach jedem Durchlauf der Schleife ausgeführt wird. Eine Besonderheit in C++ ist die Möglichkeit, Variablen in der Schleifeninitialisierung zu deklarieren. Beispiel (multi-hallo): for (int i=0; i<3; i++) { cout << "Hallo Welt!" << endl; }

In der Schleifeninitialisierung kann man mehrere Anweisungen ausführen lassen. Dies ist auch im Aktualisierungsausdruck möglich. Beispiel (Fakultät1): int fakultaet; int n; cout << "Bitte geben Sie 'n' ein: "; cin >> n; for (int i=n, fakultaet=1; i>1; i--) { fakultaet *= i; 24


Programmieren in C++

Manfred Mirsch

}

Schleifenvergleiche Wie oft werden die Schleife ausgeführt, wenn 'zahl' die Werte 1, 2, 0 oder -1 hat.

while-Schleife

do-while-Schleife

while (zahl!=0) { zahl--; }

do { zahl--; } while (zahl!=0);

zahl:

1

2

0

zahl:

-1

1

2

0

-1

Durchläufe:

Durchläufe:

for-Schleife 1

for-Schleife 2

for (int i=0; i<zahl; i++) { cout << "Hallo"; }

for (int i=zahl; i>=0; i-=3) { cout << "Hallo"; }

zahl:

1

2

0

-1

Durchläufe:

zahl:

1

2

0

-1

Durchläufe:

Endlosschleifen Eine große Gefahr bei der Programmierung von Schleifen besteht darin, Endlosschleifen zu erstellen.

Beispiele Endlosschleifen Programm

Fehler

int i=1; while (i==1) { cout << "Hallo"; } for (;;) { cout << "Hallo"; } for (i=1; i<5; i++) { cout << "Hallo"; } Übung: Einkauf2

25


Programmieren in C++

Manfred Mirsch

26


Programmieren in C++

Manfred Mirsch

4.4 Funktionsaufrufe 4.4.1 Funktionale Abstraktion Im Top-Down-Entwurf benutzen wir Abstraktionen, um Problemdetails im Grobentwurf auszublenden. Eine Folge von Befehlen, die zusammengepackt wird nennt man Funktionale Abstraktion. Der Aufruf eines problemorientierten Befehls, der eine funktionale Abstraktion darstellt, wird Funktionsaufruf genannt. Dabei sind drei Aspekte zu berücksichtigen: 1. Die Sicht des Konstrukteurs (Entwurf): Er analysiert die Problembeschreibung, um funktionale Abstraktionen daraus abzuleiten. Im Entwurfsdiagramm wird eine funktionale Abstraktion als Stellvertreterbox dargestellt. 2. Die Sicht des Implementierers: Der Implementierer muss die Funktion durch detaillierte Befehle implementieren (realisieren). 3. Die Sicht des Anwenders: Der Anwender muss in abstrakten Begriffen wissen, was die Funktion ausführt und wie man sie aufruft. Beispiel für Funktionale Abstraktion Speichern eines Dokuments: Konstrukteur: Berücksichtigt im Entwurf, dass ein Dokument gespeichert werden kann. Implementierer: Realisiert die Schritte, die zur Speicherung des Dokuments notwendig sind. Anwender: Weiß, dass es die Möglichkeit des Abspeicherns gibt und dass er sie über das Menü Datei oder mit einem Tastaturkürzel abrufen kann.

4.4.2 Parametrisierung von Funktionen Eine Funktion bekommt keinen oder mehrere Werte (Parametern) übergeben und liefert im allgemeinen einen Wert zurück.

Beispiele für die Parametrisierung von Funktionen: Funktion uhrzeit a2 (Quadrat) ab (Potenz)

Eingabewerte

Ausgabewerte

4.5 Die Funktionsschnittstelle Eine C++-Funktion wird durch drei Eigenschaften gekennzeichnet: 27


Programmieren in C++

Manfred Mirsch

1. ihren Namen; 2. die Typen der Eingabeparameter, sofern vorhanden; 3. den Typ des Rückgabewertes der Funktion. Um eine Funktion aufzurufen, muss die Funktionsschnittstelle korrekt verwendet werden: 1. der Name der aufgerufenen Funktion muss korrekt geschrieben sein; 2. die Parameter müssen kompatibel sein (korrekte Anzahl und korrekte Typen); 3. der Rückgabewert muss sinnvoll verwendet werden. Beispiele für Funktionsaufrufe: // Funktionsschnittstelle: void clrscr(void); // kein Parameter, kein Rückgabewert // Funktionsaufruf: clrscr(); // Funktionsschnittstelle: int getch(void); // kein Parameter, ein Rückgabewert int taste; // Funktionsaufruf: taste = getch(); // Funktionsschnittstelle: double sqrt(double zahl); // ein Parameter, ein Rückgabewert double a=3.0; double b=4.0; double c; // Funktionsaufruf: c = sqrt(a*a + b*b);

28


Programmieren in C++

Manfred Mirsch

5 Funktionsdefinitionen Unter einer Funktionsdefinitionen versteht man die Implementierung einer Funktion.

5.1 Die Funktionsdeklaration Als ersten Schritt bei der Entwicklung einer Funktion sollte man die Funktionsdeklaration entwerfen. Rückgabetyp Funktionsname(Parameterliste);

Die Funktionsdeklaration bildet die Funktionsschnittstelle nach außen. Beispiel (Fakultät): int fakultaet(int grenze);

Alle Funktionsdeklarationen müssen vor der Hauptfunktion vorgenommen werden, damit diese Funktionen vor ihrer Benutzung bekannt sind.

5.2 Die Funktionsdefinition Die eigentliche Funktionsdefinition besteht aus zwei Teilen: 1. der Funktionskopf; 2. dem Funktionsrumpf.

5.2.1 Der Funktionskopf Der Funktionskopf ist bis auf das fehlende Semikolon identisch mit der Funktionsdeklaration: Rückgabetyp Funktionsname ( Parameterliste )

5.2.2 Der Funktionsrumpf Der Funktionsrumpf ist ein normaler Anweisungsblock.

29


Programmieren in C++

Manfred Mirsch

Typischerweise werden jedoch zu Beginn des Funktionsrumpfes lokale Variablen deklariert:

Beispiel (Fakultät): int fakultaet(int grenze) { int fak=1; int i=grenze; while(i>1) { fak *= i; i--; } return fak; }

Übung: Zinsen3

5.2.3 Die Parameter Falls eine Funktion Argumente übergeben bekommt, so handelt es sich im Normalfall um Kopien der Werte, die beim Aufruf der Funktion übergeben wurden. Diese Form der Parameterübergabe nennt man call-by-value. Beispiel (Fakultät) int fakultaet(int grenze); int main(void) { int n=5; int ergebnis; ergebnis = fakultaet(n); cout << "Die Fakultät von " << n << " ist " << ergebnis; return 0; } int fakultaet(int grenze) { int fak=1; while(grenze>1) { fak *= grenze; grenze --; } return fak; }

Die Variable 'n' fungiert im Funktionsaufruf von fakultaet als konkreter Parameter. Beim Aufruf wird der Wert von 'n' kopiert und an die Funktion fakultaet übergeben. 30


Programmieren in C++

Manfred Mirsch

Innerhalb der Funktionsdefinition gibt es den formalen Parameter 'grenze'. Ein formaler Parameter verhält sich genauso wie eine lokale Variable, die mit einem Wert initialisiert wurde, wobei der Initialwert vom konkreten Parameter, in diesem Fall 'n', kopiert wurde. Änderungen am formalen Parameter haben deswegen keine Auswirkungen auf den konkreten Parameter. Beispiel (tausche): void tausche(int a, int b); int main(void) { int zahl1=1; int zahl2=2; tausche(zahl1,zahl2); cout << "Zahl1: " << zahl1 << "Zahl2: " << zahl2; return 0; } void tausche(int a, int b) { int hilf=1; hilf = a; a = b; b = hilf; }

Dieser Tausch funktioniert wegen des call-by-value-Mechanismus der Parameterübergabe nicht.

5.2.4 Der Referenz-Typ Für den Fall, dass man Argumente durch eine Funktion verändern möchte gibt es den Referenz-Typ. Typ & Variablenname

Eine Referenz wird durch das Zeichen '&' gekennzeichnet, welches direkt nach der Typangabe geschrieben wird. Wird ein Parameter als Referenz übergeben, so erfolgt die Parameterübergabe nicht mehr als Kopie sondern der formale Parameter referenziert nunmehr den konkreten. Anders ausgedrückt ist der formale Parameter nur ein zweiter Name, der mit demselben Objekt arbeitet wie der konkrete Parameter. Diese Form der Parameterübergabe nennt man call-by-reference. Alle Veränderungen des formalen Parameters betreffen dann auch den konkreten Parameter.

31


Programmieren in C++

Manfred Mirsch

Beispiel (tausche mit Referenz): void tausche(int& a, int& b); int main(void) { int zahl1=1; int zahl2=2; tausche(zahl1,zahl2); cout << "Zahl1: " << zahl1 << "Zahl2: " << zahl2; return 0; } void tausche(int& a, int& b) { int hilf=1; hilf = a; a = b; b = hilf; }

5.2.5 Wertparameter versus Referenzparameter Vorteile von Wertparametern:  Wertparameter schützen vor unbeabsichtigter Veränderung von Variablen,  gestatten einen allgemeinen Gebrauch einer Funktion auch mit Literalen und Konstanten. Nachteile von Wertparametern:  durch das Anlegen von Kopien wird u.U. mehr Zeit und Speicherplatz verbraucht, als bei Übergabe einer Referenz. Sinnvoller Einsatz von Referenzparametern:  wenn Wertänderungen der Parameter erwünscht sind,  wenn durch Referenzparameter erhebliche Effizienzvorteile zu erwarten sind.

Übung: gross

32

Programmieren in C++  

Programmieren in C++

Read more
Read more
Similar to
Popular now
Just for you