Grundrechenoperationen

Bringen wir nun etwas Leben in die bisher doch relativ einfachen Programme. In dieser Lektion werden wir uns mit den Grundrechenoperationen befassen die C++ zur Verfügung stellt.

Für Berechnungen stehen die bekannten Rechenoperationen Addition +, Subtraktion -, Multiplikation * und Division / zur Verfügung. Diese Operatoren gelten sowohl für Ganzzahlen wie auch für Gleitkommazahlen.

Wird eine Division mit zwei Ganzzahlen durchgeführt so ist das Ergebnis ebenfalls eine Ganzzahl. Es wird keine Rundung des Ergebnisses durchgeführt. Wollen Sie das Ergebnis der Ganzzahl-Division als Gleitkommazahl erhalten, so müssen Sie die beiden Operanden vor der Division in Gleitkommazahlen konvertieren. Mehr dazu später bei den Typkonvertierungen.

Für Ganzzahlen steht ferner noch der Modulo-Operator % (das Prozentzeichen) zur Verfügung. Er berechnet den Rest einer Division von zwei Ganzzahlen (siehe Beispiel).

#include <iostream>
using namespace std;

// Zwei Ganzzahl-Variablen definieren
short var1=10, var2=3;

int main ()
{
   short result;
   // Division zweier Ganzzahlen
   result = var1/var2;
   cout << var1 << '/' << var2 << '=' << result << endl;
   // Modulo zweier Ganzzahlen
   result = var1%var2;
   cout << var1 << '%' << var2 << '=' << result << endl;
}

10/3=3
10%3=1

Bei allen Operationen gilt stets: Punkt- vor Strichrechnung, d.h. Multiplikation, Division und Modulo vor Addition und Subtraktion. Dese Reihenfolge kann jedoch durch Setzen von entsprechenden Klammerebenen abgeändert werden. Mehr zur Reihenfolge der Operatoren später noch.

Kurzschreibweisen

C++ stellt noch eine Reihe von Kurzschreibweisen für häufig benötigte Rechenoperationen bereit, die in der nachfolgenden Tabelle aufgeführt sind. Diese Kurzschreibweisen können sowohl auf Ganzzahlen wie auch auf Gleitkommazahlen angewandt werden. Die einzige Ausnahme bildet hierbei der Modulo-Operator %=, er ist, wie bereits erwähnt, nur für Ganzzahlen zugelassen.

x++	Erhöht x um 1 nach dessen Auswertung
++x	Erhöht x um 1 vor dessen Auswertung
x--	Vermindert x um 1 nach dessen Auswertung
--x	Vermindert x um 1 vor dessen Auswertung
x += y	Addiert y zu x (x = x + y)
x -= y	Subtrahiert y von x (x = x - y)
x *= y	Multipliziert x mit y (x = x * y)
x /= y	Dividiert x durch y (x = x / y)
x %= y	Weist x den Rest der Division x/y zu (x = x % y)

// Beispiele für Grundrechenoperationen

int X = 10; // Initialisierung der Variablen
int Y = 2;

X++;               // X = X+1 => 11

Y = X++;           // Zuerst Y = X => 11 und dann X = X+1 => 12

Y = ++X;           // Jetzt zuerst X = X+1 => 13 und dann Y = X => 13

X += Y;            // X = X+Y => 13+13 = 26

X %= 5;            // X = X%5 => 26%5 = 1

X += (--Y * 2);    // Zuerst Y = Y-1 => 12 und dann X = X+12*2 => 1+24

Beachten Sie den Unterschied zwischen X++ und ++X bzw. X-- und --X in den Berechnungen.

Beispiel und Übung

Beispiel:

Das Beispiel berechnet zunächst den Zins, den eine fixe Einlage von 66,- EUR bei 3% nach 5 und 6 Jahren bringt nach folgender Formel (ohne Zinseszins):

Zins = Betrag*Zinssatz*Jahre/100

Im Anschluss wird der Zinssatz auf 3.25% erhöht und dann erneut der Zins für 6 Jahre berechnet.

Alle Ausgaben werden auf 2 Nachkommastellen begrenzt. Beachten Sie bitte, dass setprecision(n) alleine die Anzahl der auszugebenden Stellen einer Gleitkommazahl festlegt. Wollen Sie die Anzahl der Nachkommastellen festlegen, so müssen Sie vorher noch den Manipulator fixed in den Ausgabestream einfügen. Sie können im Beispiel versuchshalber ja auch einmal den fixed Manipulator entfernen und sich dann die Ausgabe ansehen.

66.00 EUR bei 3.00% nach 5.00 Jahren 9.90 EUR Zinsen
66.00 EUR bei 3.00% nach 6.00 Jahren 11.88 EUR Zinsen
66.00 EUR bei 3.25% nach 6.00 Jahren 12.87 EUR Zinsen

// Beispiel zu Grundrechenoperationen

// Zuerst Dateien iostream und iomanip einbinden
#include <iostream>
#include <iomanip>

using std::cout;
using std::endl;

// Konstante für Betrag definieren
const double betrag = 66.0;
// Zinssatz (in %) definieren und Anfangswert initialisieren
double zinssatz = 3.0f;
// Variable für aktuelles Jahr definieren und initialisieren
double jahre = 5.0f;
// Variable für Zinsen definieren
double zins;

// main() Funktion
int main ()
{
   // Anzahl der Nachkommastellen auf 2 begrenzen
   cout << std::setprecision(2) << std::fixed;

   // Zinsen nach 5 Jahren berechnen
   zins = (betrag * zinssatz * jahre) / 100.0;
   cout << betrag << " EUR bei " << zinssatz << "% nach "
        << jahre << " Jahren " << zins << " EUR Zinsen\n";

   // nun Zinsen nach 6 Jahren berechnen
   jahre++;
   zins = (betrag * zinssatz * jahre) / 100.0;
   cout << betrag << " EUR bei " << zinssatz << "% nach "
        << jahre << " Jahren " << zins << " EUR Zinsen\n";

   // jetzt bei 3.25% Zinsen
   zinssatz += 0.25;
   zins = (betrag * zinssatz * jahre) / 100.0;
   cout << betrag << " EUR bei " << zinssatz << "% nach "
        << jahre << " Jahren " << zins << " EUR Zinsen\n";
}

Übung:

Nun einmal etwas aus der Welt der Technik:

Berechnen Sie den elektrischen Widerstand (in Ohm) für folgende Kupferleitungen:

Länge 10 m, Querschnitt 1 mm²
Länge 10 m, Querschnitt 2 mm²
Länge 100 m, Querschnitt 2 mm²

Die Formel zur Berechnung des Leitungswiderstands lautet:

Leitungswiderstand = Kupferwiderstand * Länge / Querschnitt

Für den Kupferwiderstand hat die Konstante 0.0172. Die Angabe der Länge innerhalb der Formel erfolgt in m und des Querschnitts in mm².

Wenn Sie die Berechnungen richtig durchgeführt haben, so sollten Sie die unten angegebenen Werte erhalten.

Widerstand bei 10.00 m und 1.00 qmm: 0.17 Ohm
Widerstand bei 10.00 m und 2.00 qmm: 0.09 Ohm
Widerstand bei 100.00 m und 2.00 qmm: 0.86 Ohm

Lösung ansehen!

Zuweisungen

Bit- und Schiebeoperationen

Grundrechenoperationen

Die Themen: