C++ Teil 3 – Variablen und Konstanten

Inhalt.
Variablen
Cin – Bruder von cout
Datentypen
        Integer-Datentypen
        Gleitkomma-Datentypen
        Zeichen-Datentypen
        Logischer Datentyp
        Datentypen-Übersichtstabelle
Rechnen mit Variablen
        Zuweisung
        Arithmetisches Rechnen
        Besonderheiten beim rechnen mit Gleitkomma-Variablen
Inkrement- und Dekrementoperatoren
Konstanten
Übungsaufgaben

Willkommen im Teil 3 des C++ Tutorials. Im letzten Teil haben wir uns angeschaut, wie man formatierten Text auf den Bildschirm bringt. Nun…diese Möglichkeit ist zwar (fast) in jedem Konsolen-Programm nötig, doch lässt sich damit kein wirklich nützliches Programm schreiben und da sind wir schon beim Thema Variablen, denn diese werden in jedem Programm benutzt.

Variablen.

Eine Variable ist nur ein Name für einen Bereich im Arbeitsspeicher, mit dem wir bzw. das Programm arbeiten kann. Die Variablen sind mit verschiedenen Behältern (z.B. Holzkiste, Flasche, Aktenmappe) in der Realität vergleichbar, in diesen Behältern können verschiedene Sachen gelagert werden z.B. in Kisten die Äpfel, in Flaschen das Mineralwasser, in Aktenmappen die Akten. In C++ können es Behälter für Ganzzahlen, Fließkommazahlen( das sind ganz normale Kommazahlen) oder Zeichen sein. Je nach dem was drin gelagert werden soll, kann man zwischen underschiedlichen Typen von Variablen wählen.

Um eine Variable zu benutzen muss man sie zuerst deklarieren (erstellen). Das sieht in C++ so aus:

Datentyp Variablenname;

Der Datentyp sagt aus, was in der Variable gespeichert werden soll. So steht z.B. int für ganze Zahlen und float für Flieskommazahlen.

Bei der Vergabe von Variablennamen sollten Sie folgendes beachten:

• Umlaute, ß, Whitespace-Zeichen und Sonderzeichen sind nicht erlaubt
• Operatoren (Rechenzeichen, Klammern, …) sind nicht erlaubt
• Das erste Zeichen des Namens darf keine Ziffer sein
• Schlüsselwörter und Funktionsnamen sind nicht erlaubt, können aber Bestandteil des Namens sein
• _ (Unterstrich) kann als Ersatz für ein Leerzeichen verwendet werden
• Möglichst sprechende Namen wählen (z.B. int speed anstatt int s)

Nach dem die Variable deklariert wurde, kann/muss man sie mit einem nützlichen Wert initialisieren (mit einem Anfangswert versehen). Man kann auch sagen die Variable wird definiert.

Datentyp Variablenname; // Deklaration
Variablenname = Wert; //Initialisierung

Das Deklarieren und Initialisieren kann man auch in einem Schritt durchführen.

Datentyp Variablenname = Wert; // Deklaration und Initialisierung

Die Initialisierung ist sehr wichtig, denn nach der Deklaration einer Variablen, sie einen zufälliger Wert besitzt, was natürlich nicht erwünscht ist und häufig später Probleme bereitet.

Die Deklaration von mehren Variablen geht genau so leicht:

int zahl_1 = 0;
int zahl_2 = 0;
int zahl_3 = 0;

und kann sogar verkürzt werden:

int zahl_1 = 0, zahl_2 = 0, zahl_3 = 0;

Bei der Deklaration ist zu beachten, dass der Variablenname nur ein Mal vergeben wird, sonst gibt es einen Compilerfehler. Ist ja auch logisch, da der Compiler nicht entscheiden kann welche Variable er bei einer Berechnung nehmen soll.

An dieser Stelle möchte ich noch mal die Begriffe Deklaration, Definition und Initialisierung explizit beleuchten:

• Deklaration: eine Variable wird erstellt (ab diesem Punkt kann man sie verwenden)
• Definition: einer Variable wird ein Wert zugewiesen (in der Variale abgelegt)
• Initialisierung: erste Definition einer Variable

Cin – Bruder von cout.

Damit es an dieser Stelle nicht zu langweilig wird und ich bessere Beispiele liefern kann, will ich ihnen ein weiteres C++ – befehl vorstellen – cin. Das ist der Bruder von cout und erlaubt uns die Benutzereingaben entgegen zu nehmen.
Die Benutzung von cin ist nicht kompliziert und sollte ohne weitere Probleme durch folgendes Beispiel nachvollziehbar sein.

#include <iostream>
using namespace std;

int main(void)
{
    // Variable für die Eingabe deklarieren
    int eingabe;

    // Dem Benutzer "Hallo" sagen
    cout<<"Hallo! Geben Sie bitte eine Zahl ein." <<endl;

    // Die Benutzereingabe wird in einer Variable
    // abgelegt, die in unserem Fall 'eingabe' heißt.
    // cin wartet bis Neue-Zeile-Befehl(Enter) kommt.
    cin>>eingabe;

    // Die Eingabe zur Kontrolle auf den Bildschirm bringen
    cout<<"Ihre Eingabe war "<< eingabe <<endl;

    // Warten auf die Enter-Taste
    cout<<"Programm-Ende"<<endl;
    cin.get();

    return 0;
}

Datentypen.

Wie Sie schon mitbekommen haben, gibt es in C++ mehrere Datentypen, die zum Teil sehr verschieden sind. Deswegen werde ich an dieser Stelle die Datentypen in drei Bereiche einteilen, die wir Stück für Stück durcharbeiten werden und ganz am Ende gibt es noch eine kleine Übersichtstabelle

Integer-Datentypen.

Variablen mit Integer-Datentypen können nur Ganzzahl-Werte beinhalten können. Zu diesen Typen zählen char, wchar_t, short, int und long. Die Verwendung von diesen Datentypen ist recht einfach und doch gibt es ein paar Besonderheiten zu beachten.
Als erstes muss man wissen welchen Zahlenbereich diese Datentypen beinhalten können. Dazu eine Tabellenübersicht.

Wie Sie erkennen können, hängt der Zahlenbereich von der Speichergröße, die für den jeweiligen Datentyp benötigt wird, ab. Um zu verstehen warum das so ist, muss man wissen, wie die Zahlen vom Computer intern verwaltet werden – nämlich binär. Schauen wir uns den Datentyp char an, es benötigt 8 Bit, was soviel heißt, dass es nur 256 (2 hoch 8 ) Zustände beschreiben kann. Doch 128 + 127 ist nicht gleich 256 werden Sie sagen. Doch, wir haben die Null vergessen, die logischerweise auch ein Zustand ist. Wieso erkläre ich das alles? Nun… was passiert wohl, wenn man der Variable einen Wert zuweist, der größer als ihr Zahlenbereich ist?

#include <iostream>
using namespace std;

int main(void)
{
    // Initialisieren mit einem Wert, der außerhalb des Zahlenbereichs liegt
    short zahl = 50000;

    // Wert ausgeben
    cout <<"Zahl = "<< zahl <<endl;

    // Warten auf die Enter-Taste
    cout<<"Programm-Ende"<<endl;
    cin.get();

    return 0;
}

Da sind wir auch schon bei dem Problem angekommen. Wir versuchen der Variable eine Zahl von Größe 50000 zuzuweisen, obwohl short nur Werte bis +32767 speichern kann. Wenn die Grenze des Zahlenbereichs(short: -32768 +32767) erreicht ist, rechnet der Rechner von der anderen Seite weiter, also von -32768.

Diese Erläuterung entspricht nicht der Tatsache, weil Computer nicht dezimal sondern binär rechnen. Sie soll nur verdeutlichen welche Probleme eventuell auftreten können.

Wenn wir der Variable den Wert 50000 zuweisen, rechnet der Rechner …, 32765, 32766, 32767 und dann weiter auf der anderer Seite -32768, -32767,-32766 und so weiter bis er 50000 Schritte erledigt hat.
Es macht kein Unterschied ob die untere oder obere Grenze überschritten wird, der Rechner macht einfach weiter. Das Überschreiten des maximalen Zahlen Bereiches wird als overflow und Unterschreiten des Zahlenbereichs als underflow bezeichnet.
Damit es zu keinen bösen Überraschungen kommt, muss der Programmier immer genau überlegen welchen Zahlenbereich er abdecken will.

In C++ gibt es eine Möglichkeit den Zahlenbereich eines Integer-Datentyps zu verdoppeln, indem man auf den negativen Zahlenbereich verzichtet. Alles was man dazu machen muss, ist bei der Deklaration vor das Datentyp das Schlüsselwort unsigned dazuschreiben.

unsigned short zahl_1 = 0;

Ab jetzt ist Zahlenbereich nicht mehr -32768 bis 32767 sondern von 0 bis 65535. Das funktioniert auch bei anderen Integer-Datentypen. In der Regel sollte man unsigned immer dann verwenden, wenn man genau weiß, dass die Variable nie einen negativen Wert haben wird. Dazu ein paar Beispiele:

int tankinhalt; // falsch. Negativer Tankinhalt?
int temperatur; // richtig (in Celsius)
unsigned int  eine_zahl; // falsch, kann auch negativ sein
unsigned int  positive_zahl; // richtig

Man sollte noch dazu sagen, dass es auch signed – Schlüsselwort gibt, was eigentlich überflüssig ist, weil wenn man nichts hinschreibt die Variable automatisch signed ist.

int temperatur_a; // hat die gleiche Wirkung wie
signed int Temperatur_b;

Manchmal braucht man eine Variable, die etwas größeren integer Zahlenbereich abdecken. Dies kann erreichen, wenn man bei der Deklaration zwei Mal long hintereinander schreibt, dabei nimmt die Variable 8 Byte Speicher ein und erlaubt das Arbeiten mit Zahlen von -9,223,372,036,854,775,808 bis 9,223,372,036,854,775,807.

long long variable_64bit;

Nun kommen wir zum einen Sonderkind der Datentypen, nämlich int. Das ist ein Systemabhängiger Datentyp, seine Datengröße kann je nach Betriebsystem variieren und damit auch sein Zahlenbereich. Früher, in 16-Bit Zeitalter, belegte int nur 2 Byte und war damit äquivalent zu short. Heute ist int mit long gleichgestellt und Morgen (auf 64Bit OS) wird es 8 Byte groß sein. Manche Programmierer meinen, dass man deswegen kein int verwenden sollte, da man nicht weiß auf welchem Betriebssystem das Programm laufen wird. Ich habe eine andere Meinung dazu, den 16-Bit Programme sollten ohne Probleme auf 32-Bit Betriebsystemen laufen(theoretisch!, denn der Zahlenbereich wird ja größer) und 64-Bit Programme laufen sowieso nicht auf 32-Bit Systemen. Daher, meine ich, dass man int mit ruhigem Gewissen, wo immer man nur will, verwenden darf (An dieser Stelle kommen Schläge von „manchen Programmierern“ ;).

Gleitkomma-Datentypen.

Mit Hilfe von Fließkommadatentypen werden Variablen für Zahlen mit Nachkommastellen deklariert. Es gibt zwei Fließkommadatentypen: float und double.

Was als erstes auffällt, ist, dass Fließkommavariablen ziemlich großen Zahlenbereich abdecken, der in binärer Form gar nicht in 4 bzw. 8 Byte gespeichert werden kann. Das liegt an der internen Speicherung von Fließkommawerten, die ganz anders als bei Integern abläuft. Dazu schauen wir uns zuerst die Abbildung von einem Integerwert im RAM an.

Eine Ganzzahl im RAM(hier: short)

Da Gleitkommatypen einen sehr großen Vor- und Nachkommateil haben können, wäre eine Speicherung wie bei Integern vom Platzbedarf her wenig sinnvoll. Stattdessen wird der Zahlenteil in zwei Teilen gespeichert:

• Der erste Teil enthält den Zahlen-Wert [Mantisse]; bei PI z.B. 314159265
• Der zweite Teil einen Faktor, mit dem der erste Teil malzunehmen ist [Exponent]; bei PI wäre das 10^1

Mantisse und Exponent werden genauso wie bei Integern in binärer Form gespeichert.
Nachstehende bildliche Darstellung soll das ganze verdeutlichen.

Eine Fließkommazahl im RAM

Eine solche Speicherung bringt ein paar Probleme mit sich, die in Abschnitt „Rechnen mit Gleitkommavariablen“ besprochen werden.

Die Initialisierung von Gleitkommavariablen erfolgt genauso wie bei Integern nur wird anstatt von Ganzzahl eine Kommazahl verwendet.

float komma_zahl_1 = 0.0f;
double komma_zahl_2 = 0.0;

Was hat das f hinter der Zahl verloren? Durch dieses f sagen wir dem Compiler, dass es sich wirklich um eine float und nicht double Variable handelt. Es hat den Hintergrund, dass manche Compiler alle Gleitkommavariablen als double behandeln, egal ob diese als float oder double deklariert wurden. Wenn man ein f dazu macht, bedeutet es float und ohne f – double. Wie ich schon gesagt habe, dieses Verhalten weisen nur einige Compiler auf und trotzdem sollten Sie sich dieser Schreibweise angewöhnen, den sie funktioniert auf jedem Compiler.

Gleitkommavariablen können wie auch Integer-Variablen negative Zahlen beinhalten, es besteht aber keine Möglichkeit den Zahlenbereich zu vergrößern wie es bei Integern mit unsigned geht.

unsigned float komma_zahl_1 = 0.0f; // Compiler-Fehler!
unsigned double komma_zahl_2 = 0.0; // Compiler-Fehler!

Zeichen-Datenypen.

Den Datentyp für Zeichen kennen Sie bereits schon – es ist char (Abkürzung von: character). Obwohl der char Datentyp Integerwerte speichert, wird es in meisten Fällen für das Speichern von einzelnen Zeichen verwendet. Es ist nämlich so, dass die Zeichen (Buchstaben, Zahlen u.s.w.) in C++ in einer Tabelle verwaltet werden, in der jedem Zeichen ein Wert zugewiesen ist. Wenn man versucht einen char-Wert, sagen wir mal 65, mit cout auszugeben, so wird der Compiler automatisch erkennen, dass es sich um einen char-Wert handelt und an Stelle von 65 bekommen wir ein Zeichen, dass diesem Wert in der Tabelle zugeordnet ist, bei 65 ist es ‚A‘.
Eine kleine Beispielanwendung soll das ganze noch mal verdeutlichen.

#include <iostream>

using namespace std;

int main(void)
{
    // Das einzelne Zeichen muss in
    // einfachen Anführungszeichen stehen
    char zeichen1 = 'A';

    char zeichen2 = 65;

    // Die Ausgabe wird identisch sein
    cout <<"zeichen1 = " <<zeichen1 << endl;
    cout <<"zeichen2 = " <<zeichen2 << endl;

    // Warten auf die Enter-Taste
    cout<<"Programm-Ende"<< endl;
    cin.get();

    return 0;
}

An dieser Stelle möchte ich anmerken, dass eine char-Variable nur ein Zeichen speichern kann.

In Wirklichkeit ist string kein fundamentaler Datentyp, sondern eine Klasse, aber dazu kommen wir später.

Um ganze Wörter in einer Variablen speichern können, muss man auf char-Felden (dazu später) zurückgreifen oder man nimmt einfach den string-Datentyp, der genauso wie die anderen Typen verwendet wird.
Man sollte beachten, dass in C++ streng zwischen einen einzelnem Zeichen und einer Zeichenkette(String) unterschieden wird. So wird ein einzelnes Zeichen immer in einfachen und Zeichenketten in doppelte Anführungszeichen eingeschlossen.
Für die jenige, die schon jetzt mit string-Klasse arbeiten möchten, hier ein kleines Beispiel ohne Erläuterung.

#include <iostream>
#include <string>

using namespace std;

int main(void)
{

    string text = "Hallo! Wie lautet ihr Vorname?";

    cout <<text <<endl <<"Antwort: ";

    cin >> text;

    cout <<"Ihr Vorname lautet:" <<text <<endl;

    // Warten auf die Enter-Taste
    cout<<"Programm-Ende"<<endl;
    cin.get();

    return 0;
}

Logischer Datentyp

Als letzten Datentyp möchte ich ihnen bool vorstellen. Dieser Datentyp kennt nur zwei Zustände und ist damit wohl der einfachste Datentyp in C++. Er wird immer dann verwendet, wenn nur zwei Zustände (an/aus, auf/zu) beschrieben werden müssen. Durch die Schlüsselwörter false und true wird festgelegt, welchen Zustand bool haben soll. Bei Ausgabe bool-Variablen durch cout, wird true durch 1 und false durch 0 repräsentiert. Der umgekehrte Weg geht auch, also wenn man mit cin einen Zustand in bool-Variable ablegen möchte, so wird 0 zu false und 1 zu true.

#include <iostream>
using namespace std;

int main(void)
{

    // bool – Variable anlegen
    bool motor_an = false;

    // Status ausgeben
    cout <<"Der Motor ist(0 = aus/ 1 = an): "<< motor_an <<endl;

    // Benutzer fragen
    cout <<"Möchten Sie den Motor starten?" <<"(0 = nein/ 1 = ja):"<<endl;

    // Neuen Status einlesen
    cin >> motor_an;

    // Status ausgeben
    cout <<"Der Motor ist(0 = aus/ 1 = an): "<< motor_an <<endl;

    // Warten auf die Enter-Taste
    cout<<"Programm-Ende"<<endl;
    cin.get();

    return 0;
}

Datentypen-Übersichtstabelle.

Alle durchgangenen Datentypen werden als fundamentale Datentypen bezeichnet, da diese immer verfügbar sind. Aus dieser Aussage lässt sich ableiten, dass es auch andere Datentypen gibt(diese sind aus den Fundamentalen Datentypen zusammengesetzt). Wir kommen in einem späterem Turorila darauf ein, wie man eigene Datentypen definiert.
Wie versprochen, gibt es am Ende eine kleine Übersicht zu allen fundamentalen Datentypen.

Puh…, das war ein ganz großer Brocken. Bis jetzt haben wir nur gelernt, was es so für Datentypen gibt, für was sie gut sind, wie man sie initialisiert und welche Probleme dabei eventuell auftreten können. Soweit so gut, den theoretischen Teil haben wir geschafft – jetzt kommt der praktische.

Rechnen mit Variablen.

Im Folgenden schauen wir uns an, wie man mit Variablen rechnet. Dies ist nicht sonderlich schwer und man kennt es vielleicht schon ähnlich aus dem Mathematikunterricht.

Zuweisung.

Die Zuweisung erfolgt durch den Zuweisungsoperator (=). Dabei sollte man die Reihenfolge der Zuweisung beachten: der Inhalt von R-Wert(right value) wird in L-Wert(left value) kopiert, wobei R-Wert eine „feste“ Zahl oder eine Variable und L-Wert nur eine Variable sein kann.

Variablenzuweisung

// Beispiel: R-Wert ist eine Konstante

#include <iostream>
using namespace std;

int main(void)
{
    // Variable Temperatur wird angelegt.
    // Ab dieser Stelle ist sie für den Compiler bekannt.
    int Temperatur = -40;

    cout <<”Im Winter betraegt die Temperatur in Westsibirien “
        <<Temperatur <<” C” <<endl;

    // der Variable wird ein neuer Wert zugewiesen
    Temperatur = 40;

    cout <<”Im Sommer betraegt die Temperatur in Westsibirien “

        <<Temperatur <<” C” <<endl;

    // Warten auf die Enter-Taste
    cout<<”Programm-Ende”<<endl;
    cin.get();

    return 0;

}

// Beispiel: R-Wert ist eine Variable

#include <iostream>
using namespace std;

int main(void)
{
    int Temp_Som = 40;

    // Variable Temperatur wird angelegt.
    // Ab dieser Stelle ist sie für den Compiler bekannt.
    int Temperatur = -40;

    cout <<”Im Winter betraegt die Temperatur in Westsibirien “

        <<Temperatur <<” C” <<endl;

    // der Variable wird ein neuer Wert zugewiesen
    Temperatur = Temp_Som;

    cout <<”Im Sommer betraegt die Temperatur in Westsibirien “
        <<Temperatur <<” C” <<endl;

    // Warten auf die Enter-Taste
    cout<<”Programm-Ende”<<endl;
    cin.get();

    return 0;
}

Arithmetisches Rechnen.

In C++ wird mit Variablen ähnlich wie in der Mathematik gearbeitet, nur müssen die Variablen bereits definiert sein und die Zeile in der die Anweisung steht mit einem Semikolon abgeschlossen werden.

Dieser Abschnitt ist relativ leicht und braucht keine Erläuterung. Schauen Sie sich die Beispiele an und ich bin mir sicher, Sie werden alles ohne Probleme nachvollziehen können. Als weiteren Tipp empfehle ich die Beispiele zu erweitern oder auch eigene zu schreiben.

// Addition und Subtraktion

#include <iostream>
using namespace std;

int main(void)
{
    // Variablen deklarieren und initialisieren
    int A = 500;
    int B = 100;
    int C = -300;
    int D = 0;

    // D = -300 + 500 = 200
    D = C + A;

    // A = 200 - 500 -(-300) - 200 = -200
    A = D - 500 - C - 200;

    // C = 200 + (-200) = 0
    C = D + A;

    // B = -200 + 100 + 0 + 200 = 100
    B = A + 100 + C + D;

    cout <<"A="<<A <<" B="<<B<<" C="<<C<<" D="<<D<<endl;

    // Warten auf die Enter-Taste
    cout<<"Programm-Ende"<<endl;
    cin.get();

    return 0;
}

// Multiplikation, Division und Modulo

#include <iostream>
using namespace std;

int main(void)
{
    // Variablen deklarieren und initialisieren
    int A = 500;
    int B = 100;
    int C = -300;
    int D = 0;

    // B = -300 * 500 = -150000
    B = C * A;

    // A = -150000 /-(-1500) = 100
    A = B / (- 1500);

    // B = 100 / 0 = nicht definiert, muss geändert werden
    B = A / D; // Fehler

    // B = -200 + 100 + 0 + 200 = 100
    B = A + 100 + C + D;

    // Modulo liefert den Rest einer Division
    // D = 29%3 = 2
    D = 29%3;

    cout <<"A="<<A <<" B="<<B<<" C="<<C<<" D="<<D<<endl;

    // Warten auf die Enter-Taste
    cout<<"Programm-Ende"<<endl;
    cin.get();

    return 0;
}

Bei der Division muss man aufpassen, dass das Ergebnis auch eine Ganzzahl wird, ansonsten fallen Nachkommastellen weg (dazu mehr im Teil 4).

Wie Sie im nächsten Beispiel sehen können, beherrscht C++ mathematische Regeln, wie Punkt vor Strich Rechnung. Die Benutzung von Klammern ist auch erlaubt.

#include <iostream>
using namespace std;

int main(void)

{
    // Variablen deklarieren und initialisieren
    long Ergebnis = 0;

    // 80-4*5+10/2 = 80-20+5 = 65
    Ergebnis = 80-4*5+10/2;
    cout <<”80-4*5+10/2 = “<< Ergebnis <<endl;

    // (2+3)*(2-3) = 5*(-1) = -5
    Ergebnis = (2+3)*(2-3);
    cout <<”(2+3)*(2-3) = “<< Ergebnis <<endl;

    // Warten auf die Enter-Taste
    cout<<”Programm-Ende”<<endl;

    cin.get();

    return 0;
}

Als nächstes kommt ein weiteres Beispiel, welches auf den ersten Blick ein wenig seltsam vorkommt.

#include <iostream>

using namespace std;

int main(void)
{
    // Ergebnis-Variable
    long Ergebnis = 500;

    // Zuerst wird auf der rechter Seite 500 mit 100 addiert und
    // dann wird 600 der Variable Ergebnis zugeordnet.
    Ergebnis = Ergebnis + 100;

    cout <<”Ergebnis = “<< Ergebnis <<endl;

    // Warten auf die Enter-Taste
    cout<<”Programm-Ende”<<endl;

    cin.get();

    return 0;
}

Alle vier Grundrechenarten können in einem spezial Fall (Beispiel drüber) in einer gekürzter Form geschrieben werden. So könnte man die Zeile Ergebnis = Ergebnis + 100 auch als Ergebnis += 100 geschrieben werden.

Das sieht vielleicht auf den ersten Blick komisch aus, wird aber sehr oft gebraucht.

Besonderheiten beim rechnen mit Gleitkomma-Variablen.

Es gibt kein Modulo für Fließkommazahlen.

Einige Besonderheiten für die Zukunft. Es ist normal wenn:

• Bei der Subtraktion zweier fast gleich großer Werte die Differenz ungenau wird
• Die Division durch zu kleine Werte einen Überlauf (overflow) ergibt
• Eine Unterschreitung (underflow) auftritt, falls das Ergebnis zu klein ist um es mit dem gegebenen Datentyp darzustellen
• Das Ergebnis, je nach Reihenfolge der Berechnungen, unterschiedlich ausfällt, obwohl doch mathematisch gesehen immer das gleiche Ergebnis kommen müsste

Ein praktisches Beispiel mit Verwendung von float.

// Rechteckfläche berechnen

#include <iostream>
using namespace std;

int main(void)
{

    float Laenge = 0.0f;
    float Hoehe = 0.0f;
    float Flaeche = 0.0f;

    // Benutzer auffordern Daten einzugeben
    cout << “Geben Sie bitte die Laenge der Grundseite eines “;
    cout << “Dreiecks ein.” <<endl <<”Laenge = “;

    // Benutzer-Eingabe entgegen nehmen
    cin >> Laenge;

    // Benutzer anfordern Daten einzugeben
    cout << “Geben Sie bitte die Hoehe des Dreiecks ein.”<<endl;
    cout << “Hoehe = “;

    // Benutzer-Eingabe entgegen nehmen
    cin >> Hoehe;

    // Dreiecksfläche berechnen F=(a*h)/2
    Flaeche = (Hoehe * Laenge)/2;

    // Fläche ausgeben

    cout << “Die Flaeche betraegt ” << Flaeche <<” FE.”<<endl;

    // Warten auf die Enter-Taste
    cout<<”Programm-Ende”<<endl;
    cin.get();

    return 0;
}

Inkrement- und Dekrementoperatoren.

Inkrementoperator ist ++ und Dekrementoperator ist –. Der erste bedeutet, dass der Wert der Variable um eins erhöht wird und der letzte, dass der Wert um eins kleiner wird.

// Inkrement- und Dekrementoperatoren 1

#include <iostream>
using namespace std;

int main(void)
{
    int a = 100;
    int b = 100;

    a++; // a wird inkrementiert (a = a+1; bzw. a+=1;)
    b–; // b wird dekrementiert (b = b-1; bzw. b-=1;)

    cout <<”a = “<<a <<endl;
    cout <<”b = “<<b <<endl<<endl;

    ++a; // a wird inkrementiert (a = a+1; bzw. a+=1;)
    –b; // b wird dekrementiert (b = b-1; bzw. b-=1;)

    cout <<”a = “<<a <<endl;
    cout <<”b = “<<b <<endl;

    // Warten auf die Enter-Taste
    cout<<”Programm-Ende”<<endl;
    cin.get();

    return 0;
}

Wie Sie sehen, kann man die beiden Operatoren vor oder nach der Variablen stehen. Im Blick auf die Geschwindigkeit, spielt es bei heutigen Compilern, im Gegensatz zu älteren, keinen Unterschied (++a war schneller als a++) welche Variante man verwenden, weil der Compiler die Optimierung automatisch ausführt. Dieser Geschwindigkeitsvorteil beruht auf einem Unterschied in der Arbeitsweise zwischen den beiden Varianten. Dies wird jetzt etwas beleutet, dazu ein Beispiel:

// Inkrement- und Dekrementoperatoren 2

#include <iostream>
using namespace std;

int main(void)
{
    int a = 100;
    int b = 100;

    b = a++;   // b = 100 (!) nicht 101

    cout <<”a = “<<a <<endl;

    cout <<”b = “<<b <<endl<<endl;

    b = ++a;   // b = 102

    cout <<”a = “<<a <<endl;
    cout <<”b = “<<b <<endl;

    // Warten auf die Enter-Taste
    cout<<”Programm-Ende”<<endl;
    cin.get();

    return 0;
}

Schauen wir uns die Zeile b = a++ an. Hier wird zuerst der Wert der Variable a der Variable b zugewiesen und erst danach wird die Variable a inkrementiert.

Bei der Zeile b = ++a wird zuerst die Variable a inkrementiert und danach der Wert von a der Variable b zugewiesen.
Das war alles auf was man achten muss. Und noch ein Tipp: Zeilen wie int c = –a-b++*(b+++a++)-b—a–; sollte man am besten in mehrere Anweisungen aufteilen ;)

Konstanten.

Das wichtigste Merkmal einer Konstante ist ihre Unveränderbarkeit. Sie kennen bereits mindestens eine Konstante:[math] \pi = 3.14… [/math]

In C++ ist eine Konstante eine Variable, die am Anfang initialisiert, aber im späteren Programmablauf nicht mehr verändert werden kann.
Eine Konstante wird dadurch das Schlüsselwort const gekennzeichnet, welches vor die Variablendeklaration geschrieben wird (so wie unsigned).

int variable = 0;
const int konstante = 0;
const double PI = 3.14159265358979;
const float c = 299792500;

Eine Konstante hat zum einen den Vorteil, dass man sich Tipparbeit spart und der Code leserlicher wird. Der zweite Vorteil ist der, dass man den Wert wie PI nicht aus versehen verändern kann.
Allgemein lässt sich sagen, dass eine Variable, die im Laufe des ganzen Programms nur einen denselben Wert beinhält, durch eine Konstante ersetzt werden sollte.

Übungsaufgaben.

1. Zählen Sie 5 Datentypen auf und beschreiben sie diese kurz
2. Welche von diesen Variablen werden nicht von C++ unterstützt: temp_3, 4ever, große_variable, INHALT, drei/sieben, extra_long, char?
3. unsigned – für was ist es gut?
4. Nennen Sie einen Datentyp, der die Zahl [math] \pi [/math] beinhalten könnte
5. Wie lautet der Datentyp, der nur zwei Zustände beschreibt?
6. Durch welche Anweisung können Benutzereingaben abgefragt werden?
7. Was bedeutet R-Wert?
8. Gekürzte Schreibweise von a) c = c / b       b) a = a-1       c) a = a + a
9. Variablenwert um eins erhöhen mit Fach-Ausdruck beschrieben
10. Schreiben Sie ein Programm, welches die Oberfläche eines Zylinders berechnet (siehe Beispiel für ein Dreick)