UInt32

UInt32 is a fixed-width, unsigned 32-bit integer value type in Swift. It represents non-negative whole numbers using exactly 4 bytes (32 bits) of memory. Unlike the standard Int or UInt types, which vary in size depending on the underlying system architecture (32-bit or 64-bit), UInt32 guarantees a strict 32-bit footprint across all platforms.

Value Range

Because it is unsigned, UInt32 cannot represent negative numbers. Its memory is entirely dedicated to positive magnitudes.

• Minimum Value: 0
• Maximum Value: 4,294,967,295 ($2^{32} - 1$)

You can access these boundaries programmatically using the type’s static properties:

let absoluteMin = UInt32.min // 0
let absoluteMax = UInt32.max // 4294967295

Initialization and Type Conversion

Swift is a strongly typed language and does not implicitly convert between different integer types. You must explicitly initialize a UInt32 when converting from another numeric type.

// Literal initialization
let explicitUInt32: UInt32 = 25000

// Conversion from standard Int
let standardInt: Int = 1024
let convertedUInt32 = UInt32(standardInt)

// Conversion from a floating-point type (truncates the decimal)
let doubleValue: Double = 3.14159
let truncatedUInt32 = UInt32(doubleValue) // 3

Note: Attempting to initialize a UInt32 with a negative value or a value exceeding 4,294,967,295 will trigger a runtime crash.

Overflow Behavior

By default, Swift arithmetic operators (+, -, *) trap and trigger a runtime error if an operation exceeds the bounds of UInt32. To perform modulo arithmetic that wraps around the type’s boundaries, you must use Swift’s overflow operators (&+, &-, &*).

var maxBoundary = UInt32.max

// Standard addition traps on overflow
// maxBoundary += 1 // Fatal error: arithmetic overflow

// Overflow addition wraps to the minimum value
let wrappedAddition = maxBoundary &+ 1 // 0

var minBoundary = UInt32.min

// Overflow subtraction wraps to the maximum value
let wrappedSubtraction = minBoundary &- 1 // 4294967295

Protocol Conformance

Under the hood, UInt32 is implemented as a struct. It conforms to a robust hierarchy of Swift standard library protocols, dictating its behavior and capabilities:

• FixedWidthInteger & BinaryInteger: Provides bitwise operations, bit-shifting (<<, >>), and endianness conversions (bigEndian, littleEndian).
• UnsignedInteger: Guarantees the type represents only non-negative values.
• Numeric & Strideable: Enables standard arithmetic and allows the type to be used in ranges (e.g., 0..<UInt32.max).
• Hashable & Equatable: Allows UInt32 to be used as dictionary keys and compared for equality.
• Codable: Provides out-of-the-box support for serialization and deserialization (e.g., JSON encoding).

Bitwise Operations

Because UInt32 has a guaranteed 32-bit layout, it is frequently manipulated at the bit level using standard bitwise operators:

let bitmask: UInt32 = 0b1111_0000_1111_0000_1111_0000_1111_0000
let inverted = ~bitmask // 0b0000_1111_0000_1111_0000_1111_0000_1111
let shifted = bitmask >> 4

Master Swift with Deep Grasping Methodology!

Learn More