C++ Einführung
C++ Variablen im Speicher, Zeiger
C++ Texte etc.
C++ Dateien, Formatierte Ausgabe, ...
C++ OOP
Hilfe / Anhang
Downloads / Links
Partner
Fehler melden / Kontakt
Impressum
|
| Seite: [1] 2 3 - Drucken |
Inhalt:
Wiederholung! - Schleifen in C++
Unser letztes Programm rechnet ja einfach das Quadrat einer eingegebenen Zahl aus. Was ist aber wenn du mehrere Zahlen quadrieren willst? Du hast drei Möglichkeiten: Den Computer kaputtschlagen und im Kopf rechnen, das Programm mehrfach ausführen oder einfach ein neues schreiben...
Um in C++ etwas mehrmals zu tun, benutzt man Schleifen. Die einfachste Form ist die "while"-Schleife:
Die "while"-Schleife
Kommen wir zum Syntax der "while"-Schleife. Mit Syntax (griechisch: σύνταξις ['sʏntaksis] „die Zusammenstellung“, deutsch vereinfachend: Satzbau; Quelle: Wikipedia) ist der Gebrauch des C++-Sprachelements gemeint:
while(Fehler==0)//!SOLANGE! (Fehler gleich Null ist) // {wird das Kommando ausgeführt.} //(Mit zwei "="!!!) { //Kommando }
Die beiden Klammern "{" und "}" schließen einen Block. Blöcke kann man kapslen, dass bedeutet, dass man zum Beispiel eine Schleife in einer anderen Schleife nutzen kann, die in einer Funktion steht...
Beachte, dass man dieses Codestück nicht kompilieren kann, da es keine "main()"-Funktion gibt! Aber kommen wir zur Schleife an sich: Wie man sieht, steht erst das Schlüsselwort "while", gefolgt von einer Bedingung in runden Klammern. Danach stehen Kommandos in geschweiften Klammern. Nur wenn die Bedingung zutrifft, und auch nur solange sie dies tut, werden die Anweisungen in den geschweiften Klammern ausgeführt. Bedingungen können sein:
| Zeichen |
Bedeutung |
Beispiel |
| == |
Wert1 gleich Wert2? |
1==1 1==3 |
true false |
| != |
Wert1 nicht gleich Wert2? |
1!=2 1!=1 |
true false |
| < |
Wert1 kleiner Wert2? |
1<2 2<2 |
true false |
| > |
Wert1 größer Wert2? |
2>1 5>5 |
true false |
| <= |
Wert1 kleiner oder gleich Wert2? |
1<=1 3<=2 |
true false |
| >= |
Wert1 größer oder gleich Wert2? |
3>=3 4>=5 |
true false |
| ! |
Nicht Wert |
!(false) !(true) |
true false |
"true" bedeutet, dass die Kommandos in der Schleife ausgeführt werden, "false" bedeutet, dass die Kommandos in der Schleife nicht ausgeführt werden...
Falls man mehrere Bedingungen verknüpfen möchte, gibt es die beiden folgenden Möglichkeiten:
| && |
Bedingung1 und Bedingung2 |
(1==1) && (2>0) (1<=1) && (2==3) |
true false |
| || |
Bedingung1 oder Bedingung2 |
(1!=1) || (2==2) (1==3) || (2==6) |
true false |
| ! |
Nicht diese Bedingung! |
!(1<0) !(1==1) |
true false |
( "||" = 2x [Alt Gr]+[<] (Meine QWERTZ))
Ich hoffe, dass dir diese Bedingungen klar sind, sonst lies bitte die Einführung in die Boolsche Algebra!
Diese Bedingungen sind für Programmierer sehr wichtig, deshalb ist es auch wichtig, dass du sie kennst.
Nun können wir unser Quadrat-Programm verbessern:
//Quadrat1b.cpp //Quadrat einer eingelesenen Zahl ausgeben #include <iostream> int iquadrat(int izahl); int main() { int ieingabe; int iausgabe; int weiter=1; std::cout << "Quadrat - v1b"; while (weiter==1) { std::cout << "\nQuadrat von:\n>"; std::cin >> ieingabe; iausgabe=iquadrat(ieingabe); std::cout << iausgabe; std::cout << "\nWeiter?\n1 - Weiter\n0 - Ende\n>"; std::cin >> weiter; } return 0; } int iquadrat(int izahl) { return (izahl*izahl); }
Nun (kurz) zum Programm:
 | Einige Bücher/Tutorials benutzen eine Funktion namens "getch", die ein einzelnes Zeichen einliest und danach ohne [↵] weiterläuft. Leider handelt es sich hier nicht um eine Standardfunktion, sondern um eine von Borland. Daher ist diese nur für WINDOS! ;( |
Beachte, dass du so ein Schließen des Programms beim Start über eine graphische Oberfläche verhindern kannst! Es gibt mehrere, oft in Foren zu findende Möglichkeiten:
- Eine Schleife, an deren Ende immer gefragt wird, ob ein weiterer Durchgang folgen soll... (zu empfehlen)
- "system("pause")" ist ein Klassiker: Unsauber und langsam (Bei jedem Aufruf wird eine eigene Shell geöffnet, die die Kommandos ausführt...), außerdem (zumindest "pause") nur für Windows! Bitte nicht für solche Zwecke benutzen... Zu "system()" später mehr!
- Eine weitere Möglichkeit ist das Benutzen von "getchar()", meist in einer Schleife oder bei simplen Programmen...
Fehlerüberprüfung
Auch dieses Programm ist nicht perfekt. Versuche zum Beispiel einmal, einen Buchstaben anstatt einer Zahl einzugeben...
C++ bietet hier einige Möglichkeiten, die Eingabe zu überprüfen:
#include <iostream> #include <limits> //für: std::numeric_limits<>::max() //Diese Funktion löscht alle //Eingaben, die bisher getätigt wurden... std::istream& puffer_weg(std::istream& in) { return in.clear(), in.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); } int main() { int var=0; //default-Wert "0" std::cout << "Eingabe:\n>"; while (!(std::cin >> var)) { std::cerr << "FEHLER: Falsche Eingabe!" << std::endl << ">"; //std::cerr ist meist eine Ausgabe auf den Bildschirm. //Der Unterschied zu std::cout: "cerr" ist für Fehler... ;) //Man kann so zum Beispiel Fehler in eine Datei schreiben, //nur Fehler ausgeben, ... //Dies kommt später... ;) puffer_weg(std::cin); } std::clog << var << "x" << var << "=" << var*var << std::endl; //"clog" ist noch ein Stream, wie auch "cout" und "cerr"... //"clog" dient zum Loggen von Events oder Werten, und kann //ebenfalls in eine Datei umgeleitet werden... ;) return 0; }
Würde man den Puffer nicht löschen, würde es zu einer Endlosschleife kommen. (Genau das passierte bis jetzt bei falschen Eingaben...)
Eigentlich ganz einfach, oder?


 | Achtung! Viele Leute schreiben zum löschen nur ein "fflush(stdin);", was aber schlichtweg falsch ist. "fflush" ist nicht für Eingabestreams definiert! |
Vergleiche in einer Schleife
Um zu überprüfen, ob eine Variable einen bestimmten Wert hat, benutzt man den Vergleichsoperator ("a==b").
 | Wichtig: Zwei Gleichheitszeichen sind ein Vergleich, eins eine Zuweisung. Nicht verwechseln, da sonst kein Vergleich stattfindet und es eine Endlosschleife gibt. (d.h.: Die Schleife hört erst auf, wenn der Computer/das Programm abstürzt... ;) |
Der Datentyp "char" - Buchstaben und Zeichen
Eine Variable des Typs char kann ein ASCII-Zeichen speichern. Um ihm ein solches zuzuweisen, wird entweder der ASCII-Code benutzt (z.b.:"chxy=65") oder das Zeichen in einfachen Anführungstrichen geschrieben ("chxy='A'"). Eine vollständige Liste der ASCII-Zeichen auszugeben ist einfach, man kann aber auch im Internet suchen. Um eine Liste auszugeben, muss man eine Schleife schreiben, die einem character nacheinander alle Werte von 0 bis 127 (255 (mit Codepage/Systemgebundene Zeichen) ) zuweist und dann diesen als Zeichen ausgibt. Dieses Programm schreiben wir auch noch, jetzt aber erstmal eine Einführund in:
Die "for"-Schleife - Schleifen noch kürzer!
Die "for"-Schleife kann dir die Arbeit noch weiter Vereinfachen. Wir wollen ein Programm schreiben, welches (wer hätte es gedacht!) die ASCII Tabelle ausgibt! . Der Aufbau der "for"-Schleife ist etwas komplizierter:
for (int i=5; i<12; i++) { //Mach was! }
- Nach "for (" folgt eine Variable, hier ein Integer mit dem Wert "5".
- Dann ein Semikolon (";") und eine Bedingung.
- Anschließend eine Aktion, hier "i++", welche (meist) die Zählervariable (wird oft mit "i" oder "j" bezeichnet) ändert.
- Die Anweisungen in den geschweiften Klammern werden nun von "i=5" bis "i=11" ("da: 11<12, aber 12 nicht <12") ausgeführt...
- Die "for"-Schleife kann aber auch etwas anders aussehen, es können zum Beispiel mehrere Bedingungen/Variablen/Aktionen genutzt werden, oder gar nicht vorkommen.
- Dann steht zum Beispiel nur ein "for(;1==1;) {}" da, was einfach eine Endlosschleife darstellt, genauso wie "while(1) {}" dies tut. Man kann eine "for"-Schleife immer auch als "while"-Schleife schreiben und umgekehrt! (Ist aber meist unterschiedlich schwer...)
Hier nun das versprochene Anwendungsbeispiel für die ASCII-Tabelle:
//ascii.cpp #include <iostream> int main() { std::cout << "Tabelle:\n"; for (int j=32; j<128; j++) //Die Steuerzeichen am Anfang bleiben weg... { //static_cast gibt hier keine Zahl, sondern das dieser // zugewiesene ASCII-Zeichen aus... ;) std::cout << j << ":" << static_cast<char>(j) << " "; } std::cout << std::endl; return 0; }
Hier haben wir schon einen Cast gebraucht! (Du erinnerst dich? ) Alternativ hätte man auch einen "char" nehmen können, und diesem den Integer einfach zuweisen können:
for (int j=32; j<=ende; j++) //Die Steuerzeichen am Anfang bleiben weg... { char als_char=static_cast<char>(j); std::cout << j << ":" << als_char << " "; }
Willst du noch mehr zu Zeichen und Texten wissen, zum Beispiel, wie man Umlaute oder andere Sprachen implementiert, solltest du dir Unicode anschauen. Allerdings ist das schon etwas(!) schwerer... (Unicode/Codepages)
do-while - Eine letzte Schleifenart
Wir haben bereits die "while"-Schleife angewandt, um einen Codeabschnitt zu wiederholen. Aber es gibt noch eine Unterart der "while"-Schleife: In diesem Abschnitt möchte ich dir die "do...while"-Schleife vorstellen! Es handelt sich hierbei um eine Schleife, deren Inhalt mindestens 1x ausgeführt wird, ideal für kleine Abfragen:
//doweil.cpp ;) //kleines Beispiel zur "do while"-Schleife: #include <iostream> int main() { char antwort; do //Beginn der Schleife... { std::cout<< "Weiter(j/n)?\n"; std::cin >> antwort; //Normalerweise kommt // hier natürlich eine // FEHLERÜBERPRÜFUNG! } while(antwort !='N' && antwort !='n'); //Ende (";"!!!) return 0; }
Variablen in Schleifen ...
...sind lokal! Sie werden direkt nach dem Verlassen der Schleife gelöscht!
Was nun?
Wir haben nun schon unseren Compiler eingerichtet, ein erstes Programm geschrieben, die Ein- und Ausgabe kennen gelernt, mit Variablen und Funktionen gearbeitet, gerechnet und ein grundlegendes Verständnis fürs Programmieren. Der schwerste Teil ist nun vorbei! Du solltest jetzt in der Lage sein, eigene, simple Programme zu schreiben, die nach dem Prinzip "Eingabe-Verarbeitung-Ausgabe" arbeiten.
Wie gehts weiter?
Als nächstes beschäftigen wir uns mit weiteren Sprachmitteln von C++. Wichtig ist zum Beispiel die bedingte Ausführung. Damit können wir zum Beispiel Sicherheitsabfragen machen!
|
| Seite: [1] 2 3 - Drucken |
|