C++Programmierung ( Programmierung für Anfänger) | 1:44 Am      |
Allgemeines, Aufbau und Variablen
Teil: (1/?)
Thema: Allgemeines, Aufbau und Variablen
Version: 2.00
Datum: 10.02.2000
Hinweis: Dieses Tutorial über C++-Programmierung dient nur dazu euch die Grundlagen der
Programmiersprache C++ beizubringen. Ihr werdet durch dieses Tutorial sicherlich nicht zu
einem Meisterprogrammierer. Leute die schon C++ beherschen können sich das lesen
sparen!!!
Allgemeines:
Compiler:
Um überhaupt Programme in C++ schreiben zu können benötigt ihr zunächst einmal einen
Compiler(ladet euch am besten eine Shareware herunter, die reicht auf alle fälle für den
Anfang). Dieser sorgt dafür, dass aus eurem Code eine ausführbares Programm wird(eine exe
Datei). Die exe Datei wird in mehreren schritten erstellt:
Der Compiler überprüft erst einmal euren Quellcode auf Fehler. Wenn er keine Fehler finden
kann, dann erstellt er eine Objekt Datei(*.obj). Nun ist der sogenannte Linker an der Reihe. Er
macht aus der vorher erstellten Objekt Datei eine ausführbare exe.
Wie ihr den Compiler bedient entnehmt ihr bitte der dazugehörigen Anleitung.
Was man noch wissen sollte:
In der Programmiersprache C++ wird zwischen groß und klein Schreibung unterschieden.
D.h. wenn ich innerhalb einer Funktion(was das ist werdet ihr später erfahren) zwei Variablen
erzeugen könnt die den selben Namen haben. Sie müssen sich aber trotzdem unterscheiden:
variable
Variable
vAriable
Alle Variablen die ich oben aufgeführt habe sind verschieden, da sie sich in groß und klein
Schreibung unterscheiden. Man sollte sich aber angewöhnen innerhalb eines Programms
niemals den selben Namen für Variablen, Funktionen und Strukturen(etc.) zu verwenden, da
dies zu unübersichtlich sein würde.
In Namen sind keine Sonderzeichen zulässig außer '_' (Beispiel: _variable (sie unterscheidet
sich auch von den anderen, die oben stehen).
C++ ist eine Formatfreie Programmiersprache. D.h. man kann so viele abstände zwischen
Zeilen, Wörtern(außer innerhalb der 'cout' Anweisung) und Anweisungen machen wie man
will. Man kann Anweisungen auch in einer Reihe schreiben, nur das dies sehr unübersichtlich
wäre.
Dies sollte fürs erste genügen. Ich werde an stellen, wo man auf bestimmte Dinge achten muß
daraufhin weisen.
Kommentare:
Kommentare dienen dazu ein Programm übersichtlicher zu gestalten. Mit ihnen ist es möglich
irgendwo im Programm etwas reinzuschreiben, ohne das der Compiler meckert. Diese Text
Teile werden dann einfach ignoriert.
Beispiel:
........
cout << "Hallo wie geht es dir?" // Ausgabe des Satzes auf den Bildschirm
.......
Hinter der 'cout' Anweisung finden wir zwei '/'. Diese sagen dem Compiler: Ignoriere alles
was in der Zeile hinter den strichen steht.
Kommentare sollten regelmäßig benutzt werden, da ihr nach einen Monat bestimmt nicht mehr genau wißt was
das eigentlich macht, was da steht
Aufbau:
Um den Aufbau eines Programmes zu erklären führe ich an dieser Stelle ein kleines
Programm auf(Hinweis: Die Zahlen gehören nicht zum Programmcode, sie diene
ausschließlich der besseren Orientierung):
1: #include<iostream.h>
2:
3: void main(void)
4: {
5: cout << "Hello World";
6: return 0;
7: }
In Zeile 1 wird die header Datei 'iostream' in das Programm eingebunden. In der Header
Datei stehen die Information, was z.B. 'cout' machen soll(ich werde mich in einen späteren
Teil genauer mit header Dateien beschäftigen). Tatsache ist, dass der Compiler eine
Fehlermeldung ausspuckt, wenn wir keine header einbinden würden.
In Zeile 3 beginnt das eigentliche Programm mit der Main Funktion. Ein jedes C++
Programm verfügt über eine Main Funktion. Sie wird immer als erstes aufgerufen und ist
somit der Ausgangspunkt für alle weiteren Operationen. Die Main Funktion(wie auch jede
andere) wird durch eine öffnende geschweifte Klammer eingeleitet(Zeile 4) und durch eine
schließende geschweifte Klammer beendet(Zeile 7).
In Zeile 5 steht die Anweisung 'cout << " " '. Sie sorgt dafür, dass die Meldung "Hello
World" auf den Bildschirm ausgegeben wird. Der auszugebende Text muß dabei in
Anführungszeichen stehen. Das Semikolon am Ende der Zeile signalisiert das Ende der
Anweisung. Hinter jeder Anweisung muß ein Semikolon stehen. Zeile 6 interessiert uns
zunächst noch nicht.
Variablen:
Variablen kennt ihr mit Sicherheit aus dem Matheunterricht aus der Schule(Bsp: x = 5+4y). In
C++ übernehmen Variablen im Prinzip die gleiche Aufgabe. Im Prinzip deshalb, weil es doch
ein bißchen anders aussieht. Es gibt mehrere Arten von Variablen in C++. Zur verdeutlichung
schauen wir uns nun ein kleines Programm an, indem der User aufgefordert wird zwei Zahlen
einzugeben, die dann addiert werden und anschließend das Ergebnis ausgegeben wird:
1: #include<iostream.h>
2:
3: void main(void)
4: {
5: int zahl1;
6: int zahl2;
7: int ergebnis:
8:
9: cout << "Bitte geben Sie die erste Zahl ein:";
10: cin >> zahl1;
11: cout << "\nBitte geben Sie die zweite Zahl ein:";
12: cin >> zahl2;
13:
14: ergebnis = zahl1 + zahl2;
15: cout << "\n Die Summe der beiden Zahlen ist:" << ergebnis;
16:
17: return 0;
18: }
Erläuterung:
Was die Zeilen 1-4 bedeuten entnehmt ihr bitte dem oberen Teil. In der Zeile 5 wird eine
Variable vom Typ integer(int) erzeugt, die den Namen 'zahl1' hat(das ist im Prinzip das selbe
wie das 'x' aus dem Mathe untericht, nur das sie anders heißt und das sie "Eigenschaften"
hat). Ihr fragt euch bestimmt jetzt was eine integer Variable ist: Eine integer Variable ist ein
Variablen Typ, der Werte im Bereich von -32.768 bis 32767 aufnehmen. Wenn man einen
größeren(oder kleineren) Wert in der Variable speichern wollen, muß diese dementsprechend
deklariert(erzeugt) werden.
Eine Auflistung aller möglichen Variablentypen steht weiter unten.
In den Zeilen 6/7 werden zwei weitere Variablen vom Typ integer erzeugt.
In Zeile 9 wird der User dazu aufgefordert einen Wert einzugeben.
In Zeile 10 wird der eben eingegebene Wert(nach der Eingabe muß die Enter Taste gedrückt
werden und es dürfen keine Punkte wie man sie sonst schon mal schreibt benutzt werden) in
die Variable 'zahl1' eingelesen. Da in dieser Variblen nun der Wert gespeichert, den der User
eingegeben hat, können wir jederzeit, zur Laufzeit des Programmes, auf den Wert der
Variablen zugreifen. Der Inhalt einer Variablen(der Wert) wird dabei im Arbeitsspeicher
zwischengespeichert. Jede Variable bekommt eine Adresse im Speicher zugewiesen.
In Zeile 11 wird der User wieder aufgefordert einen Wert einzugeben. In dieser Zeile gibt es
aber auch noch etwas neues: Hinter den >>"<< steht ein '\n'. Das bedeutet, dass hier ein
Zeilenumbruch stattfindet(eine neue Zeile wird angefangen). Diese Anweisung kann
irgendwo innerhalb der Gänsefüßchen stehen. Würden wir das '\n' an dieser Stelle weglassen,
so würde die Aufforderung direkt hinter der ersten stehen –und das wäre sehr unübersichtlich.
In Zeile 12 wird der eingegebene Wert in die Variable 'zahl2' eingelesen.
In Zeile 14 werden die beiden Werte der Variablen der Variablen ergebnis zugewiesen. Hier
kann man auch sehen, dass C++ Anweisungen immer von rechts nach links abarbeitet.
In Zeile 15 wird schließlich die Varible 'ergebnis' ausgegeben. Erst wird hierbei der Text
ausgegeben, der in Anführungszeichen steht, anschließend wird der Wert der Variablen
ausgegeben.
Variablentypen:
Typ
Wertebereich
unsigned short int
0 bis 65.535
short int
-32.768 bis 32.767
unsigned long int
0 bis 4.294.967.295
long int
-2.147.483.648 bis 2.147.483.647
float*
1,2e-38 bis 3,4e38
double*
2,2e-308 bis 1,8e308
char
256 Zeichenwerte
* Diese Typen können Kommazahlen darstellen(aufnehmen)
Um eine Variable als einen anderen Typ zu Deklarieren wie oben(int), so muß man nur das
Schlüsselwort umändern. Man setzt anstatt des 'int' im oberen Beispiel einfach einen
Schlüsselwort aus der Tabelle(je nachdem was für Werte man benötigt). Die sieht dann wie
folgt aus:
int kleinerWertebereich;
float größererWertebereich;
Mit dem Typ 'char' kann man bis zu 256 Zeichenwerte aufnehmen(Buchstaben etc.). Die
kann man gut bei ja/nein auswertungen gebrauchen(und bei vielen anderen Dingen).
Operatoren und Auswertungen
Teil: (2/?)
Thema: Operatoren und Auswertungen
Version: 2.00
Datum: 12.02.2000
Operatoren:
Zuerst einmal möchte ich kurz erklären, was Operatoren überhaupt sind:
Einfach gesagt sind Operatoren Symbole, die den Compiler eine bestimmte Aktion ausführen
lassen. Im ersten Teil dieses Tutorials haben wir bereits Operatoren kennengelernt:
Wir haben zwei Werte addiert und die Summe im gleichen schritt einer Variablen
zugewiesen:
ergebnis = zahl1 + zahl2;
Dabei ist zu beachten, dass der Compiler von rechts nach links arbeitet. Er addiert zuerst die
beiden werte und weißt die Summe anschließend der Variablen ergebnis zu. Hier hätten wir
dann auch schon einen weiteren Operator: den Zuweisungsoperator.
Es ist bei diesem Operator zu beachten, dass er nicht 'ist das selbe wie(ist gleich)' bedeutet,
wie es in der Mathematik ist. Er bedeutet viel mehr: Weise den rechten Wert dem linken
Operanden zu. Wenn man zwei Werte auf Gleichheit überprüfen will, muß man den
'Vergleichsoperator' verwenden( = = ).
Mathematische Operatoren:
Wir haben auch schon Mathematische Operatoren kennengelernt. Diese sind in ihrer Funktion
wohl selbst erklärend. Lediglich die Schreibweise in C++ ist anders als in der Mathematik:
Mathematik
C++
Bedeutung
+
+
Addition
-
-
Subtraktion
*
Multiplikation
:
/
Division
?
%
Modulo*
*Dieser Operator liefert den Rest einer Ganzzahldivision: 31 : 6 = 5 mit einem Rest von 1.
Vergleichsoperatoren:
Prüft zwei Werte auf folgende Fälle:
Bezeichnung
Zeichen
Gleich
= =
Ungleich
!=
kleiner
<
größer
>
kleiner oder gleich
<=
größer oder gleich
>=
Inkrementierung:
Wenn man einen Wert nur um eins erhöhen bzw. um 1 erniedrigen will kann man das
folgendermaßen schreiben:
int zahl=0;
zahl = zahl +1;
zahl = zahl - 1
Da dies aber umständlich ist, bietet C++ eine andere Möglichkeit die weniger Arbeit macht,
aber das selbe bewirkt. Mit Hilfe des Inkrements kann man den Wert einer Variablen um eins
erhöhen. Mit Hilfe des Dekrements kann man den Wert einer Variablen um 1 erniedrigen.
In der Praxis sieht das wie folgt aus:
int zahl=0;
zahl++;
zahl--;
Erst wird die Variable 'zahl' erzeugt und ihr der Wert '0' zugewiesen. Anschließend wird der
Wert um eins erhöht. Folglich hat die Variable nun den Wert '1'.
Nach der Erhöhung um 1 wird der Wert wieder um '1' erniedrigt. Nun hat die Variable
wieder ihren ürsprünglichen Wert '0'.
Nun stellt sich die Frage, ob man das Inkrement bzw. das Dekrement nicht auch vor die
Variable schreiben kann: Die Antwort lautet JA. Das sieht dann wie folgt aus:
++zahl;
--zahl;
Man muß allerdings bei Inkrementireung bzw. Dekrementierung auf eine Sache achten:
Es gibt ein sog. 'Präfix' und ein 'Postfix'. Beim Präfix wird der Wert der Variablen erst
erhöht und anschließend(siehe Beispiel) einer Variablen zugewiesen. Beim Postfix wird der
Wert erst einer Variablen zugewiesen und anschließend erst erhöht:
....
int x=6;
int y=6;
int ergebnis=0;
ergebnis = ++x;
ergebnis = y++;
...
Erst werden drei Variablen erzeugt und ihnen Werte zugewiesen. Im ersten Fall haben wir ein
Präfix. Der Wert der Variablen 'x' wird als erstes um eins erhöht und dann der Variablen
'ergebnis' zugewiesen. 'x' hat jetzt einen Wert von 7. Die Variable 'ergebnis' hat einen Wert
von 7.
Im zweiten Fall haben wir ein Postfix. Der Wert von 'y' wird erst der Variablen 'ergebnis'
zugewiesen und anschließen erst um eins erhöht. Die Variable 'y ' hat nun einen Wert von 7
und die Variable 'ergebnis' hat einen Wert von 6.
Die if-Anweisung:
Nun werden wir eine Möglichkeit kennenlernen, wie man Eingaben eines Users auswerten
kann. Dies mache wir mit Hilfe der if-Anweisung. Dabei wird eine Aktion ausgeführt, wenn
eine bestimmte Bedingung erfüllt wird. Schauen wir uns das mal in der Praxis an:
1: #include<iostream.h>
2:
3: void main(void)
4: {
5: int auswahl, zahl1, zahl2, ergebnis;
6:
7: cout << "Bitte waehlen Sie aus den folgenden moeglichkeiten ein aus:\n";
8: cout << "1) Zwei Zahlen addieren\n";
9: cout << "2) Zwei Zahlen Multiplizieren\n";
10: cout << "Bitte waehlen Sie(1/2):";
11: cin >> auswahl;
12:
13: cout << "\nBitte geben Sie die erste Zahl ein:";
14: cin >> zahl1;
15: cout << "\nBitte geben Sie die zweite Zahl ein:";
16: cin >> zahl2;
17:
18: if(auswahl == 1)
19: ergebnis = zahl1 + zahl2;
20: if(auswahl == 2)
21: ergebnis = zahl1*zahl2;
22: if(auswahl != 1 && auswahl != 2)
23: cout << "\nSie haben eine falsche auswahl getroffen!!!";
24: cout << "\nDas Ergebnis ist:" << ergebnis;
25: }
Erläuterung:
Zu den Zeilen 1-6 muß ich wohl kein Kommentar mehr abgeben. In den Zeilen 7-10 wird der
User dazu aufgefordert eine der Optionen auszuwählen. In Zeile 11 wird die Wahl des
Users(1/2) in die Variable 'auswahl' eingelesen. Die Zeilen 13-16 sollten klar sein.
In Zeile 18 beginnt die Auswertung. Hierbei wird überprüft, welche Option der User gewählt
hat. Man kann diese Zeilen(18/19) wie folgt ausdrücken: Wenn der Wert der Variablen
'auswahl' gleich '1' ist, dann weise die Summe der beiden Zahlen der Variablen 'ergebnis'
zu. Genauso verhält es sich mit den Zeilen 20/21. In Zeile 22 gibt es jedoch etwas neues: Hier
wird die Anweisung erst ausgeführt, wenn zwei Bedingungen erfüllt werden. Wir verknüpfen
an dieser Stelle zwei Bedingungen mit einem logischen AND(und). Man würde es wie folgt
übersetzen: Wenn Ausdruck eins UND Ausdruck zwei gleich TRUE(= wahr: Wenn auswahl
!= '1' UND auswahl != '2'), dann führe die Anweisung aus.
In Zeile 24 wird schließlich das Ergebnis ausgegeben.
Um weitere Möglichkeiten, die man in der if-Anweisung verwenden kann, zu zeigen, werde
ich direkt noch ein Beispiel aufführen. Dabei erweitere ich das oben stehende Programm um
ein paar Dinge:
1: #include<iostream.h>
2:
3: void main(void)
4: {
5: int auswahl, zahl1, zahl2, ergebnis;
6:
7: cout << "Bitte waehlen Sie aus den folgenden moeglichkeiten ein aus:\n";
8: cout << "1) Zwei Zahlen addieren\n";
9: cout << "2) Zwei Zahlen Multiplizieren\n";
10: cout << "Bitte waehlen Sie(1/2):";
11: cin >> auswahl;
12:
13: cout << "\nBitte geben Sie die erste Zahl ein:";
14: cin >> zahl1;
15: cout << "\nBitte geben Sie die zweite Zahl ein:";
16: cin >> zahl2;
17:
18: if(auswahl != '1')
19: {
20: if(auswahl == '2')
21: ergebnis = zahl1 * zahl2;
22: cout << "\nDas Ergebnis ist:" << ergebnis;
23: else
24: cout << "\nSie haben eine Ungueltige Option gewaehlt!!!";
25: }
26: else
27: {
28: ergebnis = zahl1 + zahl2;
29: cout << "\nDas Ergebnis ist:" << ergebnis;
30: }
31: }
Erläuterung:
Dieses Programm macht genau das selbe, wie das Programm zuvor. Es hat sich lediglich die
Schreibweise der Auswertung verändert. Deswegen setze ich auch direkt in Zeile 18 an:
Zuerst wird die Bedingung gestellt: Wenn die Variable ungleich '1' ist, dann führe die
Anweisungen innerhalb der geschweiften Klammern aus. Wenn die Variable aber gleich(also
nicht ungleich 1) ist dann führe die Anweisung aus, die nach dem 'else' folgt.
Das 'else' bedeutet nämlich 'andernfalls'. Man könnte das wie folgt sagen: Wenn die
Bedingung so und so erfüllt ist, dann mache dies ANDERNFALLS(else) mache dies.
Wenn die Variable aber ungleich 1 ist, so werden, wie schon gesagt, die Anweisungen
innerhalb der geschweiften Klammern ausgeführt. In diesem Fall würde dann wieder eine
Auswertung statt finden. Wenn die Bedingung nicht erfüllt wird, so wird eine Fehlermeldung
ausgegeben und das Programm fährt hinter der else Anweisung in Zeile 25 fort(also in Zeile
30).
Auswertungen II, Funktionen I
Teil: (3/?)
Thema: Auswertungen II, Funktionen I
Version: 1.00
Datum: 02.03.2000
Auswertungen II:
Im zweiten Teil haben wir bereits eine Möglichkeit kennengelernt, um Dinge auszuwerten.
Dies war die 'if-else' Anweisung. In diesem Teil werde ich noch eine Möglichkeit zeigen, mit
der es möglich ist Dinge auf Gleichheit zu prüfen: Die 'switch-case' Anweisung.
Ich will jetzt auch nicht länger reden, äh schreiben und direkt ein Beispiel heranführen:
1: #include<iostream.h>
2:
3: void main(void)
4: {
5: int zahl;
6:
7: cout << "Bitte geben Sie eine Zahl im Bereich von 1-4 ein:";
8: cin >> zahl;
9:
10 switch(zahl)
11: {
12: case 0: cout << "\nSie sollten eine Zahl zwischen 1-4 eingeben und nicht 0 !!!\n";
13: Break;
14: Kasse 1: Cut << "\nSie gaben die Zahl 1 ein";
15: break;
16: case 2: cout << "\nSie gaben die Zahl 2 ein";
17: break;
18: case 3: cout << "\nSie gaben die Zahl 3 ein";
19: break;
20: case 4: cout << "\nSie gaben die Zahl 4 ein";
21: break;
22: default: cout << "\nKoennen Sie denn nicht das tun was man Ihnen sagt?";
23: break;
24: }
25: }
Erläuterung:
Ich setze direkt in Zeile 10 an, da der Rest klar sein müsste:
In besagter Zeile wird die switch Anweisung aufgerufen. In der Klammer dahinter steht der
Auszuwertende Ausdruck. Dieser Ausdruck kann ein beliebiger C++ Ausdruck sein.
Die Auswertung beginnt mit einer öffnenden geschweiften Klammer. In Zeile 12 beginnt die
Auswertung. Hinter der 'case' Anweisung folgt ein Wert, der mit dem Ausdruck aus der
Klammer hinter dem switch, verglichen wird. Wenn der Wert gleich dem Ausdruck ist, wir
die Anweisung hinter dem Doppelpunkt ausgeführt. Nachdem die Anweisung ausgeführt
wurde, springt das Programm aus der switch Konstruktion. Wenn der Wert ungleich dem des
Ausdrucks ist, fährt das Programm beim nächsten case fort und prüft wie zuvor auf
Gleichheit. Wenn es keine Übereinstimmung gibt, landet das Programm bei der 'default'
Anweisung. Diese wird(sofern sie angegeben ist) dann aber auf jedem Fall bearbeitet.
Funktionen:
Zunächst möchte ich mal klären, was Funktionen sind:
Funktionen sind eigentlich Unterprogramme, die bestimmte Anweisungen durchführen und
dann einen Wert an die Main Funktion zurückgeben. Die Main Funktion ist die Hauptfunktion
in einem C++ Programm. Sie muss immer vorhanden sein und wird beim starten des
Programms automatisch aufgerufen. Eine Funktion kann praktisch an jedem Punkt der Main
Funktion aufgerufen werden. Bevor man jedoch eine Funktion benutzen kann, muss man
diese Deklarieren. Die Deklaration einer Funktion nennt man Prototyp. Diesen schreibt man
vor die Main Funktion:
1: #include<iostream.h>
2:
3: int addieren(int zahl1, zahl2);
4:
5: void main(void)
6: {
7: int zahl1, zahl2, ergebnis;
8:
9: cout << "Bitte geben Sie die erste Zahl ein:";
10: cin >> zahl1;
11: cout << "\nBitte geben Sie die zweite Zahl ein:";
12: cin >> zahl2;
13:
14: ergebnis = addieren(zahl1, zahl2);
15:
16: cout << "\n\nDie Summe der beiden Zahlen ist:" << ergebnis;
17:
18: return 0;
19: }
20:
21:
22:
23: int addieren(zahl1, zahl2)
24: {
25: return zahl1 + zahl2;
26: }
Erläuterung: Die Funktion 'addieren' wird in Zeile 3 deklariert. Es ist der Prototyp der
Funktion. Der erste Teil(int) des Prototyps ist der Rückgabetyp. Der darauffolgende
Teil(addieren) ist der Name der Funktion. In der Klammer stehen schließlich die
Parametertypen und die Parameternamen. Da die Prototypen Deklaration eine Anweisung ist,
schließt sie mit einem Semikolon.
Der darauf folgende Teil ist alt gebacken. Erst in Zeile 14 wird es wieder interessant.
Dort wird die Funktion 'addieren' aufgerufen, die wir oben deklariert haben. In der Klammer
stehen die Namen der Zwei Variablen, die wir in der Main Funktion erstellt haben. Diese
beiden Variablen geben wir mit auf den Weg zur Funktion 'addieren', die nach der Main
Funktion Definiert ist. Nun befinden wir uns also in Zeile 23.
Diese Funktion unterscheidet sich in zwei Punkten von der Main Funktion:
1) Anstatt eines 'void', wie in der Main F. finden wir hier ein 'int'. Dies heißt, dass diese
Funktion ein 'int' zurückgibt(und zwar an die Main F.). Dies ist identisch mit dem
Prototypen.
2) In der Klammer finden wir auch kein 'void' wie in der Main F. sondern zwei Namen.
Und zwar sind dies Variablen, die wir hier Deklarieren. Ihr denkt bestimmt jetzt, dass hier
etwas fehlt: Ja! Da fehlt wirklich etwas. Und zwar der Typ der Variablen(int, float etc.).
Wir müssen keinen Typ mehr angeben, weil wir das schon im Prototypen gemacht haben(wir
haben dem Compiler gesagt, dass wir zwei Variablen vom Typ 'int' in der Funktion addieren
benutzen möchten. Also weiß der Compiler, dass die Variablen vom Typ int sein müssen.
Dabei spielt die Wahl des Namens keine Rolle. Das will heißen, dass ich in der
Funktion(Zeile 23) einen beliebigen anderen Namen eingeben könnte. Es geht eigentlich nur
darum, dem Compiler mitzuteilen, vom welchen Typ die Variablen sein sollen.
Nun wird eine weitere Frage aufgeworfen: Wir haben doch gelernt, dass man einen
Variablennamen nur einmal verwenden darf, oder?
Nun, innerhalb einer Funktion kann man einen Variablennamen nur einmal verwenden. Das
heißt nicht, dass wir einen Namen nicht mehrmals innerhalb eines Programmes benutzen
können. In C++ ist es möglich einen Variablennamen mehrmals, aber in verschiedenen
Funktionen zu verwenden.
Dies ist aber nicht ratsam, da nur die Übersicht leidet. Ich habe es nur zur Veranschaulichung
so gemacht.
Das sollte fürs erste zum Thema Funktionen reichen. Jetzt möchte ich noch einen Nachtrag
machen, der eigentlich im ersten Teil erscheinen sollte. SORRY!
Kommentare:
Kommentare dienen dazu ein Programm übersichtlicher zu gestalten. Mit ihnen ist es möglich
irgendwo im Programm etwas reinzuschreiben, ohne das der Compiler meckert. Diese Text
Teile werden dann einfach ignoriert.
Beispiel:
........
cout << "Hallo wie geht es dir?" // Ausgabe des Satzes auf den Bildschirm
.......
Hinter der 'cout' Anweisung finden wir zwei '/'. Diese sagen dem Compiler: Ignoriere alles
was in der Zeile hinter den strichen steht.
Kommentare sollten regelmäßig benutzt werden, da ihr nach einen Monat bestimmt nicht
mehr genau wisst was das eigentlich macht, was da steht.
Funktionen II, Schleifen I
Teil: (4/?)
Thema: Funktionen II, Schleifen I
Version: 1.00
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 noch mal.
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 Laufbedingung(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 Abbruchbedingung 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 durchlaufen, weil die
Laufbedingung nicht mehr erfüllt wird. Das
Programm fährt wie gewohnt fort. |
|
