Quelltext der Seite Integer (Datentyp)

Mit '''Integer''' ([{{IPA|ˈɪnteɡɐ}}], {{enS}} [{{IPA|ˈɪntɪdʒə}}], für [[ganze Zahl]]; von {{laS|numerus integer}}) wird in der [[Informatik]] ein [[Datentyp]] bezeichnet, der ganzzahlige Werte speichert. Als grundlegender arithmetischer Datentyp werden Ganzzahlen von der Hardware fast aller Rechenanlagen nativ unterstützt und sind in nahezu jeder [[Programmiersprache]] verfügbar – im Gegensatz zu [[Festkommazahl|Festkomma-]] und [[Gleitkommazahl]]en, die gegebenenfalls softwareseitig emuliert werden müssen.
Meist werden mehrere ganzzahlige Datentypen bereitgestellt, die sich in der Darstellung, der Länge (sogenannte [[Datenwort|''Wortbreite'']]) oder dem Vorhandensein eines [[Vorzeichen (Zahl)|Vorzeichens]] unterscheiden, und somit unterschiedliche [[Wertebereich]]e abdecken. Die Hardwareunterstützung bestimmter ''Wortbreiten'' beschränkt sich in der Regel nicht auf die jeweilige [[Befehlssatzarchitektur#Bitbreite|Bitbreite]] eines Systems.
Der 2001 veröffentlichte Internationale Standard ''ISO/IEC 10967 „Language Independent Arithmetic“''<ref>''[[:en:ISO/IEC 10967|ISO/IEC 10967]]'' in der englischsprachigen Wikipedia</ref> beschreibt die grundlegenden Eigenschaften und Rechenoperationen für ganze Zahlen und Gleitkommazahlen, unabhängig von der eingesetzten Programmiersprache und dem eingesetzten Computer.

== Darstellungen ==

=== Vorzeichenlose Zahlen ===
{| class="wikitable float-right" style="text-align:right"
|+ Darstellung von vorzeichenlosen Binärzahlen
|-
! Zahl
! Darstellung
! Bias
! Bit&#8239;7
! Bit&#8239;6
! Bit&#8239;5
! Bit&#8239;4
! Bit&#8239;3
! Bit&#8239;2
! Bit&#8239;1
! Bit&#8239;0
! Summe
|-
| colspan="2" align="right" |  || 0 || 128{{0|·'''1'''}} || 64{{0|·'''1'''}} || 32{{0|·'''1'''}} || 16{{0|·'''1'''}} || 8{{0|·'''1'''}} || 4{{0|·'''1'''}} || 2{{0|·'''1'''}} || 1{{0|·'''1'''}} || 
|-
| 0   || <code>00000000</code> || 0  || 0   || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|-
| 7   || <code>00000'''111'''</code> || 0  || 0   || 0 || 0 || 0 || 0 || 4·'''1''' || 2·'''1''' || 1·'''1''' || 7
|-
| 100 || <code>0'''11'''00'''1'''00</code> || 0  || 0   || 64·'''1''' || 32·'''1''' || 0 || 0 || 4·'''1''' || 0 || 0 || 100
|-
| 255 || <code>'''11111111'''</code> || 0  || 128·'''1''' || 64·'''1''' || 32·'''1''' || 16·'''1''' || 8·'''1''' || 4·'''1''' || 2·'''1''' || 1·'''1''' || 255
|}

Ganzzahlen werden in einem binären [[Stellenwertsystem]] gespeichert und verarbeitet, das bedeutet, dass jede Zahl aus einer festen Anzahl Stellen besteht, und jede dieser Stellen entspricht einem bestimmten Wert. Der Wert einer Zahl ergibt sich in einem Stellensystem dadurch, dass man jede Ziffer der Zahl mit dem jeweiligen Stellenwert multipliziert und diese Teilergebnisse aufsummiert. Im Binärsystem gibt es nur die Ziffern 0 und 1, daher reicht es, die Stellenwerte der Stellen zu addieren, an denen die Ziffer 1 ist.

Zum Beispiel sind bei der Zahl 100 die Bits 6, 5 und 2 gesetzt. Die dazugehörigen Stellenwerte sind 64, 32 und 4, und deren Summe ist 100.

Die Stellenwerte der einzelnen Bits entsprechen genau den [[Zweierpotenz]]en. Durch diese Wahl gibt es zu jeder Zahl genau eine Darstellungsmöglichkeit, und dadurch wiederum wird der Speicherplatz optimal genutzt.
{{Absatz}}

=== Vorzeichenbehaftete Zahlen im Zweierkomplement ===
{| class="wikitable float-right" style="text-align:right"
|+ Darstellung von Zweierkomplement-Binärzahlen
|-
! Zahl
! Darstellung
! Bias
! Bit&#8239;7
! Bit&#8239;6
! Bit&#8239;5
! Bit&#8239;4
! Bit&#8239;3
! Bit&#8239;2
! Bit&#8239;1
! Bit&#8239;0
! Summe
|-
| colspan="2" |  || 0 || −128{{0|·'''1'''}} || 64{{0|·'''1'''}} || 32{{0|·'''1'''}} || 16{{0|·'''1'''}} || 8{{0|·'''1'''}} || 4{{0|·'''1'''}} || 2{{0|·'''1'''}} || 1{{0|·'''1'''}} || ←&#8239;Wert
|-
| −128 || <code>'''1'''0000000</code> || 0  || −128·'''1''' || 0 || 0 || 0 || 0 || 0 || 0 || 0 || −128
|-
| −100 || <code>'''1'''00'''111'''00</code> || 0  || −128·'''1''' || 0 || 0 || 16·'''1''' || 8·'''1''' || 4·'''1''' || 0 || 0 || −100
|-
|   −7 || <code>'''11111'''00'''1'''</code> || 0  || −128·'''1''' || 64·'''1''' || 32·'''1''' || 16·'''1''' || 8·'''1''' || 0 || 0 || 1·'''1''' || −7
|-
|    0 || <code>00000000</code> || 0  || 0   || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|-
|    7 || <code>00000'''111'''</code> || 0  || 0   || 0 || 0 || 0 || 0 || 4·'''1''' || 2·'''1''' || 1·'''1''' || 7
|-
| 100  || <code>0'''11'''00'''1'''00</code> || 0  || 0   || 64·'''1''' || 32·'''1''' || 0 || 0 || 4·'''1''' || 0 || 0 || 100
|-
| 127  || <code>0'''1111111'''</code> || 0  || 0 || 64·'''1''' || 32·'''1''' || 16·'''1''' || 8·'''1''' || 4·'''1''' || 2·'''1''' || 1·'''1''' || 127
|}

Um auch negative ganze Zahlen darzustellen, wird das [[Zweierkomplement]] verwendet. Dabei wird das Vorzeichen der höchstwertigen Stelle umgekehrt.

Zum Beispiel hat bei einer 8-Bit-Zahl die höchstwertige Stelle nicht mehr den Stellenwert 128, sondern −128. Dadurch geht der Zahlenbereich nicht mehr von 0 bis 255, sondern von −128 bis 127.

Beim Rechnen im Zweierkomplement funktionieren Addition und Subtraktion genauso wie bei vorzeichenlosen Zahlen. Das Vergleichen von Zahlen sowie die Multiplikation und Division müssen jedoch angepasst werden. Die kleinste negative Zahl hat kein entsprechendes Gegenstück bei den positiven Zahlen, daher kann eine Multiplikation mit −1 dazu führen, dass sich das Vorzeichen nicht ändert.
{{Absatz}}

=== Vorzeichenbehaftete Zahlen im Einerkomplement ===
{| class="wikitable float-right" style="text-align:right"
|+ Darstellung von Einerkomplement-Binärzahlen
|-
! Zahl
! Darstellung
! Bias
! Bit&#8239;7
! Bit&#8239;6
! Bit&#8239;5
! Bit&#8239;4
! Bit&#8239;3
! Bit&#8239;2
! Bit&#8239;1
! Bit&#8239;0
! Summe
|-
| colspan="2" |  || 0 || −127{{0|·'''1'''}} || 64{{0|·'''1'''}} || 32{{0|·'''1'''}} || 16{{0|·'''1'''}} || 8{{0|·'''1'''}} || 4{{0|·'''1'''}} || 2{{0|·'''1'''}} || 1{{0|·'''1'''}} || ←&#8239;Wert
|-
| −127 || <code>'''1'''0000000</code> || 0  || −127·'''1''' || 0 || 0 || 0 || 0 || 0 || 0 || 0 || −127
|-
| −100 || <code>'''1'''00'''11'''0'''11'''</code> || 0  || −127·'''1''' || 0 || 0 || 16·'''1''' || 8·'''1''' || 0 || 2·'''1''' || 1·'''1''' || −100
|-
|   −7 || <code>'''11111'''000</code> || 0  || −127·'''1''' || 64·'''1''' || 32·'''1''' || 16·'''1''' || 8·'''1''' || 0 || 0 || 0 || −7
|-
|   −0 || <code>'''11111111'''</code> || 0  || −127·'''1''' || 64·'''1''' || 32·'''1''' || 16·'''1''' || 8·'''1''' || 4·'''1''' || 2·'''1''' || 1·'''1''' || 0
|-
|    0 || <code>00000000</code> || 0  || 0   || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|-
|    7 || <code>00000'''111'''</code> || 0  || 0   || 0 || 0 || 0 || 0 || 4·'''1''' || 2·'''1''' || 1·'''1''' || 7
|-
| 100  || <code>0'''11'''00'''1'''00</code> || 0  || 0   || 64·'''1''' || 32·'''1''' || 0 || 0 || 4·'''1''' || 0 || 0 || 100
|-
| 127  || <code>0'''1111111'''</code> || 0  || 0 || 64·'''1''' || 32·'''1''' || 16·'''1''' || 8·'''1''' || 4·'''1''' || 2·'''1''' || 1·'''1''' || 127
|}
Beim [[Einerkomplement]] wird das Vorzeichen der höchstwertigen Stelle umgekehrt und 1 abgezogen. Dadurch gibt es 2 unterschiedliche Darstellungen für die Zahl 0, die +0 und −0 genannt werden.

Zum Beispiel hat bei einer 8-Bit-Zahl die höchstwertige Stelle nicht mehr den Stellenwert 128, sondern −127. Dadurch geht der Zahlenbereich nicht mehr von 0 bis 255, sondern von −127 bis 127.

Elektronische Schaltungen zum Rechnen im Einerkomplement sind aufwendiger, daher ist diese Darstellung nicht weit verbreitet.
{{Absatz}}

=== Vorzeichenbehaftete Zahlen als Vorzeichen und Betrag ===
{| class="wikitable float-right" style="text-align:right"
|+ Darstellung als Vorzeichen und Betrag
|-
! Zahl
! Darstellung
! Bias
! Bit&#8239;7
! Bit&#8239;6
! Bit&#8239;5
! Bit&#8239;4
! Bit&#8239;3
! Bit&#8239;2
! Bit&#8239;1
! Bit&#8239;0
! Faktor·Summe
|-
| colspan="2" |  || 0 || Vorzeichen || 64{{0|·'''1'''}} || 32{{0|·'''1'''}} || 16{{0|·'''1'''}} || 8{{0|·'''1'''}} || 4{{0|·'''1'''}} || 2{{0|·'''1'''}} || 1{{0|·'''1'''}} || ←&#8239;Wert
|-
| −127 || <code>'''11111111'''</code> || 0 || '''1''' ≙ Faktor −1 || 64·'''1''' || 32·'''1''' || 16·'''1''' || 8·'''1''' || 4·'''1''' || 2·'''1''' || 1·'''1''' || −1·127 = −127
|-
| −100 || <code>'''111'''00'''1'''00</code> || 0  || '''1''' ≙ Faktor −1 || 64·'''1''' || 32·'''1''' || 0 || 0 || 4·'''1''' || 0 || 0 || −1·100 = −100
|-
|   −7 || <code>'''1'''0000'''111'''</code> || 0  || '''1''' ≙ Faktor −1 || 0 || 0 || 0 || 0 ||  4·'''1''' || 2·'''1''' || 1·'''1''' || −1·7 = {{0|00}}−7
|-
|   −0 || <code>'''1'''0000000</code> || 0  || '''1''' ≙ Faktor −1 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || −1·0 = {{0|00−}}0
|-
|    0 || <code>00000000</code> || 0  || 0 ≙ Faktor +1 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || +1·0 = {{0|00−}}0
|-
|    7 || <code>00000'''111'''</code> || 0  || 0 ≙ Faktor +1 || 0 || 0 || 0 || 0 || 4·'''1''' || 2·'''1''' || 1·'''1''' || +1·7 = {{0|00−}}7
|-
| 100  || <code>0'''11'''00'''1'''00</code> || 0  || 0 ≙ Faktor +1 || 64·'''1''' || 32·'''1''' || 0 || 0 || 4·'''1''' || 0 || 0 || +1·100 = {{0|−}}100
|-
| 127  || <code>0'''1111111'''</code> || 0  || 0 ≙ Faktor +1 || 64·'''1''' || 32·'''1''' || 16·'''1''' || 8·'''1''' || 4·'''1''' || 2·'''1''' || 1·'''1''' || +1·127 = {{0|−}}127
|}

In der Betrags-Vorzeichendarstellung werden das Vorzeichen und der Betrag getrennt gespeichert und verarbeitet
(engl. Bezeichnung: ''signed-magnitude representation'').

Die Betrags-Vorzeichendarstellung ist zum Multiplizieren und Dividieren praktisch, da das Vorzeichen separat behandelt werden kann. Vergleiche, Additionen und Subtraktionen sind jedoch im Zweierkomplement einfacher umzusetzen.
{{Absatz}}

=== Vorzeichenbehaftete Zahlen als vorzeichenlose Zahlen mit Bias ===
{| class="wikitable float-right" style="text-align:right"
|+ Vorzeichenbehaftete Zahlen als vorzeichenlose Zahlen mit Bias
|-
! Zahl
! Darstellung
! Bias
! Bit&#8239;7
! Bit&#8239;6
! Bit&#8239;5
! Bit&#8239;4
! Bit&#8239;3
! Bit&#8239;2
! Bit&#8239;1
! Bit&#8239;0
! Summe
|-
| colspan="2" |  || −128 || 128{{0|·'''1'''}} || 64{{0|·'''1'''}} || 32{{0|·'''1'''}} || 16{{0|·'''1'''}} || 8{{0|·'''1'''}} || 4{{0|·'''1'''}} || 2{{0|·'''1'''}} || 1{{0|·'''1'''}} || ←&#8239;Wert
|-
| −128 || <code>00000000</code>             || −128 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || −128
|-
| −100 || <code>000'''111'''00</code>       || −128 || 0 || 0 || 0 || 16·'''1''' || 8·'''1''' || 4·'''1''' || 0 || 0 || −100
|-
|   −7 || <code>0'''1111'''00'''1'''</code> || −128 || 0 || 64·'''1''' || 32·'''1''' || 16·'''1''' || 8·'''1''' || 0 || 0 || 1·'''1''' || −7
|-
|    0 || <code>'''1'''0000000</code>       || −128 || 128·'''1''' || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|-
|    7 || <code>'''1'''0000'''111'''</code> || −128 || 128·'''1''' || 0 || 0 || 0 || 0 || 4·'''1''' || 2·'''1''' || 1·'''1''' || 7
|-
| 100  || <code>'''111'''00'''1'''00</code> || −128 || 128·'''1''' || 64·'''1''' || 32·'''1''' || 0 || 0 || 4·'''1''' || 0 || 0 || 100
|-
| 127  || <code>'''11111111'''</code>       || −128 || 128·'''1''' || 64·'''1''' || 32·'''1''' || 16·'''1''' || 8·'''1''' || 4·'''1''' || 2·'''1''' || 1·'''1''' || 127
|}
Die Darstellung ist u.&#8239;a. üblich bei vielen [[Analog-Digital-Umsetzer|A/D]]- und [[Digital-Analog-Umsetzer|D/A-Wandlern]].
Etliche lassen sich zwischen Zweierkomplement und vorzeichenlosen Zahlen mit Bias umschalten (was nur eine Invertierung des [[Bitwertigkeit|MSB]] erfordert).

Diese Darstellung wird auch für den Exponenten in [[IEEE 754#Zahlenformate und andere Festlegungen des IEEE-754-Standards|IEEE-Gleitkommadarstellungen]] benutzt.

Um zwei vorzeichenbehaftete Werte in dieser Darstellung zu vergleichen, werden ihre Darstellungen vorzeichenlos verglichen, die Ordnungsrelation der kodierten Werte bleibt dabei erhalten. Die bitweise Darstellung der IEEE-Gleitkommazahlen nutzt diese Eigenschaft aus, um einen Vergleich zwischen Gleitkommazahlen auf einen einfacheren Vergleich von Ganzkommazahlen zurückzuführen, statt die beiden zu vergleichenden Zahlen in ihre Komponenten (Vorzeichnen, Exponent, Mantisse) zu zerlegen.

==== Mit abweichenden Bias ====
Meist wird für eine n-Bit-Zahl ein Bias von 2<sup>n−1</sup> verwendet. Damit sind Werte zwischen −2<sup>n−1</sup> und 2<sup>n−1</sup>−1 kodierbar.

Es sind allerdings auch andere Bias-Werte möglich, damit sind asymmetrische Signale (z.&#8239;B. Lichtintensitäten) besser kodierbar.

Beispiele:<br>12-Bit-Kamera-Rohdaten mit Bias −256 (Wertebereich −256…3839) oder 14-Bit-Kamera-Rohdaten mit Bias −1024 (Wertebereich −1024…15359).
{{Absatz}}

=== BCD-Darstellungen ===
Etliche [[Prozessor|CPUs]] der 1970er/80er Jahre sowie (auch heute noch) die meisten Taschenrechner arbeiten intern im [[BCD-Code|BCD-Format]].
Die betroffenen CPUs der 1970er/80er Jahre (z.&#8239;B. der CPU Sharp SC61860) unterstützten nativ Addition und Subtraktion von ''BCD-Langzahlen'' und Verschieben um 4 Bit sowie um N×8 Bit von BCD-Langzahlen. Damit war eine (für die damalige Zeit) '''effiziente BCD-Arithmetik''' programmierbar. CPUs wie der [[MOS 6502]] unterstützen das Rechnen mit BCD- wie mit Binärzahlen gleichermaßen.

Das Abspeichern und Verarbeiten von BCD-Zahlen geriet gegenüber Binärzahlen mit der Einführung von Multiplikation und Division in Befehlssätzen Ende der 1970er Jahre ins Hintertreffen. Während CPUs neben 8-Bit Operationen auch 16-, 32- und 64-Bit-Operationen sowie Multiplikation und Division einführten, wurden nativ nur 8-Bit-Addition/Subtraktion partiell unterstützt, was dazu führte, dass BCD-Arithmetik 3 bis 4 Größenordnungen langsamer als Binärarithmetik ist. Im [[X64|64-Bit-8086]]-Befehlssatz wurde auch diese Unterstützung entfernt.

Einzige Ausnahme ist das Konvertieren von 18-stelligen-BCD-Zahlen in Gleitkommazahlen doppelter Genauigkeit, ''double'' (<code>FBLD</code>, ''Load Binary Coded Decimal''), sowie umgekehrt von ''double'' in 18-stellige-BCD-Zahlen (<code>FBSTP</code>, ''Store BCD Integer and Pop''), das weiterhin unterstützt und zur Ein-/Ausgabe von Dezimalzahlen genutzt wird.

Negative Zahlen:<br>
Negative Zahlen können wie bei Binärdarstellung sowohl als Betrag und Vorzeichen oder als Zehnerkomplement (−6 = FFFA<sub>(16)</sub>) gespeichert werden.

=== Carry-Save-Darstellungen ===
''Carry-Save''-Darstellungen werden für viele Zwischenberechnungen in CPUs und [[Field Programmable Gate Array|FPGAs]] benutzt, z.&#8239;B. für Hardware-Multiplikationen (siehe [[Dadda-Tree-Multiplizierer]], [[Wallace-Tree-Multiplizierer]]) oder für Adressberechnungen komplexer Adressierungsmodi (<code>8*RBX + RCX + 78h</code>).

Zwischenergebnisse werden dazu nicht mehr als ein Ganzzahl-Vektor, sondern durch zwei Ganzzahl-Vektoren repräsentiert, den Überläufen der letzten Addition und den Summen der letzten Addition. Es ist keine Übertrags-Propagation mehr notwendig. Allerdings ist '''eine''' finale Addition für die Umwandlung in „normale“ Ganzzahlen notwendig.

=== Weitere Darstellungen ===
Weitere Darstellungen sind in [[Donald E. Knuth]]s ''[[The Art of Computer Programming]]''<ref>[[Donald E. Knuth]]: ''[[The Art of Computer Programming]]. 2. Seminumerical Algorithms''. 3. Auflage. Addison-Wesley, 1997, ISBN 0-201-89684-2. S. 195, 4.1 Positional number systems; S. 284, 4.3.2 Modular arithmetic</ref> als geschichtliche Abhandlung und als weitere Möglichkeiten beschrieben:
* Zahlensysteme zur Basis 3 (''ternary''), Basis 4 (''quaternary''), Basis 5 (''quinary'')
* Zahlensysteme zur Basis 20 ([[Maya-Zivilisation|Maya]]) und 60 ([[Babylonier]], [[Antikes Griechenland|Griechen]])
* Zahlensysteme mit negativen ganzzahligen Basen
* Zahlensysteme für komplexe Zahlen mit komplexwertigen Basen wie 2&#8239;i, '''√'''<span style="text-decoration-line: overline">&#8239;2&#8239;</span>i oder i−1
* Zahlensysteme mit unterschiedlichen Basen
* Zahlensysteme mit irrationalen Basen

== Auftreten ==
Ganzzahlformate finden Verwendung in
* A/D-Wandlern (8 bis 24 Bit)
* D/A-Wandlern (8 bis 24 Bit)
* FPGAs (18, 25, 27 Bit (DSP-Slice Hardwaremakros) oder beliebig)
* ASICs (beliebig)
* Zählern (bis zu 60 Bit)
* Signalprozessoren (24 bis 56 Bit)
* Grafikprozessoren (4 bis 32 Bit)
* „normalen“ CPUs (8 bis 64 Bit)
Die nativ unterstützten Bitbreiten liegen dabei zwischen 4 und 64 Bit.

== Häufige Speicherformen ==
Historisch wurden auch andere Werte (12, 48 … Bit) verwendet.

Namen von Integer-Datentypen mit festgelegter Breite setzen sich zusammen aus einem Vorzeichenindikator und der Breite in Bits. So bezeichnet zum Beispiel <code>Int32</code> einen vorzeichenbehafteten 32-Bit breiten Datentyp, während <code>UInt128</code> einen vorzeichenlosen ([[amerikanisches Englisch|englisch]] ''{{lang|en-US|unsigned}}'') 128-Bit breiten Datentyp bezeichnet. Je nach Programmiersprache variieren die tatsächlichen Namen.

Zusätzlich gibt es historisch gewachsene Namen für die Datentypen, die keinem festen Schema folgen und je nach Programmiersprache und Prozessor variieren, zum Beispiel:
* [[Byte]] oder ''char'' für 8 Bit, je nach Programmiersprache mit oder ohne Vorzeichen
* Word für 16, 18, 32, 36 Bit – je nach Rechnerarchitektur, davon abgeleitet ''DWord'' für „''double word''“ und ''QWord'' für „''quad word''“
* Int, Integer, SmallInt, short int, LongInt, long long int, je nach Rechnerarchitektur
* Rune, für die Darstellung von Zeichen, siehe [[Unicode]]

Bei der Ablage im Speicher muss festgelegt sein, in welcher Reihenfolge die Bits der Zahlendarstellung auf die einzelnen Bytes verteilt werden, siehe [[Byte-Reihenfolge|Bytereihenfolge]].

{| class="wikitable"
|- class="hintergrundfarbe6"
| rowspan=2 style="text-align:center" | '''Größe'''<br />(Bit)
! rowspan="2"| Vorzeichen
! colspan="2"| Grenzen des Wertebereichs ([[Zweierkomplement]])
| rowspan=2 style="text-align:center" | '''Dezimalstellen'''<br />(ohne Vorzeichen)
|- class="hintergrundfarbe6"
| align="right" | '''min'''
| align="right" | '''max'''
|-
|rowspan="2"| 8
| style="text-align:center" | signed
| align="right"  | −128
| align="right"  | 127
| align="right"  | 3
|-
| style="text-align:center" | unsigned
| align="right"  | 0
| align="right"  | 255
| align="right"  | 3
|-
|rowspan="2"| 16
| style="text-align:center" | signed
| align="right"  | −32.768
| align="right"  | 32.767
| align="right"  | 5
|-
| style="text-align:center" | unsigned
| align="right"  | 0
| align="right"  | 65.535
| align="right"  | 5
|-
|rowspan="2"| 32
| style="text-align:center" | signed
| align="right"  | −2.147.483.648
| align="right"  | 2.147.483.647
| align="right"  | 10
|-
| style="text-align:center" | unsigned
| align="right"  | 0
| align="right"  | 4.294.967.295
| align="right"  | 10
|-
|rowspan="2"| 64
| style="text-align:center" | signed
| align="right"  | −9.223.372.036.854.775.808
| align="right"  | 9.223.372.036.854.775.807
| align="right"  | 19
|-
| style="text-align:center" | unsigned
| align="right"  | 0
| align="right"  | 18.446.744.073.709.551.615
| align="right"  | 20
|-
|rowspan="2"| 128
| style="text-align:center" | signed
| align="right"  | ≈ −1,70141·10<sup>38</sup>
| align="right"  | ≈ 1,70141·10<sup>38</sup>
| align="right"  | 39
|-
| style="text-align:center" | unsigned
| align="right"  | 0
| align="right"  | ≈ 3,40282·10<sup>38</sup>
| align="right"  | 39
|-
|rowspan="2"| ''n''
| style="text-align:center" | signed
| align="right"  | −2<sup>n−1</sup>
| align="right"  | 2<sup>n−1</sup> − 1
| style="text-align:center" | ⌈log<sub>10</sub> 2<sup>n−1</sup>⌉

|-
| style="text-align:center" | unsigned
| align="right"  | 0
| align="right"  | 2<sup>n</sup> − 1
| style="text-align:center" | ⌈log<sub>10</sub> 2<sup>n</sup>⌉
|}

== Rechenoperationen ==
Die folgenden Rechenoperationen gelten im Zweierkomplement. In den anderen Darstellungen ist die Umsetzung aufwendiger, das heißt mit mehr elektronischen [[Gatter]]n verbunden, da die 0 zwei unterschiedliche Darstellungen hat.

=== Vergleich ===
Um zwei vorzeichenlose Ganzzahlen A und B zu vergleichen, wird von der Zahl A die Zahl B subtrahiert. Zusätzlich wird der Übertrag, der bei der höchstwertigen Stelle entsteht, untersucht.

* Ist der Übertrag 1, ist B größer als A.
* Ist der Übertrag 0, ist B kleiner oder gleich A.
* Ist das Ergebnis der Subtraktion 0, sind die Zahlen gleich.

Um zwei vorzeichenbehaftete Ganzzahlen A und B zu vergleichen, wird deren höchstwertiges Bit gekippt (0 wird zu 1, 1 wird zu 0), die so entstandenen Zahlen werden wie vorzeichenlose Zahlen verglichen.

=== Vergleich auf Gleichheit ===
Vergleiche auf Gleichheit sind deutlich einfacher zu implementieren.
Außer in der Einerkomplement- und in der Vorzeichen-und-Betrag-Repräsentation ist bitweiser Vergleich ausreichend.

=== Addition ===
Um zwei Ganzzahlen A und B zu addieren, werden ihre Bits paarweise addiert, wie bei der [[Schriftliche Addition|schriftlichen Addition]]. Der elektronische Baustein, um ein Bit zweier Zahlen und den Übertrag der vorherigen Stelle zu addieren, heißt [[Volladdierer]].

Wenn beim Addieren der höchstwertigen Stelle ein Übertrag entsteht, ist das Ergebnis zu groß für den Datentyp. Bei vorzeichenlosen Zahlen wird ein solcher Überlauf üblicherweise ignoriert. Bei vorzeichenbehafteten Zahlen hängt das Verhalten von der Programmiersprache ab: In C ist das Verhalten undefiniert, in Java wird der Übertrag verworfen.

=== Subtraktion ===
Um zwei Ganzzahlen A und B zu subtrahieren, werden alle Bits von B gekippt (aus 0 wird 1, aus 1 wird 0), anschließend wird die Summe aus A, dem gekippten B und 1 berechnet. Statt B zu subtrahieren wird also die „Gegenzahl“ von B addiert.

Wenn bei dieser Addition ein Übertrag entsteht, war die Subtraktion erfolgreich. Wenn jedoch kein Übertrag entsteht, liegt das mathematische Ergebnis außerhalb des darstellbaren Bereichs, mit den gleichen Folgen wie bei der Addition.

=== Multiplikation ===
Um zwei Ganzzahlen A und B zu multiplizieren, wird seit Anfang der 1990er Jahre keine [[Schriftliche Multiplikation|schriftlichen Multiplikation]] verwendet, sondern es werden optimierte, wesentlich schnellere Verfahren (Dadda-Tree-Algorithmus) verwendet. Typische Latenzen liegen bei 3…4 Takten bei 3…6 GHz Taktfrequenz, d.&#8239; bei 500 bis 1300 ps.

Das Ergebnis hat meist genauso viele Stellen wie die beiden Operanden einzeln.

;Beispiel:
:<code>imul rcx, rbx     ; rcx = rcx * rbx, 64 bit = 64 bit * 64 bit</code>

Es spielt dabei keine Rolle, ob die Zahlen signed oder unsigned sind, da sich beide Repräsentation im Wert um 2<sup>64</sup> (MSB: −2<sup>63</sup> ↔ 2<sup>63</sup>) unterscheiden und damit keinen Einfluss auf den Low-Teil der Multiplikation haben.

Daneben gibt es häufig Multiplikationen für Langzahlarithmetik
:<code>imul rbx         ; rdx:rax = rax * rbx, 128 bit = 64 bit * 64 bit, beide Operanden signed</code>
:<code>mul  rbx             ; rdx:rax = rax * rbx, 128 bit = 64 bit * 64 bit, beide Operanden unsigned</code>
Gemischte Multiplikationen signed * unsigned gibt es im Allgemeinen nicht.
|&nbsp;|

=== Division ===
Um zwei Ganzzahlen A und B zu dividieren, werden seit Anfang der 1990er Jahre optimierte Algorithmen verwendet, die bis zu 6 Bit in einem Takt bestimmen.

=== Arithmetischer Überlauf ===
[[Datei:Zahlenkreis sint3.jpg|mini|Überlauf bei Integerzahlen (Bitlänge&nbsp;3+1)]]

Entsteht beim Rechnen mit Ganzzahlen ein Wert außerhalb ihres Wertebereiches, führt dies zu einem [[Arithmetischer Überlauf|arithmetischen Überlauf]]. So wird z.&nbsp;B. bei einer vorzeichenlosen 8-Bit-Integer-Variablen aus 255+1 der Wert&nbsp;0; bei einer vorzeichenbehafteten im [[Zweierkomplement]] hingegen aus 127+1 entweder der Wert −128 oder undefiniertes Verhalten, je nach verwendeter CPU, Sprache, Compiler, Compiler-Optionen und Laufzeitumgebung.

== Verwendung ==
Ganzzahlen lassen sich in Computern vielseitig einsetzen:
* Als Zahlen, mit denen gerechnet wird
* Als [[Nummer]]n bzw. Kennungen, um Objekte zu unterscheiden (Fehlernummern, Fehlercodes, IDs in [[Datenbank]]en)
* Als Bitmenge, für eine Teilmenge einer kleinen Anzahl von Objekten (mögliche Zustände in nichtdeterministischen [[Automat (Informatik)|Automaten]])

== Verwandte Datentypen ==
* [[Aufzählungstyp]]en definieren eine Menge von unterscheidbaren Objekten, sie werden üblicherweise als Ganzzahl gespeichert.
* [[Festkommazahl]]en funktionieren analog zu den Ganzzahlen, da das Komma keine Auswirkungen auf Vergleich, Addition und Subtraktion hat, lediglich bei Multiplikation und Division muss das Komma verschoben und das Ergebnis gerundet werden.
* [[Gleitkommazahl]]en decken bei gleichem Speicherbedarf einen größeren Zahlenbereich ab, können dafür aber nicht alle ganzen Zahlen in diesem Bereich darstellen. Durch die erforderlichen Rundungen innerhalb der Rechnungen gelten viele der Rechenregeln (Assoziativgesetz, Distributivgesetz) dort nicht.

== Einzelnachweise ==
<references />

[[Kategorie:Datentyp]]
[[Kategorie:Computerarithmetik]]