Ownership в Rust: как работает управление памятью без GC

Ownership — самая важная концепция Rust. Именно она позволяет быть быстрым (как C) и безопасным (как Java) одновременно. С правильными аналогиями это не сложно!

Аналогия: ключ от квартиры

1. Ключ есть только у одного — это владелец.
2. Отдал ключ другу — у тебя его больше нет. Это move (перемещение).
3. Дал посмотреть, не отдавая — это borrow (заимствование, ссылка).
4. Хозяин ушёл — квартира закрывается. Память освобождается автоматически.

Три правила Ownership

1. У каждого значения есть один владелец.
2. Владелец только один одновременно.
3. Когда владелец выходит из области видимости — значение удаляется.

fn main() {
    let s1 = String::from("привет");  // s1 владелец

    // MOVE: s1 ПЕРЕДАЁТ владение s2
    let s2 = s1;

    // println!("{}", s1);  // ОШИБКА! s1 больше не владелец
    // error[E0382]: borrow of moved value

    println!("{}", s2);  // OK

    // Простые типы — копируются, не перемещаются!
    let x = 5;
    let y = x;   // x КОПИРУЕТСЯ (trait Copy)
    println!("x={}, y={}", x, y);  // оба доступны
}

Ownership и функции

fn takes_ownership(s: String) {
    println!("Получил: {}", s);
}  // s удаляется

fn makes_copy(x: i32) {
    println!("Копия: {}", x);
}  // оригинал не тронут

fn gives_back() -> String {
    let s = String::from("привет");
    s  // передаём владение вызывающему
}

fn main() {
    let s1 = gives_back();
    takes_ownership(s1);     // s1 перемещается в функцию
    // println!("{}", s1);  // ОШИБКА!

    let x = 5;
    makes_copy(x);
    println!("{}", x);  // OK — i32 копируется
}

References — заимствование без передачи владения

Аналогия: Показываешь другу фотографию кошки — он смотрит, но не забирает.

fn length(s: &String) -> usize {
    s.len()   // используем без владения
}  // s — ссылка, данные НЕ удаляются

fn main() {
    let s1 = String::from("привет");
    let len = length(&s1);   // передаём ссылку
    println!("'{}' = {} символов", s1, len);  // s1 жива!

    // Срез строки
    let sentence = String::from("hello world");
    let hello = &sentence[0..5];   // "hello"
    let world = &sentence[6..11];  // "world"
    println!("{} {}", hello, world);
}

Изменяемые ссылки &mut

fn append(s: &mut String) {
    s.push_str(", мир!");
}

fn main() {
    let mut s = String::from("Привет");
    append(&mut s);
    println!("{}", s);  // Привет, мир!

    // ГЛАВНОЕ ПРАВИЛО:
    // Либо ОДИН &mut, либо много &
    // Но НИКОГДА одновременно &mut и &!

    let r1 = &s;
    let r2 = &s;
    println!("{} и {}", r1, r2);  // OK — два &

    // r1, r2 больше не используются
    let r3 = &mut s;   // OK
    r3.push_str(" Rust!");
    println!("{}", r3);
}

Почему это правило существует?

Двое одновременно читают и пишут один документ: один видит «кошка», другой меняет на «собака» — несоответствие. Это состояние гонки (data race). Rust запрещает это физически на уровне компилятора!

Clone — явное копирование

fn main() {
    let s1 = String::from("привет");
    let s2 = s1.clone();   // явное ГЛУБОКОЕ копирование

    println!("s1={}, s2={}", s1, s2);  // оба работают!
    // clone() дорогая — поэтому явная, не скрытая

    // Типы с trait Copy — копируются автоматически:
    // i32, u32, f64, bool, char, (T1, T2) если T1,T2: Copy
    let x: i32 = 5;
    let y = x;  // копируется, не перемещается
    println!("x={}, y={}", x, y);
}

Висячие ссылки — Rust не допустит!

// fn dangle() -> &String {
//     let s = String::from("привет");
//     &s   // s удаляется! Висячая ссылка!
// }  // error: missing lifetime specifier

// Правильно — передавать владение:
fn no_dangle() -> String {
    let s = String::from("привет");
    s  // OK!
}

fn main() {
    let s = no_dangle();
    println!("{}", s);
}

Lifetimes — кратко

// 'a — параметр lifetime (живёт не дольше чем x и y)
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    for (i, &b) in bytes.iter().enumerate() {
        if b == b' ' { return &s[0..i]; }
    }
    &s[..]
}

fn main() {
    let s1 = String::from("длинная строка");
    let s2 = String::from("xyz");
    let r = longest(s1.as_str(), s2.as_str());
    println!("Длиннее: {}", r);

    let s = "Привет мир Rust";
    println!("Первое слово: {}", first_word(s));
}

Практика: работа со строками

fn word_count(text: &str) -> usize {
    text.split_whitespace().count()
}

fn longest_word<'a>(text: &'a str) -> &'a str {
    text.split_whitespace()
        .max_by_key(|w| w.len())
        .unwrap_or("")
}

fn main() {
    let text = "Rust — самый безопасный язык программирования";
    println!("Слов: {}", word_count(text));
    println!("Длиннейшее: {}", longest_word(text));

    let mut s = String::new();
    s.push_str("Жили-были ");
    s.push_str("три медведя.");
    println!("{}", s);
    println!("{}", s.to_uppercase());
    println!("Оригинал: {}", s);  // s не перемещалась!
}

Типичные ошибки

❌ Использование после move

let s2 = s1;
println!("{}", s1);  // error: borrow of moved value
// Исправление: let s2 = s1.clone();

❌ Два &mut одновременно

let r1 = &mut s;
let r2 = &mut s;  // error: cannot borrow as mutable more than once

Итого

Три правила: один владелец, один одновременно, удаление при выходе из scope.

&T — неизменяемая ссылка. &mut T — изменяемая. Правило: либо один &mut, либо много &.

Move vs Copy: String/Vec — перемещаются. i32/f64/bool/char — копируются. .clone() — явное глубокое копирование.

Дополнительные примеры для практики

Программирование — это навык, который улучшается только с практикой. Вот несколько задач для самостоятельной работы:

Задача 1: Числовые паттерны

fn main() {
    // Выведи пирамиду из звёздочек
    for i in 1..=5 {
        for _ in 0..i { print!("* "); }
        println!();
    }

    // Числа Фибоначчи итеративно (быстрее рекурсии)
    let mut a = 0u64;
    let mut b = 1u64;
    print!("Фибоначчи: ");
    for _ in 0..15 {
        print!("{} ", a);
        let c = a + b;
        a = b;
        b = c;
    }
    println!();

    // Простые числа через решето Эратосфена
    let n = 50usize;
    let mut is_prime = vec![true; n + 1];
    is_prime[0] = false;
    is_prime[1] = false;
    let mut i = 2;
    while i * i <= n {
        if is_prime[i] {
            let mut j = i * i;
            while j <= n {
                is_prime[j] = false;
                j += i;
            }
        }
        i += 1;
    }
    print!("Простые до {}: ", n);
    for k in 2..=n {
        if is_prime[k] { print!("{} ", k); }
    }
    println!();
}

Задача 2: Работа с данными

fn main() {
    let data = vec![
        ("Алиса", 85.0f64),
        ("Боря",  72.0),
        ("Вера",  91.0),
        ("Гриша", 68.0),
        ("Даша",  95.0),
    ];

    // Сортировка по убыванию
    let mut sorted = data.clone();
    sorted.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());

    println!("Топ учеников:");
    for (i, (name, score)) in sorted.iter().enumerate() {
        let medal = match i { 0 => "🥇", 1 => "🥈", 2 => "🥉", _ => "  " };
        println!("{} {} — {:.1}", medal, name, score);
    }

    let avg = data.iter().map(|(_, s)| s).sum::() / data.len() as f64;
    let above: Vec<_> = data.iter().filter(|(_, s)| *s > avg).collect();

    println!("
Средний балл: {:.2}", avg);
    println!("Выше среднего: {}", above.len());
}

Разбор типичных задач

// Палиндром
fn is_palindrome(s: &str) -> bool {
    let chars: Vec = s.chars().collect();
    let n = chars.len();
    for i in 0..n/2 {
        if chars[i] != chars[n-1-i] { return false; }
    }
    true
}

// FizzBuzz
fn fizzbuzz(n: u32) -> String {
    match (n % 3, n % 5) {
        (0, 0) => "FizzBuzz".to_string(),
        (0, _) => "Fizz".to_string(),
        (_, 0) => "Buzz".to_string(),
        _      => n.to_string(),
    }
}

// Подсчёт слов в тексте
fn word_frequencies(text: &str) -> std::collections::HashMap<&str, usize> {
    let mut freq = std::collections::HashMap::new();
    for word in text.split_whitespace() {
        *freq.entry(word).or_insert(0) += 1;
    }
    freq
}

fn main() {
    println!("'racecar' палиндром? {}", is_palindrome("racecar"));
    println!("'hello' палиндром? {}", is_palindrome("hello"));

    for n in 1..=20 { print!("{} ", fizzbuzz(n)); }
    println!();

    let text = "rust rust код код код программирование";
    let freq = word_frequencies(text);
    let mut pairs: Vec<_> = freq.iter().collect();
    pairs.sort_by(|a, b| b.1.cmp(a.1));
    for (word, count) in pairs {
        println!("'{}': {}", word, count);
    }
}