Integers (Signed vs Unsigned)

An Integer is a datum of integral data type, a data type that represents some range of mathematical integers. Integral data types may be of different sizes and may or may not contain negative values.

1. Signed vs. Unsigned

In computer science, the distinction between signed and unsigned integers determines whether the variable can represent negative numbers.

Signed Integers

Can represent both positive and negative numbers.

Mechanism: Usually uses the Two's Complement representation. The most significant bit (MSB) is the "sign bit".
- 0 = Positive
- 1 = Negative
Range (for $n$ bits): $-2^{n-1}$ to $2^{n-1} - 1$.
Example (8-bit): -128 to 127.

Unsigned Integers

Can only represent non-negative numbers (zero and positive).

Mechanism: All bits are used to store the magnitude of the number.
Range (for $n$ bits): $0$ to $2^n - 1$.
Example (8-bit): 0 to 255.

2. Common Bit Sizes

Bits	Name (C/C++)	Signed Range	Unsigned Range
8	`char` / `int8`	-128 to 127	0 to 255
16	`short` / `int16`	-32,768 to 32,767	0 to 65,535
32	`int` / `int32`	-2 billion to 2 billion	0 to 4 billion
64	`long` / `int64`	$-9 \times 10^{18}$ to $9 \times 10^{18}$	0 to $1.8 \times 10^{19}$

3. Integer Overflow

Overflow occurs when an arithmetic operation attempts to create a numeric value that is outside of the range that can be represented with a given number of bits.

Unsigned Overflow (Wraparound)

Usually defined behavior. If you add 1 to the maximum value, it wraps around to 0.

uint8_t x = 255;
x = x + 1; -> x becomes 0.

Signed Overflow

In languages like C/C++, signed integer overflow is Undefined Behavior (UB), meaning anything can happen (crashes, security vulnerabilities). In Java, it wraps around (e.g., MAX_INT + 1 becomes MIN_INT).

4. Two's Complement

The standard way computers represent negative integers. To get -x:

Invert all bits of x (One's Complement).
Add 1.

Example: 5 in 4-bit binary is 0101.
1. Invert: 1010
2. Add 1: 1011 (-5)

5. BigInt (Arbitrary-Precision Integers)

Standard integers (like int32 or int64) have a fixed size and can overflow. BigInt allows you to store integers whose size is limited only by the available memory of the system.

How it works: The number is stored as an array of digits (or smaller integers) in memory. Arithmetic operations are performed using software algorithms rather than direct CPU instructions.
Pros: No overflow. Can represent numbers larger than the universe.
Cons: Significantly slower than fixed-width integers (CPU cannot process them in a single cycle).

Language Support

Python: All integers are BigInts by default (since Python 3).
JavaScript: Use the BigInt type (append n to the number).
```
const huge = 9007199254740991n; 
```
Java: Use java.math.BigInteger.
C#: Use System.Numerics.BigInteger.

programming/common-syntax programming/bit-manipulation programming/floating-point-numbers

Backlinks

Strings

Created: March 17, 2026 • Last Modified: January 31, 2026

Docs Login