Integer Types

Signed vs Unsigned

Signed integer types (i8, i16, i32, i64, i128) can represent negative and positive numbers, while unsigned types (u8, u16, u32, u64, u128) only represent zero and positive numbers, giving them double the positive range for the same bit size.

Example: Signed vs Unsigned

fn main() {
    let signed: i32 = -10;
    let unsigned: u32 = 10;
    println!("signed: {}, unsigned: {}", signed, unsigned);
}

Default Integer Type

When you write an integer literal without an explicit type and the compiler cannot infer one from context, Rust defaults to i32, which is a good general-purpose choice on modern hardware.

Example: Default Integer Type

fn main() {
    let default_int = 100;
    println!("Default integer type holds: {}", default_int);
}

usize for Indexing

usize is an unsigned integer sized to match the machine's pointer width (commonly 64-bit). It is the type Rust uses for array/vector indices and lengths, since a collection can never have a negative size.

Example: usize for Indexing

fn main() {
    let numbers = [10, 20, 30];
    let index: usize = 1;
    println!("Element at index {}: {}", index, numbers[index]);
}

Integer Overflow

Every integer type has a fixed range, and exceeding it is called overflow. In a debug build, Rust panics immediately on overflow to catch the bug early; in a release build it wraps around instead, so relying on overflow behavior is dangerous.

Note: checked_add returns None instead of panicking or wrapping, letting you handle overflow explicitly.

Example: Integer Overflow

fn main() {
    let small: u8 = 250;
    let safe_sum = small.checked_add(3);
    println!("checked_add result: {:?}", safe_sum);
}