C++-Programmierung/ Einführung in C++/ Rechnen (lassen)
Aus Wikibooks
In diesem Kapitel soll unser Rechner einmal das tun, was er ohnehin am besten kann: Rechnen. Wir werden uns derweil zurücklehnen und zusehen oder besser gesagt, werden wir das tun, nachdem wir ihm mitgeteilt haben, was er rechnen soll.
Inhaltsverzeichnis |
[Bearbeiten] Einfaches Rechnen
int main(){
std::cout << "7 + 8 = " << 7 + 8 << std::endl; // Ausgabe einer Rechnung
}
Zugegebenermaßen hätten Sie diese Rechnung wahrscheinlich auch im Kopf lösen können, aber warum sollten Sie sich so unnötig anstrengen. Ihr Rechner liefert doch auch das richtige Ergebnis und wenn Sie dies mit der Eingabe von Zahlen kombinieren, können Sie sogar bei jedem Programmdurchlauf zwei unterschiedliche Zahlen addieren:
int main(){
int Summand1, Summand2; // Anlegen von 2 Variablen
std::cin >> Summand1 >> Summand2; // 2 Zahlen eingeben
std::cout << Summand1 << " + " << Summand2 // beide durch " + " getrennt Wieder ausgeben
<< " = " // " = " ausgeben
<< Summand1 + Summand2 // Ergebnis berechnen und ausgeben
<< std::endl; // Zeilenumbruch
}
Benutzereingabe: 123
774 + 123 = 897
Das Ergebnis lässt sich natürlich auch in einer Variable zwischenspeichern. Folgendes Beispiel demonstriert diese Möglichkeit:
int main(){
int Summand1, Summand2, Ergebnis; // Anlegen von 3 Variablen
std::cin >> Summand1 >> Summand2; // 2 Zahlen eingeben
Ergebnis = Summand1 + Summand2; // Ergebnis berechnen
std::cout << Summand1 << " + " << Summand2 // beide durch " + " getrennt wieder ausgeben
<< " = " // " = " ausgeben
<< Ergebnis // Ergebnis ausgeben
<< std::endl; // Zeilenumbruch
}
Benutzereingabe: 300
400 + 300 = 700
[Bearbeiten] Die großen 4
C++ beherrscht die 4 Grundrechenarten: Addition ( +), Subtraktion ( -), Multiplikation ( *) und Division ( /). Genau wie in der Mathematik gilt auch in C++ die Regel Punktrechnung geht vor Strichrechnung und Klammern gehen über alles. Das folgende Beispiel soll eine komplexere Rechnung demonstrieren:
int main(){
int Ergebnis; // Anlegen einer Variable
Ergebnis = ((3+3*4)/5-1)*512-768; // Ergebnis berechnen
std::cout << "((3+3*4)/5-1)*512-768 = " // Aufgabe ausgeben
<< Ergebnis // Ergebnis ausgeben
<< std::endl; // Zeilenumbruch
}
Gerechnet wird in dieser Reihenfolge:
3 * 4 = 12 3 + 12 = 15 15 / 5 = 3 3 - 1 = 2 2 * 512 = 1024 1024 - 768 = 256
Sie sollten darauf achten, immer die gleiche Anzahl öffnende und schließende Klammern zu haben, denn dies ist ein beliebter Fehler, der von Anfängern meist nicht so schnell gefunden wird. Compiler bringen in solchen Fällen nicht selten Meldungen, die einige Zeilen unter dem eigentlichen Fehler liegen.
[Bearbeiten] Zusammengesetzte Operatoren
C++ ist eine Sprache für schreibfaule Menschen, daher gibt es die Möglichkeit, die Rechenoperatoren mit dem Zuweisungsoperator zu kombinieren. Dies sieht dann folgendermaßen aus:
Zahl += 5; // Zahl = Zahl + 5;
Zahl -= 7; // Zahl = Zahl - 7;
Zahl *= 2; // Zahl = Zahl * 2;
Zahl /= 4; // Zahl = Zahl / 4;
Als Kommentar sehen Sie die Langfassung geschrieben. Diese Kurzschreibweise bedeutet nicht mehr, als dass die vor (!) dem Zuweisungsoperator stehende Rechenoperation mit der Variable auf der linken Seite und dem Wert auf der rechten Seite ausgeführt und das Ergebnis der Variable auf der linken Seite zugewiesen wird. Sie sollten diese Kurzschreibweise der ausführlichen vorziehen, da sie nicht nur die Finger schont, sondern auch noch ein wenig schneller ist.
Am besten werden Sie dies wahrscheinlich verstehen, wenn Sie es einfach ausprobieren. Stehen auf der rechten Seite noch weitere Rechenoperationen, so werden diese zuerst ausgeführt. Das Ganze stellt sich dann also folgendermaßen dar:
Zahl *= 3+4; // Zahl = Zahl * (3+4);
[Bearbeiten] Inkrement und Dekrement
Inkrementieren bedeutet, den Wert einer Variable um 1 zu erhöhen, entsprechend bedeutet dekrementieren 1 herunterzählen. Dem Inkrementoperator schuldet C++ übrigens seinen Namen. Die beiden Operatoren gibt es jeweils in der Präfix und der Postfix Variante. Insgesamt ergeben sich also 4 Operatoren:
Zahl++; // Inkrement Postfix (Zahl == 6)
++Zahl; // Inkrement Präfix (Zahl == 7)
Zahl--; // Dekrement Postfix (Zahl == 6)
--Zahl; // Dekrement Präfix (Zahl == 5)
Der Unterschied zwischen Inkrement ( ++) und Dekrement ( --) ist sofort ohne größeres Nachdenken erkennbar. Der Sinn von Präfix und Postfix ergibt sich hingegen nicht sofort von selbst. C++ schuldet seinen Namen der Postfix-Variante.
Der Unterschied zwischen Präfix und Postfix besteht im Rückgabewert. Die Präfix-Variante erhöht den Wert einer Zahl um 1 und gibt diesen neuen Wert zurück. Die Postfix-Variante erhöht den Wert der Variable ebenfalls um 1, gibt jedoch den Wert zurück, den die Variable vor der Erhöhung hatte.
Das folgende kleine Programm zeigt den Unterschied:
int main(){
int Zahl; // Anlegen einer Variable
std::cout << "Zahl direkt ausgeben:\n";
Zahl = 5; // Zahl den Wert 5 zuweisen
std::cout << Zahl << ' '; // Zahl ausgeben
Zahl++; // Inkrement Postfix (Zahl == 6)
std::cout << Zahl << ' '; // Zahl ausgeben
++Zahl; // Inkrement Präfix (Zahl == 7)
std::cout << Zahl << ' '; // Zahl ausgeben
Zahl--; // Dekrement Postfix (Zahl == 6)
std::cout << Zahl << ' '; // Zahl ausgeben
--Zahl; // Dekrement Präfix (Zahl == 5)
std::cout << Zahl << ' '; // Zahl ausgeben
std::cout << "\nRückgabewert des Operators ausgeben:\n";
Zahl = 5; // Zahl den Wert 5 zuweisen
std::cout << Zahl << ' '; // Zahl ausgeben
std::cout << Zahl++ << ' '; // Inkrement Postfix (Zahl == 6)
std::cout << ++Zahl << ' '; // Inkrement Präfix (Zahl == 7)
std::cout << Zahl-- << ' '; // Dekrement Postfix (Zahl == 6)
std::cout << --Zahl << ' '; // Dekrement Präfix (Zahl == 5)
std::cout << "\nEndwert von Zahl: " << Zahl << std::endl;
}
5 6 7 6 5
Rückgabewert des Operators ausgeben:
5 5 7 7 5
Endwert von Zahl: 5
In einem späteren Kapitel werden Sie noch ein paar zusätzliche Informationen erhalten, was beim Rechnen schief gehen kann und wie Sie es vermeiden. Wenn Sie beim Herumexperimentieren mit Rechenoperationen plötzlich scheinbar unerklärliche Ergebnisse erhalten, dann ist es an der Zeit eine Blick auf dieses Kapitel zu werfen.
Im Anhang zu diesem Kapitel finden Sie:
- Aufgaben und zugehörigen Musterlösungen.
Aufgabe 1:
Rechnen Sie die Ergebnisse die folgenden Aufgaben aus und schreiben Sie ein Programm, welches das Gleiche tut.
Zahl = (500-100*(2+1))*5 Zahl = (Zahl-700)/3 Zahl += 50*2 Zahl *= 10-8 Zahl /= Zahl-200
int main(){
int Zahl;
Zahl = (500-100*(2+1))*5; //1000
Zahl = (Zahl-700)/3; //100
Zahl += 50*2; //200
Zahl *= 10-8; //400
Zahl /= Zahl-200; //2
std::cout << "Zahl: " << Zahl;
}
