++i => zuerst wird erhöht oder erniedrigt dann wird die variable benutzt
i++ => zuerst wird die Variable benutzt und dann erhöht oder erniedrigt
Division ganzer Zahlen:
Das Ergebnis ist wieder eine ganze Zahl:
i = 8 / 3; // i erhält den Wert 2
i = i / 3; // i erhält den Wert 0
Den Rest erhält man mit dem Modulo Operator:
i = 8 % 3; // i erhält den Wert 2
i = I % 3; // i erhält jetzt den Wett 2
Rationale Zahlen ( Reelle Zahlen bzw. Gleitkommazahlen):
Darstellung ist eine Ziffernfolge die entweder einen Punkt oder einen Exponenten (E bzw. e) oder beides beinhalten muss.der Exponent bedeutet 10n. Jede rationale Konstante ist vom Typ double. Will man eine Konstante vom Typ float deklarieren, so muss diese mit dem Buchstaben f oder F enden. Für long double ist l oder L zu verwenden.
Variablen die ein einzelnes Zeichen aufnehmen können besitzen den Datentyp char.
Konstante vom Typ char können alle ASCII- Zeichen sein, also Buchstaben, Ziffern und Sonderzeichen.
Ausweisung als Konstante => ` .`
char i, stern; // 2 Variablen vom Typ char vereinbaren
stern = `*`; // zuweisen der Zeichenkonstante * an Variable stern
i = `i`; // zuweisen der Zeichenkonstante i an Variable i
cout << " stern= " << stern << endl; //
cout << endl << " i = " << i << endl;
i = stern; // zuweisen des Inhalts von stren (*) an i
Zu Zeichenkonstenaten gehören auch die Textkonstanten also " ."
Mathematische Funktionen:
einbinden über #include <math.h>
Klammer
Ausdrücke:
Die Rangfolge gibt an in welcher Reihenfolge die Ausdrücke ausgewertet werden wenn keine Klammer vorliegt. Rangstufe 1 bedeutet höchste Priorität.
Typhirarchie:
Treten in einem Ausdruck verschiedene Typen auf so werden die Datentypen zur aktuellen Berechnung gewandelt, so dass alle Operanden den gleichen Datentyp haben.
Ausschlaggebend ist der höchste Operand.
Dieser ist zugleich der Datentyp des Ergebnisses.
Der Typmodifizierer const:
Konstanten sind Datenspeicherstellen die beim Start des Programms vorbesetzt werden und während des Programmlaufs nicht verändert werden dürfen.
const Datentyp Bezeichner = Wert
Bsp.:
const double pi = 3.1415927; // Vereinbart reelle Konstante pi vom Typ double
// deren Wert im Programmlauf nicht geändert // werden darf
Verzweigungen:
Einfache Verzweigung (if) :
if ( bedingung ) { // wenn Bedingung erfüllt AW1 wird ausgeführt
anweisung1;
}
else { //wenn Bedingung nicht erfüllt führe AW2 aus
anweisung2;
}
Mehrfachentscheidungen (switch case):
switch ( ausdruck ) // Fallunterscheidung switch „berechnet“ den Ausdruck und // verzweigt dann zur case-AW die den berechneten Wert zeigt
{ case wert1: anweisungen;
break; // verhindert das abarbeiten der nachfolgenden case- Anweisungen
case wert2: anweisungen;
break;
case wert2: anweisungen;
break;
default: anweisungen; // trifft keiner der werte zu wird mit der default AW // fortgesetzt
}
Bsp.:
int zahl;
cout << “Bitte Zahl von 1 bis 3 eingeben: “ << endl;
cin >> zahl;
switch (zahl)
{ case 1: cout << “Die eingegebene Zahl war 1“ << endl;
case 2: cout << “Die eingegebene Zahl war 2“ << endl;
break;
case 3: cout << “Die eingegebene Zahl war 3“ << endl;
break;
default: cout << “Die eingegebene Zahl lag nicht zwischen 1 und 3“ << endl;
}
Schleifen:
Abweisende Schleife (while Schleife):
AW wird nur ausgeführt wenn die Bedingung erfüllt ist
while ( bedingung ) { anweisung ; } // Auswertung der Bedingung und Ausführung der AW // wenn Bedingung erfüllt. Die Bedingung muss am ende // Schleifenrumpfs neu gesetzt werden=> sonst // Endlosschleife
bedingung
anweisung
oder Anweisungsblock
Bsp.:
int zahl;
cout << “Bitte Zahl von 1 bis 3 eingeben: “ << endl;
cin >> zahl;
while ( zahl <= 3 ) {
cout << “Die Zahl ist noch kleiner oder gleich 3“ << endl;
cin >> zahl;
}
Die nicht abweisende Schleife ( do- while):
Aw wird auf jeden Fall einmal ausgeführt
do
{ // ausführung des Schleifenrumpfs (anweisung)
anweisung(en)
} while ( bedingung ) // Auswertung der Bedingung, wenn erfüllt springe zu // do, wenn nicht verlassen der Schleife.
Anweisung
(oder Anweisungsblock)
Bedingung
Die Zählschleife:
Wenn der Programmierer weiß wie oft eine Schleife durchlaufen werden soll
for ( Initialisierung ; Laufbedingung ; Veränderung ) {
anweisung(en);
}
Initialisierung => i=1 // Schleife beginnt bei i=1 zu zählen
Laufbedingung => i <= 1 // Schleife läuft solange i <= 1 ist
Veränderung => i++ // Zählvariable wird NACH jedem Durchlauf um 1 erhöht