C++-Datentypen: int, double, char, bool und mehr

Warum Typen in C++ wichtig sind

Auf der Seite zu Variablen hast du Werte mit einem expliziten Typ wie int age = 30; deklariert. Dieser Typ ist nicht bloß ein Etikett - er sagt dem Compiler, wie viele Bytes er reservieren soll, wie diese Bytes zu interpretieren sind und welche Operationen erlaubt sind. Wähle den falschen Typ, und du kannst stillschweigend Präzision verlieren, überlaufen oder undefiniertes Verhalten auslösen.

C++ fasst seine eingebauten Typen in wenige Familien zusammen: Ganzzahlen, Gleitkommazahlen, einen Zeichentyp und einen booleschen Typ. Schauen wir uns jeden an und dann die Regeln, über die man stolpert.

Die grundlegenden Typen

Hier ist je ein Beispiel jedes Kerntyps in einem einzigen Programm. Achte auf die Literal-Suffixe (L, f, u) und die einfachen Anführungszeichen bei char:

#include <iostream>
using namespace std;

int main() {
    int    count = 42;          // ganze Zahl, meist 32 Bit
    long long big = 9000000000LL; // breitere Ganzzahl, das Suffix LL
    double price = 19.99;       // 64-Bit-Dezimalzahl (Standard für Dezimalzahlen)
    float  ratio = 0.5f;        // 32-Bit-Dezimalzahl - beachte das f
    char   grade = 'A';         // ein einzelnes Zeichen, einfache Anführungszeichen
    bool   passed = true;       // nur true oder false

    cout << count << " " << big << "\n";
    cout << price << " " << ratio << "\n";
    cout << grade << " " << passed << "\n"; // bool wird als 1 / 0 ausgegeben
}

Ein bool wird standardmäßig als 1 oder 0 ausgegeben, nicht als true/false. Ein char verwendet einfache Anführungszeichen - 'A' ist ein Zeichen, während "A" (doppelte Anführungszeichen) ein String-Literal ist, ein völlig anderer Typ. Diese beiden Fehler sind am Anfang extrem häufig.

Größen sind nicht festgelegt

Das ist die größte Überraschung, wenn man von Sprachen wie Java kommt. Der C++-Standard garantiert nur die Mindestgrößen und eine relative Reihenfolge (short ≤ int ≤ long ≤ long long). Die tatsächliche Größe hängt von deinem Compiler und deiner Plattform ab. Prüfe es immer mit sizeof:

#include <iostream>
using namespace std;

int main() {
    cout << "char:      " << sizeof(char)      << " byte\n";  // immer 1
    cout << "short:     " << sizeof(short)     << " bytes\n";
    cout << "int:       " << sizeof(int)       << " bytes\n";
    cout << "long:      " << sizeof(long)      << " bytes\n";
    cout << "long long: " << sizeof(long long) << " bytes\n";
    cout << "double:    " << sizeof(double)    << " bytes\n";
}

In einem typischen 64-Bit-Linux-Build siehst du int = 4, long = 8. Unter 64-Bit-Windows ist long jedoch nur 4 Bytes groß. Genau diese Portabilitätslücke ist der Grund, warum du keinen Code schreiben solltest, der annimmt, dass long 64 Bit ist.

Wenn du eine exakte Breite brauchst, greife zu den Ganzzahltypen fester Breite aus <cstdint>:

#include <iostream>
#include <cstdint>
using namespace std;

int main() {
    int8_t   a = -120;          // genau 8 Bit, signed
    uint16_t b = 65000;         // genau 16 Bit, unsigned
    int32_t  c = 2000000000;    // genau 32 Bit
    int64_t  d = 9000000000LL;  // genau 64 Bit, auf jeder Plattform

    cout << (int)a << " " << b << " " << c << " " << d << "\n";
}

Verwende int32_t/int64_t für Dateiformate, Netzwerkprotokolle oder alles, was sich auf allen Maschinen identisch verhalten muss. Beachte die Umwandlung (int)a - das Streamen eines 8-Bit-Typs gibt ihn als Zeichen aus, nicht als Zahl, also wandle ihn zuerst um.

Signed vs. unsigned

Jeder Ganzzahltyp gibt es in zwei Varianten. Ein signed-Typ kann negative Werte aufnehmen; ein unsigned-Typ nicht und tauscht den negativen Bereich gegen ein höheres positives Maximum. Das einfache int ist standardmäßig signed.

#include <iostream>
#include <climits>
using namespace std;

int main() {
    unsigned int u = 0;
    u = u - 1;          // wird NICHT zu -1
    cout << u << "\n";  // springt auf 4294967295 (das max unsigned int)

    cout << "int max:  " << INT_MAX << "\n";
    cout << "uint max: " << UINT_MAX << "\n";
}

Von einer vorzeichenlosen 0 zu subtrahieren springt zu einer riesigen positiven Zahl, statt negativ zu werden. Das erwischt die Leute ständig - besonders mit size_t (ein unsigned-Typ), den .size() zurückgibt:

vector<int> v = {1, 2, 3};
// GEFAHR: v.size() ist unsigned. Wenn v leer ist, springt v.size() - 1
// auf eine gigantische Zahl und die Schleife läuft fast endlos.
for (size_t i = 0; i <= v.size() - 1; i++) { /* ... */ }

Bevorzuge i < v.size() (niemals <= size() - 1) oder umgehe das ganze Problem mit einer bereichsbasierten for-Schleife.

Ganzzahlüberlauf ist undefiniertes Verhalten

Anders als der Überlauf von unsigned (der wohldefiniert ist) ist der Überlauf von vorzeichenbehafteten Ganzzahlen in C++ undefiniertes Verhalten. Der Compiler darf alles tun - Müll zurückgeben, die Prüfung wegoptimieren oder abstürzen:

#include <iostream>
#include <climits>
using namespace std;

int main() {
    int maxInt = INT_MAX;            // 2147483647
    cout << maxInt << "\n";
    cout << maxInt + 1 << "\n";      // UNDEFINIERTES VERHALTEN - springt oft ins Negative

    long long safe = (long long)maxInt + 1; // vor der Addition hochstufen
    cout << safe << "\n";            // 2147483648, korrekt
}

Die Lösung ist dieselbe wie die Überlauffalle in jeder Sprache: führe die Arithmetik in einem breiteren Typ aus. Wandle einen Operanden vor dem + in long long um, damit die Addition in 64 Bit erfolgt. Das Ergebnis hinterher umzuwandeln ist zu spät - der Überlauf ist bereits passiert.

Den richtigen Typ wählen

Für den meisten Code sind die Standardwerte in Ordnung: int für ganze Zahlen, double für Dezimalzahlen. Greife nur dann zu etwas anderem, wenn du einen Grund hast.

Typ	Typische Größe	Verwenden, wenn
int	32 Bit	Der Standard für ganze Zahlen
long long	64 Bit	Werte über ~2 Milliarden: Zeitstempel, große Zähler
double	64 Bit	Der Standard für Dezimalzahlen - gute Präzision
float	32 Bit	Speicherknappe Arrays, bei denen Präzision leiden darf
bool	1 Byte	Ein true/false-Flag
int32_t / int64_t	exakt	Plattformübergreifende Formate, Protokolle, Bitmanipulation

Ein paar Fallstricke, die du im Kopf behalten solltest. float hat nur etwa 7 signifikante Dezimalstellen, daher ist 0.1f + 0.2f nicht exakt 0.3 - bevorzuge double, es sei denn, du musst wirklich Speicher sparen. Und char kann je nach Plattform signed oder unsigned sein, also gib signed char oder unsigned char an, wenn du mit rohen Bytes rechnest.

Als Nächstes: Das Schlüsselwort auto

Den Typ jedes Mal auszuschreiben wird mühsam, und manchmal ist der Typ lang oder schwer zu benennen. C++ lässt den Compiler ihn mit dem Schlüsselwort auto für dich ableiten - auto x = 42; macht x zu einem int, und auto it = v.begin(); erspart dir das Tippen eines umständlichen Iterator-Typs. Die nächste Seite behandelt, wann auto den Code klarer macht und wann es zu viel verbirgt.