В чем разница между usize и u32 в Rust? Когда что использовать?

Ключевое различие: платформозависимость

Главное отличие usize от u32 в том, что usize — это платформозависимый тип. Его размер определяется архитектурой процессора, на которой выполняется программа:

• На 32-битных системах (x86, ARM32) — 4 байта (32 бита).
• На 64-битных системах (x86_64, ARM64) — 8 байт (64 бита).
• На 16-битных системах (редко) — 2 байта (16 бит).

u32 же — это фиксированный тип, который всегда занимает 4 байта независимо от архитектуры.

Для чего нужен usize?

usize специально создан для представления размеров, индексов и смещений в памяти. Его размер гарантированно совпадает с размером указателя на целевой платформе. Это означает, что usize может адресовать любой байт в доступной памяти.

Рассмотрим пример:

// Максимальное значение usize зависит от архитектуры
println!("max usize: {}", usize::MAX);
// На 64-битной системе: 18446744073709551615
// На 32-битной системе: 4294967295

// u32 всегда одинаков
println!("max u32: {}", u32::MAX);
// Всегда: 4294967295

Почему нельзя использовать u32 для индексов?

Представьте, что вы пишете программу для 64-битной системы и используете u32 для индексации большого вектора. Если вектор содержит более 4,3 миллиарда элементов (что возможно на 64-битной системе с большим объемом RAM), то u32 переполнится, и индексация сломается. usize же может адресовать до 18,4 квинтиллионов элементов на 64-битной системе.

Почему Rust запрещает смешивание?

Rust — язык с сильной статической типизацией. Он предотвращает случайные ошибки, которые возникают при смешивании типов разного размера. Рассмотрим:

let a: u32 = 5;
let b: usize = 10;
// let c = a + b; // ОШИБКА: нельзя сложить u32 и usize

// Правильное решение: явное приведение
let c = a as usize + b; // или
let c = a + b as u32;   // но это может привести к потере данных

Если бы Rust разрешил неявное смешивание, вы могли бы случайно потерять данные при переполнении. Например, на 64-битной системе usize может содержать значение, которое не помещается в u32. Явное приведение заставляет программиста осознать это.

Когда что использовать?

• usize — для индексов коллекций (Vec, String, HashMap), размеров, смещений в памяти, параметров функций, работающих с памятью (например, std::mem::size_of).
• u32 — для хранения чисел, которые гарантированно помещаются в 32 бита: идентификаторы, счетчики, значения из внешних источников (файлы, сеть), где спецификация требует 32 бита.

Практический пример

fn main() {
    let data: Vec<u8> = vec![0; 1_000_000];
    
    // Правильно: usize для индексов
    for i in 0..data.len() {
        let _ = data[i];
    }
    
    // Если вам нужно сохранить индекс в структуре:
    struct MyStruct {
        index: usize, // правильно
        // index: u32, // может не хватить на 64-битной системе
    }
    
    // u32 используйте для фиксированных форматов
    struct NetworkPacket {
        packet_id: u32, // всегда 32 бита по протоколу
        payload: Vec<u8>,
    }
}

Производительность

Миф о том, что u32 быстрее usize, не всегда верен. На 64-битных системах операции с 64-битными числами могут быть такими же быстрыми, как с 32-битными, а иногда и быстрее из-за выравнивания данных. Используйте usize для индексов — это идиоматично и безопасно.

fn main() {
    let v = vec![1, 2, 3];
    
    // Идиоматичный Rust
    for i in 0..v.len() {
        println!("{}", v[i]);
    }
    
    // Или еще лучше — итератор
    for (i, val) in v.iter().enumerate() {
        println!("v[{}] = {}", i, val);
    }
    // Здесь i автоматически имеет тип usize
}