Grundlegende Datentypen und Definition von Variablen

Datentypen (nur die wichtigsten):

C++	Bytes
char	1
int	2/4
long	4/8
float	4
double	8
bool	4

int i = 5;
float y = 3.7;
bool b = true;

Ganze Zahlen versus Fließkommazahlen: Computer sind Rechner ... sehr schnelle Rechner ... jedoch mit begrenztem Zahlenbereich und Rechengenauigkeit (jedenfalls mit den gängigen Compilern/Interpretern)

int: i.a. 32-bit 2-komplement Form (Rechner-abhängig)
$\ensuremath{\displaystyle \quad 5 \equiv 0000....0101 \equiv 00000005 }$
$\ensuremath{\displaystyle -5 \equiv 1111....1011 \equiv \mbox{FFFFFFFB} }$

decimal binär hex

Zahlenbereich $[-2^{31}, 2^{31}-1] \approx \pm 2 \cdot 10^9$
float: 32-bit IEEE-Norm

Bereich: $\approx [-1.2\cdot10^{-38}, 3.4\cdot10^{+38}]$ , ca. 7 Dezimalstellen
double: 64-bit IEEE-Norm

Bereich: $\approx [-2.2\cdot10^{-308}, 1.8\cdot10^{+308}]$ , ca. 16 Dezimalstellen
: Fließkommazahlen werden als Summe von 2er Potenzen dargestellt:
$\ensuremath{\displaystyle (-1)^s \cdot ( b_0 + b_1\, 2^{-1} + b_2\, 2^{-2} + ... + b_{(n-1)}\, 2^{-(n-1)} ) \cdot 2^{exponent}}$

inf und nan

Nicht immer führen Rechnungen zu einem gültigen Ergebnis, d.h. zu darstellbarer Zahl

double a = 0, b=1;
double c = b/a;
double d = sqrt(-1.);

cout << " a = " << a    // ok
<< ", b = " << b        // ok
<< ", c = " << c        // inf
<< ", d = " << d        // nan 
...
// check mit
if ( isinf(c) ) {  // Funktion deklariert in cmath
...

$\bgroup\color{blue}$\pm$\egroup$ inf zeigt an, dass Ergbnis ( $\bgroup\color{blue}$\pm$\egroup$ ) unendlich ist, z.B. Division durch Null, log(0.), ...
nan (Not A Number) zeigt an, dass Ergbnis nicht als reelle Zahl darstellbar ist, z.B. sqrt(-1.), log(-1.), ...

Variablen müssen deklariert sein bevor sie benutzt werden. Die Deklaration kann an jeder Stelle im Programm geschehen ( C++).


     double a = 0;
     a = ...
     double b;
     b = 2 * a;

auto

Neues key-word (C++-11) erlaubt vereinfachte Deklaration von Variablen, wenn sich die Typ–Defintion aus dem Kontext eindeutig ableiten lässt, z.B.:

// C++ 11

auto hellostr = "Hello World!"; // type clear from context -> string

auto x = tan(1.0); // type clear from context -> double

// C++ 03

string hellostr = "Hello World!"; double x = tan(1.0);

Variablen im Detail
Leicht Verwirrung möglich was genau mit Variable gemeint ist, präzise Verwendung der Begriffe wichtig! Ein Ausdruck der Form
double x = 2.7; Image vard

definiert eine Variable.

Diese Variable umfasst vier Dinge:

Identifier (= Name) der Variable ( x)
Typ der Variable ( double).
Wert der Variable ( 2.7)
Adresse der Variable, d.h. wo sie sich im Speicher befindet.

Mit Deklaration einer Variablen ( double x) wird ein dem Typ entsprechender Speicherbereich reserviert, der Identifier erlaubt den Zugriff auf den Wert der an dieser Stelle gespeichert ist bzw. wird. Die Adresse der Variable ist in C++ über Pointer zugänglich $\bgroup\color{green}\ensuremath{\Rightarrow}\egroup$ später

Konstanten und “Literals”

Man kann jederzeit im Programm Zahlenwerte oder Strings direkt hinschreiben, das sind die sog. Literals.

cout <<"9 * 9 = " <<9*9 <

Für simple Zwecke ok, aber bei komplexeren Grössen und/oder häufigem Gebrauch besser als Konstante definieren:

const double C_LIGHT = 2.99792458e8;
const double M_PROTON = 1.6726215813e-27;

Das Keyword const bewirkt dass “Variable” bei Initialisierung festgelegt wird und später nicht mehr geändert werden kann.

Konvention: Grossbuchstaben für Konstanten verwenden !

Ansonsten gilt für Variablen-Namen (Identifier):

1. Zeichen Buchstabe
Dann beliebig viele Buchstaben, Ziffern oder UnderScore ( _), case-sensitiv
MasseDesNeutrons, mass_of_neutron, X127612a8313
Variablen-Name soll möglichst Aufschluss über Inhalt/Verwendung geben

Liste der reservierten Wörter in C++

Dürfen nicht als Namen für Variablen, Funktionen, Klassen verwendet werden!

asm auto bitand bitor bool break case catch char class compl const

const_cast continue default delete do double dynamic_cast else enum explicit export

extern false float for friend goto if inline int long mutable namespace new not not_eq

operator or or_eq private protected public register

reinterpret_cast return short signed sizeof static static_cast struct switch template

this throw true try typedef typeid typename union unsigned using virtual void volatile

wchar_t while xor xor_eq

define else endif if ifdef ifndef include undef

Hinzu kommen noch die Namen gängiger Klassen und Methoden wie
printf cout sin exp ...
Wird zwar syntaktisch von C++ akzeptiert, führt aber leicht ins Chaos ...

Strings/Zeichenketten in C (für Spezialisten):

In C kein eigener Datentyp für Zeichenketten (character strings), sondern gebildet als array (s.u.) von char Variablen:
char s[] = "Hallo" $\bgroup\color{dgreen}$\Rightarrow$\egroup$ 'H'|'a'|'l'|'l'|'o'|' $\bgroup\color{magenta}$\backslash 0$\egroup$ '
Länge = # Buchstaben + 1, $\bgroup\color{magenta}$\backslash 0$\egroup$ wird angehängt zum Kennzeichnen des String–Endes.
Wichtig: Unterschied zwischen single und double quotes:
'a' = single character
"a" = character string mit 2 Elementen: 'a'|' $\bgroup\color{magenta}$\backslash 0$\egroup$ '

In In C++ mittlerweile string Datentyp (als Klasse) definiert

#include <string>
..
string s1("Hello "); // s1 deklariert und initialisiert
string s2; // s2 deklariert
s2 = s1 + "world "; // zusammenketten mit '+'
                    // => s2 = "Hello world"
cout  << s2 <<  endl; // Ausgabe ...
cout  << "Name ? ";
cin  >> s2;            // Einlesen von Tastatur
cout << s1 << s2 << endl;

dynamisches Anlegen/Erweitern bei Verwendung des Strings
“Intuitive” Operationen =, +, +=, [] definiert
I/O direkt in strings mit >>, <<

In C/C++ implizite Typumwandlung von int nach float/double und float nach double
aber Vorsicht, im Zweifelsfall besser explizit (casts):


   int i = 3, k = 1;
   double a = i;
   double b = k/i; // b = 0
   double c = double(k)/double(i); // cast

Zuweisung meist ok, aber Vorsicht bei Rechen–Operationen:
int und float Arithmetik völlig verschieden !

C/C++ bietet darüberhinaus noch komplexere Datentypen an; die structures, die aus beliebigen anderen Typen zusammengesetzt sind (für Spezialisten):


    struct person {
       char *name;
       int  age;
       ...
     }
     struct person gd;
     gd.name = "Guenter Duckeck";
     gd.age  = 0x29;

Diese Funktionalität erlauben auch Klassen, daher selten verwendet in C++ ( $\bgroup\color{green}\ensuremath{\Rightarrow}\egroup$ später).

typedef (für Spezialisten)
damit kann ein Alias zu einem Standard–Datentyp oder einem selbstdefinierten Typ gesetzt werden:


    typedef int Length;
    ....
    Length len, maxlen;

Kann Verständlichkeit des Variablengebrauchs erleichtern, oft aber auch komplex auf echten Datentyp zurückzuschliessen.

Häufig benutzt in C/C++