Int

Int is a standard library value type (implemented as a struct) in Swift that represents a signed, two’s complement integer. By default, Int is platform-dependent: it is guaranteed to be the same size as the native word size of the target architecture. On 32-bit platforms, Int is equivalent to Int32; on 64-bit platforms, it is equivalent to Int64.

Bounds and Memory

Because Int is platform-dependent, its minimum and maximum representable values are accessed via static properties rather than assumed constants.

let minVal: Int = Int.min // -9,223,372,036,854,775,808 on 64-bit
let maxVal: Int = Int.max //  9,223,372,036,854,775,807 on 64-bit
let bitWidth: Int = Int.bitWidth // 64 on 64-bit platforms

Literal Representation

The Swift compiler infers Int as the default type for integer literals. Literals can be expressed in decimal, binary, octal, or hexadecimal formats using specific prefixes. Underscores can be injected for readability without affecting the underlying compiled value.

let decimal: Int = 17
let binary: Int = 0b10001
let octal: Int = 0o21
let hexadecimal: Int = 0x11
let padded: Int = 1_000_000 // Underscores are ignored by the compiler

Explicitly Sized Variants

While Int is the recommended default, Swift provides explicitly sized integer structs for strict memory layouts, network protocols, or C-interoperability. Swift is strongly typed and does not support implicit type coercion; explicitly sized integers do not implicitly convert to Int or to each other.

• Signed: Int8, Int16, Int32, Int64
• Unsigned: UInt, UInt8, UInt16, UInt32, UInt64

let explicit8Bit: Int8 = 127
let unsigned64Bit: UInt64 = 18_446_744_073_709_551_615

// Explicit initialization/casting is mandatory across integer types
let converted: Int = Int(explicit8Bit)

Overflow and Safety Mechanics

Swift prioritizes memory safety by trapping (triggering a runtime crash) if an arithmetic operation exceeds the allocated memory bounds of the Int type. To perform two’s complement wrap-around arithmetic without trapping, Swift requires explicit overflow operators.

var max = Int.max

// max += 1 // This will trap (crash) at runtime

// Wrap-around addition using the overflow operator
let wrapped: Int = max &+ 1 // Evaluates to Int.min

The standard overflow operators are &+ (addition), &- (subtraction), and &* (multiplication).

Master Swift with Deep Grasping Methodology!

Learn More