Fast jedes Programm, auch wenn es noch so klein ist, arbeitet mit Variablen. Variablen haben einen Typ, einen Namen und einen Wert. Dieser Wert kann - und wird auch meistens - während der Programmausführung geändert, indem neue Daten (aus Benutzereingaben oder Berechnungen) zwischengespeichert werden. Variablen müssen in C++ deklariert werden, bevor sie benutzt werden können. Dies kann im Gegensatz zu C nicht nur am Anfang eines Blockes geschehen, sondern fast überall. Danach kann man ihr mit Hilfe des = Operators einen Wert zuweisen. Bspw.:

int faktor1;

int faktor2;

int ergebnis;

faktor1 = 4;

faktor2 = 88;

ergebnis = faktor1 * faktor2;

int ist der Variablentyp, der angibt, was für Werte gespeichert werden können: hier eine Ganzzahl. faktor1, faktor2 und ergebnis sind die Namen, mit denen man den entsprechenden Speicher ansprechen kann. In den Zeilen 4-6 wird den einzelnen Variablen Werte zugewiesen. Dies kann man sowohl tun, indem man einen numerischen Wert hinter den Zuweisungsoperator schreibt, als auch indem man den Variablennamen hinschreibt, dessen Wert automatisch substituiert wird. Das Sternchen * der letzten Zeile steht für eine Multiplikation (Übersicht der Operatoren s.u.), sodass ergebnis schließlich die Zahl 352 zugewiesen bekommt. Man braucht die Variablen nicht brav erst deklarieren und dann definieren (Wert zuweisen), sondern kann dies in einem Schritt tun. Auch braucht man für eine Reihe von Variablen gleichen Typs diesen nicht jedesmal erneut angeben, sondern man trennt die einzelnen Namen mit dem Komma-Sequenz-Operator, wobei die Anzahl der Whitespaces (Leerzeichen, Newlines, etc.), wie überall in C++, keine Auswirkung hat. Man kann also die folgende Zeile auch nach den Kommas umbrechen, damit es u.U. etwas übersichtlicher wird:

int faktor1 = 4, faktor2 = 88, ergebnis = faktor1 * faktor 2;

In C++ gibt es einen ganzen Haufen an Datentypen. Im folgenden werde ich die vordefinierten Typen, ihren Werte- und Anwendungsbereich angeben:

bool

char

short

int

long

float

double

long double

void

Von allen aufgezählten Typen ausser bool und void gibt es eine unsigned Variante, die dafür sorgt, dass das Vorzeichen wegfällt, der Bereich sich im Positiven aber verdoppelt. Etwa hat ein  unsigned short  einen Wertbereich von 0 bis 65535.

Man sollte darauf achten, dass man wirklich immer den korrekten Typ nimmt, da wenn man einem double das Ergebnis der Operation 2 * 0.25 zuweist 0.5, bei der Zuweisung an einen int jedoch (die falsche) 0 gespeichert wird. Es ist auch wichtig zu wissen, dass nur globale Variablen (solche die ausserhalb jeder Funktion deklariert sind) automatisch mit 0 initialisiert werden, lokale hingegen enthalten einen zufälligen Wert, sodass man darauf achten muss, sie vor Benutzung zu initialisieren, um das gewünschte Verhalten des Programms gewährleisten zu können.

Neben den Variablen gibt es noch einen verwandten Typus: die Konstanten. Wie der Name schon sagt, kann man ihren Wert nicht ändern, er muss bereits bei der Deklaration, die somit automatisch auch eine Definition ist, angegeben werden. Man kennzeichnet Konstanten, indem man das Schlüsselwort const an den Anfang stellt. Wenn man einen festen Wert an mehreren Stellen im Programm verwendet ist es sinnvoll eine Konstante für ihn zu definieren, da man ihr a) einen sprechenden Namen geben kann und b) wenn sich der Wert ändert, braucht man nicht den ganzen Quellcode zu durchsuchen und an allen Stellen zu ändern, sondern es reicht, wenn man man einfach den neuen Wert bei der Zuweisung der Definition einträgt. Beispiele für Konstanten:

const double PI = 3.14159;

const int ALTER = 89;

Variablen schreibt man i.d.R. mit Klein-, Konstanten mit Großbuchstaben.

Dieser nächste Abschnitt stellt die Operatoren von C++ und deren gewöhnliches Verhalten in Form einer Tabelle vor:

= Zuweisung
* Multiplikation
/ Division
+ Addition
- Subtraktion
% Modulo (Ermittlung des Rest einer Division)
++ Inkrementierung (Erhöhung des Wertes einer Variablen um eine Einheit)
-- Dekrementierung (Erniedrigung des Wertes einer Variablen um eine Einheit)

== gleich
!=  ungleich
< kleiner
> größer
<= kleiner-gleich
>= größer-gleich

&& logisches UND
|| logisches ODER
! logisches NOT

<<  Bitverschiebung nach links
>> Bitverschiebung nach rechts
& bitweises UND
^ bitweises exklusives ODER XOR
| bitweises ODER
 

* / + - % << >> & ^ | mit einem direkt folgendem = (etwa += ) führt die entsprechende Operation aus, verwendet den Wert links des = als erstes Argument und weist das Ergebnis diesem danach zu.
Folgendes ist also äquivalent:

wert = wert + 11;

wert += 11;

Für den Spezialfall:

wert = wert + 1;

wert += 1;

wert++;

++wert;

Um Variablen bzw. Konstanten auszugeben muss man cout (s. Teil 1) folgendermaßen anwenden:

int alter = 89;
std::cout << "Ich bin " << alter << " Jahre alt!\n";

Der << Operator, der eigentlich eine Bitverschiebung durführt, ist für diesen speziellen Fall
überladen, und "kontaktiert" die einzelnen Teile, die auf den Bildschirm verschoben werden sollen.

Die Schwester (oder ist es der Bruder?) von cout ist cin . Es wird gleich angewandt (nur
<< wird durch >> ersetzt) wie cout, ist jedoch für die Abfrage von Benutzereingaben (von der
Tastatur) zuständig.

int alter;
std::cout << "Wie alt bist du?\t";
std::cin >> alter;
std::cout << "\n\nMan sieht dir garnicht an, dass du schon " << alter << " bist!\n";

Prinzip verstanden? Wie wär's mit folgender Übung bis zum näxten Mal?

Das Prog fragt höflich nach dem Alter des Benutzers und errechnet dann, wieviele Sekunden
gleich der Zahl seiner Lebensjahre sind (Jahr immer 365.25 Tage!). Diese gibt es dann
wieder auf dem Bildschirm aus. (richtigen Variablentyp wählen, um einem Überlauf entgegenzuwirken!)
 

Eine mögliche Lösung der Aufgabe des ersten Teils:

#include <iostream>
int main() {
  std::cout << "Hallo Welt!\n\nC++ ist\t(nicht)\tschwer!\n";
  return 0;
}

Viel Spaß beim Lernen und Ausprobieren wünscht

 Jolly Roger
 webmaster@christoph-mueller.de
 http://www.christoph-mueller.de