Разбираемся с Box, ref, & и * в Rust: в чём разница и как их использовать?

Ключевое различие: владение и заимствование

Чтобы понять разницу, нужно запомнить главное правило Rust: каждое значение имеет ровно одного владельца. Box, &, ref и * — это инструменты для управления этим владением.

1. & — ссылка (заимствование)

&x создаёт ссылку на значение x. Это значит, что мы заимствуем значение, но не становимся его владельцем. Когда ссылка выходит из области видимости, значение не удаляется — оно остаётся у владельца.

let x = 42;
let y = &x; // y — это &i32, ссылка на x
println!("{}", y); // 42 — автоматическое разыменование при печати
// x всё ещё жив, так как y только заимствовал его

2. * — оператор разыменования

* делает обратное &: он берёт ссылку и даёт доступ к самому значению. В большинстве случаев Rust автоматически применяет * (например, при вызове методов), но иногда нужно явно:

let x = 42;
let y = &x;
let z = *y; // z = 42, теперь z — это i32, а не ссылка
// Но! z — это копия, так как i32 реализует Copy

Важно: *y даёт доступ к значению, но не передаёт владение, если это ссылка. Можно только читать или копировать (если тип реализует Copy).

3. ref — захват по ссылке в сопоставлении с образцом

ref используется только в match и деструктуризации. Он говорит: «не забирай владение, а возьми ссылку». Без ref вы попытаетесь переместить значение из Option или Result:

let maybe_number = Some(10);
match maybe_number {
    Some(x) => println!("{}", x), // ОШИБКА! x перемещается, maybe_number больше нельзя использовать
    None => ()
}
// println!("{:?}", maybe_number); // ошибка компиляции

С ref мы берём ссылку на внутреннее значение:

match maybe_number {
    Some(ref x) => { // x — это &i32
        println!("{}", x); // автоматически разыменовывается
    }
    None => ()
}
println!("{:?}", maybe_number); // ОК, владение не было передано

Также есть ref mut для изменяемых ссылок.

4. Box<T> — умный указатель с владением

Box — это владеющий указатель на данные в куче (heap). В отличие от &, Box является владельцем. Когда Box удаляется, данные в куче тоже удаляются.

let a = Box::new(42); // a — владелец числа 42 в куче
let b = a; // владение перемещается в b
// println!("{}", a); // ОШИБКА! a больше не владеет данными

Сравните с ссылкой:

let x = 42;
let y = &x; // y — ссылка, x остаётся владельцем
let z = y; // копируется ссылка, x всё ещё владеет
println!("{}", x); // ОК

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

• & — когда нужно временно «посмотреть» на данные, не забирая их. 90% случаев.
• * — когда нужно явно получить доступ к значению за ссылкой (редко, обычно автоматически).
• ref — только в match и деструктуризации, чтобы не перемещать данные.
• Box — когда нужно владеть данными, но хранить их в куче (например, для рекурсивных типов, трейт-объектов или больших данных, которые не должны копироваться на стеке).

Пример: рекурсивный тип без Box не скомпилируется

enum List {
    Cons(i32, Box<List>), // Box обязателен, иначе размер бесконечен
    Nil,
}

Итог

Запомните цепочку: & создаёт ссылку, * её разыменовывает, ref — это & внутри match, а Box — это владелец, который хранит данные в куче. Начните с & для заимствования, и используйте Box только когда компилятор явно попросит.

let s = String::from("hello");
let r = &s;
println!("{}", r.len()); // работает без явного *r
// Rust автоматически разыменовывает r до String, чтобы вызвать len()

let b = Box::new(String::from("world"));
println!("{}", b.len()); // автоматическое разыменование Box -> String

let maybe_ref = &Some(10);
match maybe_ref {
    &Some(x) => println!("{}", x), // x — это i32, потому что мы "разобрали" ссылку
    &None => ()
}
// Но если maybe_ref — это не ссылка, а владелец, то &Some(x) не сработает

fn process(data: &Vec<i32>) { // заимствование
    for x in data.iter() {
        println!("{}", x);
    }
}

fn main() {
    let v = vec![1, 2, 3];
    process(&v); // передаём ссылку
    println!("{:?}", v); // v всё ещё доступен