Grundlegende Datentypen und Deklaration

Die grundlegenden, eingebauten Datentypen von C++ sind bool, char, int, float, double. Diese Datentypen werden besonders effizient vom Computer bearbeitet.

Der Typ bool wird für die Resultate von Vergleichsoperationen () benutzt. Er kann die Werte true oder false besitzen. Weiterhin ist er frei in den int Datentyp umwandelbar, wobei true einer 1 und false einer 0 entspricht. Diese Umwandlung stellt die Aufwärtskompatibilität zu alten Programmen her, die statt bool einfach int's verwendeten. Einige einfache Deklarationen sind:

  bool    test;                 // declare test
  test  =(0 < 5);               // comparison with result true
                                // test is set to true
  int     i(test);              // i is declared and set to 1

Die Initialisierung/Konstruktion einer Variablen kann in der Form type variable = type_constant oder äquivalent durch type variable(type_constant) erfolgen. Das Gleichheitszeichen an dieser Stelle ist keine Zuweisung, da die Variable gerade erst ins Leben gerufen wird und nicht bereits im Programm existiert.

Der Typ int ist der Datentyp, der auf der jeweiligen Maschine vom Compilerschreiber als der für die Verarbeitung ganzer Zahlen als ``geeignetster'' empfunden wurde. Über seine Größe ist im Standard nichts festgelegt. Mit Hilfe des sizeof Operators kann man seine Größe in Einheiten der Größe eines char erfragen, der gleichzeitig der kleinste Datentyp ist. Ein char wurde vom Compilerschreiber als der für Einzel(schrift)zeichen geeignete Typ gewählt. Verschiedene Rechner unterstützen noch weitere ganzzahlige Datentypen, z.B. neben 32-bit int auch 16 oder 64-bit große Variablen. Diese lassen sich ggf. Deklaration von short und long oder gar (nicht ANSI konform) long long ansprechen. Nach diesen Schlüsselworten darf int fehlen. Man beachte, daß eine Integer-Variable, immer einen ganzzahligen Wert hat - auch wenn man ihr eine reelle Zahl zuweist. Beispiele für integer Deklarationen sind:

  bool    test;                   // declare test
  test  =(0 < 5);                 // (see above)
  int     i(test);                // i is declared and set to 1
  int     j=0;                    // j is declared and set to 0
  long    l, n, m;                // l, n, and m are declared "long"
  short   s1, s2;                 // s1 and s2 are declared "short"
  cout << sizeof(test) << " " 
       << sizeof(i) << " " 
       << sizeof(l) << " "
       << sizeof(s1) << "\n";     // check size of: test, i, l, s1
                                  // Note: this is not guaranteed
                                  // on my machine I get: 8 4 8 2 
                                  // ANSI should give:    1 (for bool)
  i = 37;
  j = 3.5674;                     // ATTENTION
  cout << i << " " << j << "\n";  // this leads to: 37 3

float und double sind Gleitkommatypen einfacher und doppelter Genauigkeit, die zu numerischen Zwecken geeignet sind. long kann zur Modifikation von double verwendet werden, um vierfache Genauigkeit zu erhalten (falls diese unterstützt sein sollte). Die exakte Gleitkommarepräsentation ist abhängig von der Hardware-Unterstützung. Es ist heute (1998) üblich, für doppeltgenaue Gleitkommazahlen zumindest die Grundrechenarten innerhalb der CPU in Rechnerhardware durchzuführen. Einfachgenaue Zahlen müssen dazu erst in doppeltgenaue gewandelt werden. Aus diesem Grund und der allgemein hohen Anforderungen numerischer Rechnungen sollte man float nur noch dort verwenden, wo dies durch z.B. Speicherplatzbeschränkungen erfordert wird.

C/C++ legt nichts über die wirkliche Repräsentation der Variablen im Speicher fest. Insbesondere ist der Speicherbedarf einer Variablen nicht definiert, es gelten aber immer die Beziehungen:
1 = sizeof(char) = sizeof(bool) $\le$ sizeof(short) $\le$ sizeof(int) =
sizeof(unsigned) $\le$ sizeof(long)
und
sizeof(float) $\le$ sizeof(double) $\le$ sizeof(long double)  .

Im allgemeinen sind auf UNIX-Arbeitsplatzrechnern int-Variablen 32, short 16 und char 8 bit lang. Doppeltgenaue doubles erfordern 64 bit, float 32 bit. Die wirklichen Werte können jedoch im Prinzip sogar von Compiler zu Compiler verschieden sein!

Die folgenden Beispiele deklarieren verschiedene Datentypen.

  #include <string>
  using std::string;

  char      c1 = 'x';       // one character: 'x'
  char    c2[] = "hello";   // text array with 5 characters
                            //   (note: length is 6 due to added '\0')
  string    str("hello");   // the C++ way, arbitrary length strings
                            //   (note: length is 5 - no added '\0')
  char      c3 = '\n';      // the new-line character
  int       i_var;          // integer variable with name i_var        
  long int  il_var = 1L;    // long constant 
  short     is_var;         // short integer variable (int per default)
  double    d_var = 34.2;   // real number 34.2 with double precision

Bei char Variablen ist zu beachten, daß einzelne Zeichen mit einem einfachen ' eingeschlossen werden können, längere Zeichenketten jedoch mit dem doppelten " begrenzt werden müssen. Die Variablen c1 und c3 haben beide die Länge Eins, wohingegen die Zeichenkette "hello" im ``Feld'' c2 abrufbar ist und die Länge Sechs hat, da automatisch ein Zeichenkettenende '\0' angefügt wird. (Die Definition char c2 = 'hello'; führt zu einer Fehlermeldung). Flexibler ist die C++ Methode, strings zu benutzen, die den Zeichenkettenterminator '\0' nicht benötigen.

Variablendeklaration sind in C++ nicht auf den Anfang eines Blockes beschränkt (wie in C), sondern können überall erfolgen, wo die Variable erstmals an einer Stelle auftaucht und wo auf sie zugewiesen werden kann. Wichtig ist insbesondere die Deklaration innerhalb einer for(;;) Schleife

    double a;
    cin >> a;              // input a via keyboard
    int    i_trunc = a;    // throw away the fractional part 
    for ( int i=0; i < i_trunc; i++ ) 
    {
       ... 
    }

Im obigen Programm ist i außerhalb der for(;;) Schleife (d.h. nach der letzten zugehörigen geschlossenen Klammer, oder der letzten Anweisung des Schleifenkörpers) nicht mehr existent.

Zusammenfassung
(i) Deklarationen können an fast beliebiger Stelle im Programm stehen
(ii) Initialisierung erfolgt in () oder = Form; es findet keine Zuweisung sondern eine Initialisierung statt!
(iii) sizeof(type) kann eingesetzt werden, wenn die Größe eines Typs im Programm bekannt sein muß, dies ist für die Portabilität zwischen verschiedenen Rechnern interessant.