Ausführbare C-Docs: Datentypen

Q: Was sind die grundlegenden Datentypen in C?

Vier Basistypen: char für einzelne Zeichen und Bytes, int für ganze Zahlen, float und double für Dezimalzahlen. Modifikatoren ändern Größe und Vorzeichen - short, long, long long, signed und unsigned - und ergeben den vollständigen Satz.

Q: Was ist der Unterschied zwischen float und double in C?

float hat 4 Bytes mit etwa 7 signifikanten Dezimalstellen; double hat 8 Bytes mit etwa 15. Double ist die Voreinstellung für Gleitkommaliterale und Mathematikfunktionen, und solange du nicht Millionen von Werten speicherst oder auf einen Embedded-Chip zielst, ist double die richtige Wahl.

Q: Was passiert, wenn ein int in C überläuft?

Bei einem vorzeichenbehafteten int ist ein Überlauf undefiniertes Verhalten - der Compiler darf umschlagen, sättigen oder die Prüfung ganz wegoptimieren. Bei einem vorzeichenlosen int ist er vollständig definiert: Der Wert schlägt modulo 2^N um, UINT_MAX + 1 ist also 0. Verlass dich nie auf einen vorzeichenbehafteten Überlauf.

Jede Variable in C hat einen Typ, der bei der Deklaration gewählt wird und für ihre gesamte Lebensdauer feststeht. Der Typ entscheidet drei Dinge: wie viele Bytes die Variable belegt, wie diese Bytes gedeutet werden und welche Operationen auf ihr sinnvoll sind.

Die Typliste von C ist kurz. Die Komplexität steckt in den Modifikatoren.

Die vier Basistypen

#include <stdio.h>

int main(void) {
    char  initial = 'K';        /* ein Zeichen / ein Byte */
    int   count   = 42;         /* ganze Zahl */
    float ratio   = 3.14f;      /* Dezimalzahl, einfache Genauigkeit */
    double precise = 3.141592653589793;  /* Dezimalzahl, doppelte Genauigkeit */

    printf("char:   %c\n", initial);
    printf("int:    %d\n", count);
    printf("float:  %f\n", ratio);
    printf("double: %.15f\n", precise);
    return 0;
}

char fasst ein Byte. Es wird für einzelne Zeichen ('A'), für die Bytes einer Zeichenkette und manchmal als winzige Ganzzahl benutzt.
int ist das Arbeitstier unter den Ganzzahltypen. Schleifenzähler, Größen, IDs.
float und double fassen reelle Zahlen. double hat etwa die doppelte Genauigkeit.
void ist in gewissem Sinne der vierte Typ, bedeutet aber „kein Wert" - du kannst keine void-Variable deklarieren, sondern es nur als Rückgabetyp einer Funktion, als leere Parameterliste oder als typlosen Zeiger benutzen.

Beachte das Suffix f bei 3.14f. Ohne es ist das Literal ein double, und es einem float zuzuweisen verliert still an Genauigkeit. Manche Compiler warnen davor.

Modifikatoren: short, long, unsigned

Die ganzzahligen Basistypen kommen mit Modifikatoren, die Größe oder Vorzeichen ändern.

#include <stdio.h>

int main(void) {
    short small = 32000;
    int normal = 2000000;
    long big = 2000000000L;
    long long huge = 9000000000000000000LL;

    unsigned int positive_only = 4000000000U;

    printf("short:        %hd\n", small);
    printf("int:          %d\n", normal);
    printf("long:         %ld\n", big);
    printf("long long:    %lld\n", huge);
    printf("unsigned int: %u\n", positive_only);
    return 0;
}

Jeder Ganzzahltyp braucht seine eigene Formatangabe: %hd für short, %d für int, %ld für long, %lld für long long, %u für unsigned. Die falsche zu benutzen ist undefiniertes Verhalten, kein Rundungsfehler.

unsigned entfernt das Vorzeichenbit und verdoppelt den positiven Bereich. Ein unsigned int fasst 0 bis etwa 4,3 Milliarden statt -2,1 bis +2,1 Milliarden. Es ist die richtige Wahl für Dinge, die wirklich nicht negativ sein können - Größen, Byteanzahlen, Bitmuster - und eine Falle für alles, von dem unter null subtrahiert werden könnte.

signed ist die Voreinstellung für int, short, long und long long, du schreibst es also fast nie. Die eine Stelle, an der es zählt, ist char: Ob ein schlichtes char vorzeichenbehaftet oder vorzeichenlos ist, ist implementierungsabhängig, schreibe also signed char oder unsigned char, wenn das Vorzeichen zählt.

Größen: was du tatsächlich bekommst

Der C-Standard gibt Mindestgrößen vor, keine exakten. Auf jeder modernen 64-Bit-Maschine mit Linux, macOS oder Windows siehst du dies:

Typ	Typische Größe	Typischer Bereich
`char`	1 Byte	-128 bis 127 (oder 0 bis 255)
`short`	2 Bytes	-32.768 bis 32.767
`int`	4 Bytes	-2.147.483.648 bis 2.147.483.647
`long`	8 Bytes (4 unter Windows)	grob ±9,2 Trillionen
`long long`	8 Bytes	grob ±9,2 Trillionen
`float`	4 Bytes	~7 signifikante Stellen
`double`	8 Bytes	~15 signifikante Stellen
`long double`	16 Bytes (schwankt)	mehr als double

Die long-Zeile ist die, die Leute erwischt: Unter Linux und macOS sind es 8 Bytes und unter 64-Bit-Windows 4 Bytes. Code, der annimmt, long könne einen 64-Bit-Wert fassen, ist nicht portabel. Nimm long long oder die Typen exakter Breite aus stdint.h (int32_t, uint64_t), wenn die Größe zur Anforderung gehört.

sizeof: den Compiler fragen

Rate nie eine Größe - miss sie:

#include <stdio.h>

int main(void) {
    printf("char:        %zu Byte(s)\n", sizeof(char));
    printf("short:       %zu Bytes\n", sizeof(short));
    printf("int:         %zu Bytes\n", sizeof(int));
    printf("long:        %zu Bytes\n", sizeof(long));
    printf("long long:   %zu Bytes\n", sizeof(long long));
    printf("float:       %zu Bytes\n", sizeof(float));
    printf("double:      %zu Bytes\n", sizeof(double));
    printf("ein Zeiger:  %zu Bytes\n", sizeof(int *));
    return 0;
}

sizeof ist ein Operator, keine Funktion, und es wird zur Übersetzungszeit ausgewertet. Es liefert einen Wert vom Typ size_t, der sich mit %zu ausgeben lässt.

sizeof(char) ist garantiert genau 1 - das ist die Definition eines Bytes in C. Alles andere wird daran gemessen.

limits.h und float.h

Die genauen Bereiche deines Compilers stehen als benannte Konstanten bereit:

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main(void) {
    printf("INT_MIN      = %d\n", INT_MIN);
    printf("INT_MAX      = %d\n", INT_MAX);
    printf("UINT_MAX     = %u\n", UINT_MAX);
    printf("LONG_MAX     = %ld\n", LONG_MAX);
    printf("CHAR_BIT     = %d Bits pro Byte\n", CHAR_BIT);
    printf("FLT_DIG      = %d Dezimalstellen\n", FLT_DIG);
    printf("DBL_DIG      = %d Dezimalstellen\n", DBL_DIG);
    return 0;
}

Das sind die Werte, gegen die du vergleichst, wenn du wissen musst, ob eine Operation überläuft. if (a > INT_MAX - b) zu prüfen, bevor du a + b berechnest, ist der Weg, einen Überlauf zu erkennen, bevor er passiert - was zählt, denn einen vorzeichenbehafteten Überlauf kannst du hinterher nicht erkennen.

Ganzzahlüberlauf

Was passiert, wenn ein Wert den Bereich seines Typs überschreitet, hängt vollständig vom Vorzeichen ab.

Ein vorzeichenloser Überlauf ist definiert: Der Wert schlägt modulo 2^N um.

#include <stdio.h>
#include <limits.h>

int main(void) {
    unsigned int u = UINT_MAX;
    printf("UINT_MAX     = %u\n", u);
    printf("UINT_MAX + 1 = %u\n", u + 1);   /* garantiert 0 */

    unsigned int zero = 0;
    printf("0 - 1        = %u\n", zero - 1); /* schlaegt auf UINT_MAX um */
    return 0;
}

Der zweite Fall ist eine echte Fehlerquelle. Eine Schleife wie for (unsigned i = n - 1; i >= 0; i--) endet nie, denn ein vorzeichenloser Wert ist immer >= 0.

Ein vorzeichenbehafteter Überlauf ist undefiniertes Verhalten. Nicht „schlägt um" - undefiniert. Der Compiler darf annehmen, dass er nie passiert, und darauf aufbauend optimieren, was bedeutet, dass eine nachträglich geschriebene Überlaufprüfung gelöscht werden darf:

int sum = a + b;
if (sum < a) { /* der Compiler darf das vollständig entfernen */ }

Prüfe vorher, mit den Grenzwerten:

if (b > 0 && a > INT_MAX - b) {
    /* a + b würde überlaufen - behandle es */
}

Gleitkommagenauigkeit

float und double speichern Zahlen binär, und die meisten Dezimalbrüche haben keine exakte binäre Form - so wie 1/3 keine exakte dezimale Form hat.

#include <stdio.h>

int main(void) {
    double a = 0.1;
    double b = 0.2;
    double sum = a + b;

    printf("0.1 + 0.2 = %.20f\n", sum);
    printf("Ist es 0.3? %s\n", (sum == 0.3) ? "ja" : "nein");

    /* Der richtige Weg: innerhalb einer Toleranz vergleichen. */
    double diff = sum - 0.3;
    if (diff < 0) diff = -diff;
    printf("Nah genug? %s\n", (diff < 1e-9) ? "ja" : "nein");
    return 0;
}

Daraus folgt die Regel: Vergleiche Gleitkommawerte nie mit ==. Vergleiche stattdessen die absolute Differenz gegen eine kleine Toleranz.

Und benutze für Geld nie Gleitkommazahlen. Speichere Cent als Ganzzahl; ein long long in Cent ist exakt, wo ein double in Euro es nicht ist.

Einen Typ wählen

Eine kurze Entscheidungsliste, die den meisten Code abdeckt:

Ganze Zahlen: int, sofern du keinen Grund hast. Es ist der Typ, den die CPU am effizientesten behandelt, und der, um den herum alle Rechenregeln gebaut sind.
Alles über 2 Milliarden: long long oder int64_t aus stdint.h.
Größen, Längen, Array-Indizes aus sizeof oder strlen: size_t. Es ist vorzeichenlos und garantiert groß genug für jedes Objekt.
Dezimalzahlen: double. Nimm float nur, um in großen Arrays Speicher zu halbieren oder auf Embedded-Hardware ohne Einheit für doppelte Genauigkeit.
Einzelne Zeichen und rohe Bytes: char für Text, unsigned char für Binärdaten.
Wahr/falsch: bool aus stdbool.h - siehe Booleans in C.
Exakte Bitbreiten (Dateiformate, Netzprotokolle, Hardwareregister): stdint.h - uint8_t, int16_t, uint32_t und so weiter.

#include <stdio.h>
#include <stdint.h>

int main(void) {
    uint8_t  flags = 0xFF;          /* genau 8 Bit, vorzeichenlos */
    int32_t  offset = -100000;      /* genau 32 Bit, vorzeichenbehaftet */
    uint64_t file_size = 5000000000ULL;

    printf("flags:     %u\n", flags);
    printf("offset:    %d\n", offset);
    printf("file_size: %llu Bytes\n", (unsigned long long)file_size);
    return 0;
}

Typen mischen

Wenn du zwei verschiedene Typen in einem Ausdruck kombinierst, wandelt C sie hinter deinem Rücken um, bevor es rechnet. Das ist meist hilfreich und gelegentlich verheerend:

#include <stdio.h>

int main(void) {
    int a = 7, b = 2;

    printf("7 / 2  als ints  = %d\n", a / b);        /* 3, nicht 3.5 */
    printf("7 / 2  mit 2.0   = %f\n", a / 2.0);      /* 3.5 */

    int  small = -1;
    unsigned int big = 1;
    printf("-1 < 1u ? %s\n", (small < big) ? "ja" : "nein");  /* ueberraschend */
    return 0;
}

Das Erste ist Ganzzahldivision: Beide Operanden sind int, das Ergebnis ist also ein int und der Bruchteil fällt weg. Das Dritte ist schlimmer - einen vorzeichenbehafteten Wert mit einem vorzeichenlosen zu vergleichen wandelt den vorzeichenbehafteten in vorzeichenlos um und macht aus -1 eine riesige positive Zahl.

Diese Umwandlungsregeln und wie man sie mit expliziten Casts in den Griff bekommt, sind das Thema von Typumwandlung in C.

Häufig gestellte Fragen

Was sind die grundlegenden Datentypen in C?

Vier Basistypen: char für einzelne Zeichen und Bytes, int für ganze Zahlen, float und double für Dezimalzahlen. Modifikatoren ändern Größe und Vorzeichen - short, long, long long, signed und unsigned - und ergeben den vollständigen Satz.

Wie viele Bytes hat ein int in C?

Auf modernen Desktop- und Serversystemen fast immer 4 Bytes (32 Bit), was einen Bereich von etwa -2,1 Milliarden bis 2,1 Milliarden ergibt. Der Standard garantiert nur mindestens 2 Bytes, und 16-Bit-Mikrocontroller benutzen tatsächlich 2. Nimm sizeof(int), wenn du es sicher wissen musst.

Was ist der Unterschied zwischen float und double in C?

float hat 4 Bytes mit etwa 7 signifikanten Dezimalstellen; double hat 8 Bytes mit etwa 15. Double ist die Voreinstellung für Gleitkommaliterale und Mathematikfunktionen, und solange du nicht Millionen von Werten speicherst oder auf einen Embedded-Chip zielst, ist double die richtige Wahl.

Was passiert, wenn ein int in C überläuft?

Bei einem vorzeichenbehafteten int ist ein Überlauf undefiniertes Verhalten - der Compiler darf umschlagen, sättigen oder die Prüfung ganz wegoptimieren. Bei einem vorzeichenlosen int ist er vollständig definiert: Der Wert schlägt modulo 2^N um, UINT_MAX + 1 ist also 0. Verlass dich nie auf einen vorzeichenbehafteten Überlauf.

Verwandte Konzepte