Swift UInt64

UInt64 is a value type in Swift representing a 64-bit unsigned integer. It stores non-negative whole numbers using exactly 8 bytes of memory, providing a fixed-width numeric representation that remains strictly 64 bits wide regardless of the underlying platform’s architecture (unlike UInt, which scales to the platform’s word size). Because it is an unsigned type, it allocates all 64 bits to the magnitude of the number, omitting the sign bit. This yields the following mathematical bounds:

Minimum Value: 0
Maximum Value: 18,446,744,073,709,551,615 ( $2^{64} - 1$ )

Syntax and Initialization

You can instantiate a UInt64 using integer literals, explicit type annotation, or by converting from other numeric types. Swift does not implicitly convert between integer types, so typecasting is strictly required when mixing UInt64 with types like Int or UInt32.

// Explicit type annotation
let defaultZero: UInt64 = 0
let hexLiteral: UInt64 = 0xFFFFFFFFFFFFFFFF

// Accessing static boundary properties
let absoluteMin = UInt64.min // 0
let absoluteMax = UInt64.max // 18446744073709551615

// Explicit conversion from a signed integer
let standardInt: Int = 2048
let convertedUInt64 = UInt64(standardInt)

// Explicit conversion from a smaller unsigned integer
let smallUInt: UInt8 = 255
let expandedUInt64 = UInt64(smallUInt)

Overflow and Underflow Behavior

By default, Swift prevents integer overflow and underflow. If an arithmetic operation on a UInt64 results in a value outside its 64-bit bounds, the program will trigger a runtime trap. To intentionally allow wrapping behavior at the bit level, Swift provides masking arithmetic operators (&+, &-, &*).

var boundaryValue = UInt64.max

// Standard addition causes a runtime crash (Overflow)
// boundaryValue += 1 

// Masking addition wraps the 64-bit integer back to 0
let wrappedValue = boundaryValue &+ 1 

var zeroValue = UInt64.min

// Masking subtraction wraps the 64-bit integer to UInt64.max
let underflowValue = zeroValue &- 1 

Protocol Conformances

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

FixedWidthInteger & BinaryInteger: Guarantees a specific bit width, enabling bitwise operations (~, &, |, ^, <<, >>) and providing access to properties like leadingZeroBitCount and nonzeroBitCount.
UnsignedInteger: Semantically enforces the lack of a sign bit.
Hashable & Equatable: Allows UInt64 to be compared for equality (==, !=) and used as keys in Dictionary or elements in Set.
Comparable: Enables relational operators (<, >, <=, >=).
Codable: Provides out-of-the-box support for serialization and deserialization (e.g., JSON encoding).

let bitwiseTarget: UInt64 = 0b1010_1010
let shifted = bitwiseTarget << 2 // 0b10_1010_1000

let zeroCount = bitwiseTarget.leadingZeroBitCount // 56

Tired of Poor Swift Skills? Fix That With Deep Grasping!Learn More

Methods

Initializers

Closures

Type Declarations

Properties

Generics

Optional Binding

Patterns

Extensions

Error Handling

Attributes

Subscripts

Parameters

Constants & Variables

Conditionals

Loops

Collection Types

Basic Types

Numeric Types

Imports

Comments

Optional Operators

Arithmetic Operators

Overflow Operators

Assignment Operators

Bitwise Operators

Comparison Operators

Conditional Operators

Logical Operators

Range Operators

Type-Casting Operators

Syntax and Initialization

Overflow and Underflow Behavior

Protocol Conformances

​Syntax and Initialization

​Overflow and Underflow Behavior

​Protocol Conformances

Syntax and Initialization

Overflow and Underflow Behavior

Protocol Conformances