> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Rust 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 ```rust theme={"dark"} // Inspecting the architectural footprint at runtime let bytes: usize = std::mem::size_of::(); 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`. ```rust theme={"dark"} 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. ```rust theme={"dark"} 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 = 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.

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