int

Der Typ int speichert einen ganzzahligen Wert, welcher heutzutags mit 4 Bytes codiert wird. Damit kann ein Wertebereich von -2'147'483'648 bis +2'147'483'647 abgedeckt werden. Für den vorzeichenlosen Typ können Werte von 0 bis +4'294'967'295 abgedeckt werden.

Siehe auch char, short, long long, signed, unsigned

Details

Ein int wird auf den heute gängigen Systemen als eine 4-Byte-Ganzzahl, sprich mit 32 Bits codiert. Auf dieser Seite wird diese Grösse als fix angegeben, obschon in früheren Zeiten ein int oftmals nur mit 2 Byte codiert wurde. In diesem Falle war der Typ long als die 4-Byte-Ganzzahl verwendet worden. Heutzutags sind int und long üblicherweise beide mit 4 Bytes codiert. Der Typ long wird heutzutags tendentiell nur noch aus Gründen der Kompatibilität zu älterem Code verwendet.

Ein int-Typ kann als Erweiterung entweder mit signed oder unsigned deklariert werden. Je nachdem speichert ein int entweder sowohl negative als auch positive Werte, oder aber explizit nur positive. Wird die Erweiterung weggelassen, wird vom Compiler standardmässig signed angenommen. Ob die Erweiterung vor oder nach dem Typ steht, spielt keine Rolle.

int           a;
signed int    b;
int signed    c;
unsigned int  d;
int unsigned  e;

Eine Besonderheit des int-Typs ist, dass er der Standard-Typ für Deklarationen ohne Typangaben ist. Dies kommt beispielsweise bei der (nicht empfehlenswerten) Benutzung der old style Parameters zum Zug. Aufgrund der Standard-Annahme ist es jedoch auch möglich, einen int nur durch Angabe von signed oder unsigned zu deklarieren:

signed        f;
unsigned      g;

Positive Werte werden als Integer-Representation gespeichert. Der Wert 0x00000000 entspricht der Zahl 0 (Null), der Wert 0x00000001 der Zahl 1 (Eins) und so weiter und so fort. Bei einem unsigned int entspricht 0xffffffff dem maximal möglichen Wert. Die negativen Werte eines signed int werden mittels des Zweierkomplements codiert. Der Wert 0x80000000 entspricht dann der Zahl -2147483648 und der Wert 0xffffffff der Zahl -1.

Die maximal und minimal möglichen Werte eines int sind in der limits-Bibliothek definiert:





-2147483648
2147483647
4294967295

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

int main(){
  printf("%d\n", INT_MIN);
  printf("%d\n", INT_MAX);
  printf("%u\n", UINT_MAX);
  return 0;
}

Der minimale Wert eines unsigned int ist 0. Bei einem Under- oder Overflow springt der Wert bei einem unsigned int von 0 auf +4294967295 und bei einem signed int von -2147483648 auf +2147483647 beziehungsweise umgekehrt. Dies wird als Wrap-Around bezeichnet.

Arithmetische Umwandlung

Bei Zuweisungen, Initialisierungen oder Casts zu einem int-Typ werden durch den Compiler gegebenfalls arithmetische Umwandlungen durchgeführt. Im folgenden sind die Umwandlungsregeln für den int-Typ beschrieben. Bei unsicheren Umwandlungen gibt ein Compiler üblicherweise eine Warnung aus, welche jedoch bei Bedarf mittels eines expliziten Casts unterdrückt werden kann.

Bei der Umwandlung eines Fliesskomma-Typs in einen int werden die Nachkommastellen schlicht abgeschnitten (Rundung hin zu Null).

123
-123

  printf("%d\n", (signed   int) 123.456);
  printf("%d\n", (signed   int)-123.456);

Hat die umzuwandelnde Fliesskommazahl keinen Platz in einem int, so wird der maximal, beziehungsweise der minimal mögliche Wert angenommen.

2147483647
-2147483648
4294967295
0

  printf("%d\n", (signed   int) 1e20);
  printf("%d\n", (signed   int)-1e20);
  printf("%u\n", (unsigned int) 1e20);
  printf("%u\n", (unsigned int)-1e20);

Bei der Umwandlung eines Integer-Typs in einen int bleiben in den wichtigsten Fällen der Wert sowie das Vorzeichen exakt erhalten:

  unsigned  short      s1 =  123;
  signed    short      s2 = -123;
  unsigned  long long  L1 =  123;
  signed    long long  L2 = -123;
  printf("%u\n", (unsigned int) s1);
  printf("%d\n", (signed   int) s2);
  printf("%u\n", (unsigned int) L1);
  printf("%d\n", (signed   int) L2);

Die Regeln für die Umwandlung eines Integer-Wertes in einen int lauten: Die niederwertigsten 32 Bits des zuzuweisenden Wertes werden bitgenau kopiert. Falls der zuzuweisende Wert weniger wie 32 Bitstellen aufweist (insbesondere bei char und short), werden die verfügbaren Bitstellen an die niederwertigsten Bitstellen des int kopiert. Die nicht-definierten höherwertigen Bit-Stellen werden folgendermassen aufgefüllt: Wenn der Typ des zuzuweisenden Wertes vorzeichenlos ist, wird an alle nicht-definierten Bit-Stellen das Bit 0 kopiert. Wenn der Typ des zuzuweisenden Wertes vorzeichenbehaftet ist, wird das höchstwertige Bit der verfügbaren Bitstellen an sämtliche höherwertige Bit-Stellen kopiert.

Durch diese Regeln können folgende Fälle zu falschen Werten führen: Eine vorzeichenbehaftete Zahl kann nicht korrekt in einen vorzeichenlosen Typ umgewandelt werden. Eine zu grosse vorzeichenlose Zahl kann bei der Umwandlung in einen vorzeichenbehafteten Typ zu negativen Werten führen. Bei der Umwandlung von (vorzeichenbehafteten oder vorzeichenlosen) Zahlen höherer Mächtigkeit (insbesondere bei long long) kann durch die Kürzung auf 32 Bit der Wert verfälscht werden oder gar zu falschem Vorzeichen führen.

  printf("%u\n", (unsigned int) -123);
  printf("%d\n", (signed   int)  4000000000);
  printf("%d\n", (signed   int)  6000000000LL);
  printf("%d\n", (signed   int)  8000000000LL);

Ein Javascript-Programm zur Veranschaulichung der Effekte beim Abschneiden von Bits ist beim Zahlensystem-Umrechner zu finden.