C++-Programmierung - Teil 4
Funktionen II, Schleifen I
Teil: (4/?)
Thema: Funktionen II, Schleifen I
Version: 1.00
Autor: Dr Doo
e-Mail: DrDoo@busch-hacker.de
Datum: 15.03.2000
Funktionen II:
Hier werde ich nochmals auf Rückgabewerte eingehen, wie ich es im Tutorial 3 auch schon gemacht habe. Ich denke aber, dass es für Anfänger nicht leicht ist dies 100%ig nachzuvollziehen. Also nochmal.
Im folgenden Beispiel werde ich ein kleines Rechenprogramm erstellen, was mehrere Funktionen enthalten wird. Also dann:
1: #include <iostream.h>
2:
3: float f_addieren(float);
4: float f_weiterleitung(float);
5:
6: void main(void)
7: {
8: float ergebnis, zahl1;
9:
10: cout << "Bitte geben sie eine Zahl ein:";
11: cin >> zahl1;
12:
13: f_weiterleitung(zahl1);
14:
15: ergebnis = zahl1 * zahl1;
16: cout << "\n\n" << zahl1 << " * " << zahl1 << " = " << ergebnis;
17: }
18:
19: float f_weiterleitung(float zahl)
20:{
21: zahl = f_addieren(zahl);
22: return (zahl);
23: }
24:
25:
26: float f_addieren(float zahl)
27:{
28: float ergebnis = zahl + zahl;
29: cout << "\n\n" << zahl << " + " << zahl << " = " << ergebnis;
30: return (zahl);
31: }
Erläuterung:
In den Zeilen 3 und 4 werden die Funktionen f_addieren() und f_weiterleitung() definiert(dies sind die Prototypen der Funktionen). Vor den Namen der Funktionen(f_addieren() ....) steht der Rückgabetyp(float), also der Typ von dem die Variablen sind, die von der Funktion an eine andere zurückgegeben werden. In der Klammer finden wir die Parameter. Die im Prototypen stehenden Parameter müssen nicht identisch sein mit denen der eigentlichen Funktion. Wir teilen dem Compiler lediglich mit, von welchem Typ diese sein sollen.
In Zeile 13 wird die Funktion ‘f_weiterleitung()‘ aufgerufen. In der Klammer steht die Variable ‘zahl1‘. Dies bedeutet, dass wir den Wert der Variablen(den haben wir ja vorher vom User abgefragt) an die Funktion ‘f_weiterleitung‘ übergeben. Bzw. an die Variable, die wir in der Klammer erzeugt haben(Zeile 19). Variablen, die in der Klammer erzeugt werden, verhalten sich wie "normale" Variablen die in der Funktion selber deklariert werden.
In Zeile 21 sagen wir dem Compiler: "Weise der Variablen ‘zahl‘ den Wert zu, den die Funktion ‘f_addieren()‘ zurückgibt."
In die Klammer setzen wir die Variable ‘zahl‘, und übergeben sie somit an die Funktion f_addieren() bzw. an die Variable ‘zahl‘. An dieser Stelle möchte ich noch einmal daran erinnern, dass man Variablen mit dem selben Namen in Verschiedenen Funktionen verwenden darf.
Nun befinden wir uns also in Zeile 26. Wir erzeugen eine Variable ‘ergebnis‘ und weisen ihr den Wert von ‘zahl + zahl‘ zu. Dann wird die Summe auf dem Bildschirm ausgegeben.
In Zeile 30 geben wir den Wert der Variablen ‘zahl‘ an die Funktion ‘f_weiterleitung()‘ zurück. Dort wird der Wert dann der Variablen ‘zahl‘ zugewiesen(Zeile 21).
In Zeile 22 wird der Wert der Variablen ‘zahl‘ an die ‘main‘ Funktion zurückgegeben. Anschließend wird multipliziert und dann wird das Ergebnis ausgegeben.
Die while Schleife:
Ich werde mal kurz erläutern, was Schleifen sind(nicht die Teile die man beim Schuhe zu machen macht!): Einfach gesagt sind
das Programm Teile die etwas immer wiederholen, bis eine bestimmte Bedingung eintritt. Fertig(Das hat jetzt eh keiner gepeilt,
aber das kriegen wir gleich noch hin)!
Ich will jetzt nicht umständlich viel schreiben und schreib mal ein Beispiel:
1:
#include <iostream.h>2:
3:
void main(void)4:
{5:
int i, j=1;6:
7:
cout << "Wie oft soll der Schleifenkörper ausgeführt werden:";8:
cin >> i;9:
10:
while(i > 0)11:
{12:
cout << "\nDurchgang: " << j;13:
i--; j++;14:
}15:
16:
cout << "\n\nEnde der Schleife!!!";17:
}Erläuterung:
In Zeile 5 erzeugen wir die Variablen ‘i‘ und ‘j‘. Sie werden oft als zählervariable verwendet. In Zeile 7 wird gefragt, wie oft
der Schleifenkörper durchgelaufen werden soll.
In Zeile 10 beginnt die Schleife: In der Klammer steht die Laufbedingun(also unter welchen Umständen der Körper ausgeführt
werden soll). In diesem Fall soll der Körper durchlaufen werden, solange wie ‘i‘ größer ist als 0. Der Schleifenkörper wird in
Zeile 11 durch eine öffnende geschweifte eingeleitet(und dementsprechend durch eine geschlossene Klammer beendet). In Zeile
13 wird der Zähler ‘i‘ um eins erniedrigt, so dass die Abruchbedingung auch irgendwann mal eintritt. ‘j‘ wird um eins erhöht,
damit man sehen kann, wie oft der Schleifenkörper schon durchlaufe wurde(dies wird in Zeile 12 ausgegeben).
Wenn ‘i‘ dann bis 0 erniedrigt wird, wird der Körper nicht mehr duchlaufen, weil die Laufbedingung nicht mehr erfüllt wird. Das
Programm fährt wie gewohnt fort.
Da ich etliche Mails bekommen habe, in denen gefragt wurde woher man einen Compiler bekommen kann werde ich das jetzt
mal sagen:
http://www.bloodshed.nu << Dank an SickBastard für den Tipp!!!
http://www.borland.com
Das war es für dieses Tutorial wieder mal. Im nächsten werden wir weitere Schleifentypen kennenlernen.
Ich habe vor eine FAQ zu erstellen, in denen die wichtigsten Fragen aufgelistet sind(mit antworten natürlich). Also wenn ihr
irgendwelche fragen zu den bisherigen Themen habt, dann Mailt mir diese an:
Greetings to: Buschmann, SickBastard, ThaMod, Omega and the rest of the "Busch-Hacker‘s"; Jimbo, Bumski
Dr Doo