Rust u16

u16 is a primitive unsigned 16-bit integer type in Rust. It occupies exactly 2 bytes of memory and represents non-negative whole numbers ranging from 0 to 65,535 (

2^{16} - 1

). Because it is unsigned, it cannot represent negative values and uses all 16 bits to store the magnitude of the number.

Memory Layout and Bounds

The bounds of a u16 are defined by associated constants in the standard library:

u16::MIN: 0
u16::MAX: 65535

Syntax and Initialization

You can declare a u16 using explicit type annotation, literal suffixes, or rely on the compiler’s type inference. Rust also supports visual separators (_) and various radix representations (hexadecimal, octal, binary).

let dec_annotated: u16 = 65000;       // Explicit type annotation
let dec_suffixed = 65000_u16;         // Literal suffix
let hex_val = 0xFE00_u16;             // Hexadecimal (Base 16)
let oct_val = 0o177777_u16;           // Octal (Base 8)
let bin_val = 0b1111_0000_1111_u16;   // Binary (Base 2)

Type Casting and Truncation

Conversions between u16 and other primitive numeric types are performed using the as keyword. When casting to a smaller type (e.g., u8), Rust truncates the higher-order bits. When casting to a larger type (e.g., u32), Rust performs zero-extension, filling the new higher-order bits with zeros.

let original: u16 = 0x1234; // 4660 in decimal

// Truncation: Keeps only the lowest 8 bits (0x34)
let downcast: u8 = original as u8; 

// Zero-extension: Pads the highest 16 bits with zeros (0x00001234)
let upcast: u32 = original as u32; 

Overflow Behavior

Like all Rust integers, u16 has strict overflow behavior determined by the compilation profile:

Debug mode (dev): Integer operations that exceed u16::MAX or drop below u16::MIN will trigger a runtime panic.
Release mode (release): Operations silently wrap around using two’s complement wrapping (e.g., 65535 + 1 becomes 0).

To explicitly control overflow behavior regardless of the compilation profile, u16 provides dedicated method families:

let val: u16 = 65535;

// Wraps around to 0
let wrapped = val.wrapping_add(1); 

// Returns None on overflow
let checked = val.checked_add(1); 

// Caps at u16::MAX (65535) instead of overflowing
let saturated = val.saturating_add(1); 

// Returns a tuple: (0, true) indicating the result and that overflow occurred
let (result, overflowed) = val.overflowing_add(1); 

Endianness and Byte Manipulation

Because u16 is a multi-byte type, its memory representation is subject to endianness (byte order). The standard library provides methods to convert a u16 to and from raw byte arrays ([u8; 2]) in specific byte orders.

let val: u16 = 0xABCD;

// Native endianness (depends on the target architecture)
let native_bytes: [u8; 2] = val.to_ne_bytes(); 

// Little-endian: Least significant byte first
let le_bytes: [u8; 2] = val.to_le_bytes(); // [0xCD, 0xAB]

// Big-endian (Network byte order): Most significant byte first
let be_bytes: [u8; 2] = val.to_be_bytes(); // [0xAB, 0xCD]

// Reconstructing from bytes
let reconstructed = u16::from_be_bytes([0xAB, 0xCD]);

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

Functions

Traits

Closures

Generics

Enums

Pattern Matching

Structs

Macros

Lifetimes

Error Handling

Variables

Control Flow

Loops

Modules

Compound Types

Collection Types

Numeric Types

Text & Boolean Types

Attributes

Comments

Assignment Operators

Arithmetic Operators

Comparison Operators

Logical Operators

Unary Operators

Reference Operators

Access & Path Operators

Range Operators

Bitwise Operators

Type Cast Operators

Memory Layout and Bounds

Syntax and Initialization

Type Casting and Truncation

Overflow Behavior

Endianness and Byte Manipulation

​Memory Layout and Bounds

​Syntax and Initialization

​Type Casting and Truncation

​Overflow Behavior

​Endianness and Byte Manipulation

Memory Layout and Bounds

Syntax and Initialization

Type Casting and Truncation

Overflow Behavior

Endianness and Byte Manipulation