Integer (computer science): Difference between revisions

The ''internal representation'' of this datum is the way the value is stored in the computer's memory. Unlike mathematical integers, a typical datum in a computer has some minimal and maximum possible value.

 

 

There are four well-known [[signed number representations|ways to represent signed numbers]] in a binary computing system. The most common is [[two's complement]], which allows a signed integral type with ''n'' bits to represent numbers from −2^(''n''−1) through 2^(''n''−1)−1. Two's complement arithmetic is convenient because there is a perfect [[bijection|one-to-one correspondence]] between representations and values (in particular, no separate +0 and −0), and because [[addition]], [[subtraction]] and [[multiplication]] do not need to distinguish between signed and unsigned types. Other possibilities include [[offset binary]], [[sign-magnitude]], and [[ones' complement]].

 

 

Some [[Decimal computer|older computer architectures]] used decimal representations of integers, stored in [[binary-coded decimal|binary-coded decimal (BCD)]] or other format. These values generally require data sizes of 4 bits per decimal digit (sometimes called a [[nibble]]), usually with additional bits for a sign. Many modern CPUs provide limited support for decimal integers as an extended datatype, providing instructions for converting such values to and from binary values. Depending on the architecture, decimal integers may have fixed sizes (e.g., 7 decimal digits plus a sign fit into a 32-bit word), or may be variable-length (up to some maximum digit size), typically occupying two digits per byte (octet).

|-

| rowspan="2" style="text-align:right;"| 64

|''Signed:'' From −9,223,372,036,854,775,808 to [[9223372036854775807|9,223,372,036,854,775,807]], from −(2⁶³) to 2⁶³ − 1

| style="text-align:right;" | {{#expr:63*ln2/ln10 round 2}}

The table above lists integral type widths that are supported in hardware by common processors. High level programming languages provide more possibilities. It is common to have a 'double width' integral type that has twice as many bits as the biggest hardware-supported type. Many languages also have ''bit-field'' types (a specified number of bits, usually constrained to be less than the maximum hardware-supported width) and ''range'' types (that can represent only the integers in a specified range).

 

 

A [[Boolean datatype|Boolean]] or [[Flag (computing)|Flag]] type is a type that can represent only two values: 0 and 1, usually identified with ''false'' and ''true'' respectively. <!-- Pascal has them the other way around --> This type can be stored in memory using a single bit, but is often given a full byte for convenience of addressing and speed of access.

 

One important cause of non-portability of software is the incorrect assumption that all computers have the same word size as the computer used by the programmer. For example, if a programmer using the C language incorrectly declares as {{mono|int}} a variable that will be used to store values greater than 2¹⁵−1, the program will fail on computers with 16-bit integers. That variable should have been declared as {{mono|long}}, which has at least 32 bits on any computer. Programmers may also incorrectly assume that a pointer can be converted to an integer without loss of information, which may work on (some) 32-bit computers, but fail on 64-bit computers with 64-bit pointers and 32-bit integers. This issue is resolved by C99 in [[stdint.h]] in the form of {{code|intptr_t}}.

 

===Short integer===

! [[Programming language]]

! Approval Type

! Data type name

! Storage in [[bytes]]

| [[C (programming)|C]] ISO/ANSI C99

| International Standard

| 4<br>(minimum requirement 4)

| −2,147,483,647 to +2,147,483,647

| International Standard

| [[Unix]],<br>64-bit systems<ref name="agnerfog" /><ref name="drdobbsinteger" />

| 8<br>(minimum requirement 4)

| −9,223,372,036,854,775,807 to +9,223,372,036,854,775,807

| International Standard

| [[Unix]], [[Windows]],<br>16/32-bit system

| 4 <ref>{{cite web

| title=Fundamental types in C++|url=http://cppreference.com/wiki/language/types|publisher=cppreference.com|access-date=5 December 2010}}</ref><br>(minimum requirement 4)

| International Standard<br>[[ECMA-372]]

| [[Unix]], [[Windows]],<br>16/32-bit systems

| 4 <ref>{{cite web| url=http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-372.pdf |title=Chapter 8.6.2 on page 12|publisher=ecma-international.org}}</ref><br>(minimum requirement 4)

| −2,147,483,648 to +2,147,483,647<br>

 

===Long long===

In the [[C99]] version of the [[C (programming language)|C programming language]] and the [[C++11]] version of [[C++]], a <CODE>long long</CODE> type is supported that has double the minimum capacity of the standard <CODE>long</CODE>. This type is not supported by compilers that require C code to be compliant with the previous C++ standard, C++03, because the {{mono|long long}} type did not exist in C++03. For an ANSI/ISO compliant compiler, the minimum requirements for the specified ranges, that is, −(2⁶³&minus;1)<ref name="c-std-6.2.6.2p2" /> to 2⁶³−1 for signed and 0 to 2⁶⁴−1 for unsigned,<ref name="c-std-5.2.4.2.1" /> must be fulfilled; however, extending this range is permitted.<ref>{{cite web| url=http://www.ericgiguere.com/articles/ansi-c-summary.html|title=The ANSI Standard: A Summary for the C Programmer|first=Eric|last=Giguere|date=December 18, 1987|access-date=2010-09-04}}</ref><ref>{{cite web|url=http://flash-gordon.me.uk/ansi.c.txt|title=American National Standard Programming Language C specifies the syntax and semantics of programs written in the C programming language.|access-date=2010-09-04|url-status=dead|archive-url=https://web.archive.org/web/20100822072551/http://flash-gordon.me.uk/ansi.c.txt|archive-date=2010-08-22}}</ref> This can be an issue when exchanging code and data between platforms, or doing direct hardware access. Thus, there are several sets of headers providing platform independent exact width types. The C [[standard library]] provides ''[[stdint.h]]''; this was introduced in C99 and C++11.

 

== Syntax ==

 

 

* <code>42</code>

 

* Many programming languages, especially those influenced by [[C (programming language)|C]], prefix an integer literal with <code>0X</code> or <code>0x</code> to represent a [[hexadecimal]] value, e.g. <code>0xDEADBEEF</code>. Other languages may use a different notation, e.g. some [[assembly language]]s append an <code>H</code> or <code>h</code> to the end of a hexadecimal value.

* Several languages, including [[Java (programming language)|Java]], [[C Sharp (programming language)|C#]], [[Scala (programming language)|Scala]], [[Python (programming language)|Python]], [[Ruby (programming language)|Ruby]], [[OCaml]], C (starting from C23) and C++ can represent binary values by prefixing a number with <code>0B</code> or <code>0b</code>.