usize

usize is an architecture-dependent unsigned integer type whose size in memory is determined at compile time by the pointer width of the target compilation platform. It represents the maximum theoretical range of memory addresses addressable by the underlying hardware and operating system.

Memory Layout and Architecture Dependency

Unlike fixed-width integers, the byte size of usize is statically determined during compilation based on the target triple:

• 16-bit targets (e.g., avr-unknown-gnu): 2 bytes (16 bits).
• 32-bit targets (e.g., wasm32-unknown-unknown, i686-pc-windows-msvc): 4 bytes (32 bits).
• 64-bit targets (e.g., x86_64-unknown-linux-gnu, aarch64-apple-darwin): 8 bytes (64 bits).

Value Ranges

Because it is an unsigned type, usize cannot represent negative numbers. Its bounds are defined by the pointer width (N) of the architecture:

• Minimum Value (usize::MIN): 0
• Maximum Value (usize::MAX): 2^N - 1

// Inspecting the architectural footprint at runtime
let bytes: usize = std::mem::size_of::<usize>();
let bits: u32 = usize::BITS;

// Accessing the architectural limits
let min: usize = usize::MIN; // Always 0
let max: usize = usize::MAX; // 4,294,967,295 (32-bit) or 18,446,744,073,709,551,615 (64-bit)

Type System Constraints

In Rust’s type system, usize is a strictly distinct type. It is not a type alias for u32 or u64, even if the underlying architecture happens to match those bit widths. The compiler enforces strict type safety, meaning implicit coercion between usize and fixed-width integers is forbidden.

Furthermore, usize is the mandatory type for representing collection lengths and memory offsets. The type system enforces this strictly; memory bounds cannot be indexed using fixed-width integers like u32 or u64.

let arch_int: usize = 100;
let fixed_int: u64 = 100;

// ERROR: mismatched types
// let result = arch_int + fixed_int; 

// SUCCESS: Requires explicit casting via the `as` keyword or conversion traits
let result_64 = arch_int as u64 + fixed_int;

When casting between usize and fixed-width integers, truncation can occur if the target platform’s pointer width is smaller than the fixed-width type. Safe conversions should utilize the TryInto trait to handle potential overflow errors at runtime across different architectures.

use std::convert::TryInto;

// A u64 value that exceeds the 32-bit maximum
let large_val: u64 = 5_000_000_000;

// Safely attempting to convert a u64 to a usize.
// This compiles on all platforms, but correctly returns an Err at runtime on 32-bit targets.
let safe_cast: Result<usize, _> = large_val.try_into();

if cfg!(target_pointer_width = "32") {
    assert!(safe_cast.is_err());
} else {
    // Explicitly cast the unwrapped value to u64 and compare against a u64 literal.
    // Because `cfg!` evaluates to a boolean literal, this block is still parsed and 
    // type-checked on 32-bit targets. Using a typed `u64` literal prevents a 
    // "literal out of range for usize" compilation error.
    assert_eq!(safe_cast.unwrap() as u64, 5_000_000_000u64);
}

Relationship to isize

usize has a signed counterpart, isize. While usize represents non-negative values up to 2^N - 1, isize uses two’s complement representation to support negative values, shifting its range to -2^N-1 through 2^N-1 - 1. Both types share the exact same byte size on any given architecture.

Master Rust with Deep Grasping Methodology!

Learn More