Sahiblik, borc götürmə və dilimlər

Sənin bir kitabın var. Onu dostuna bağışlaya bilərsən — onda kitab artıq sənin deyil. Onu bir neçə dosta eyni anda oxumağa verə bilərsən. Ya da onu yalnız bir dosta qeyd yazmağa verə bilərsən — o yazarkən başqa heç kim kitabı oxumamalıdır ki, yarımçıq qeydləri görməsin. Rust yaddaşı məhz bu məntiqlə idarə edir: sahiblik, oxumaq üçün borc və dəyişmək üçün borc.

Stek, heap və sahiblik qaydaları

Ölçüsü əvvəlcədən məlum olan qiymətlər (i32, bool, char) sürətli stekdə saxlanılır. Ölçüsü dəyişə bilən məlumat, məsələn, böyüyən mətn String, heap adlanan dinamik yaddaşda yerləşir: stekdə yalnız göstərici, uzunluq və tutum qalır. Heap-dəki yaddaşı kimsə azad etməlidir — Rust-da bu, sahibin işidir.

1. Rust-da hər qiymətin bir sahibi var — onu saxlayan dəyişən.
2. Eyni anda yalnız bir sahib ola bilər.
3. Sahib görünmə sahəsindən ({ } blokundan) çıxanda qiymət avtomatik silinir (drop) və yaddaş azad olunur.

Ötürmə (move), klonlama və Copy

let s2 = s1; yazanda String-in heap-dəki məzmunu kopyalanmır — sahiblik s1-dən s2-yə ötürülür (move). Əgər hər ikisi sahib olsaydı, blok bitəndə eyni yaddaşı iki dəfə azad edərdilər. Buna görə Rust s1-i etibarsız sayır və ondan istifadəni qadağan edir. Həqiqətən ikinci surət lazımdırsa, .clone() çağır.

fn main() {
    let s1 = String::from("Baku");
    let s2 = s1;
    println!("{s1} {s2}");
}

fn main() {
    let s1 = String::from("Baku");
    let s2 = s1.clone();
    println!("{s1} {s2}");
}

error[E0382]: borrow of moved value: `s1`
 --> src/main.rs:4:15
  |
2 |     let s1 = String::from("Baku");
  |         -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait
3 |     let s2 = s1;
  |              -- value moved here
4 |     println!("{s1} {s2}");
  |               ^^^^ value borrowed here after move

Tam ədədlər, kəsr ədədlər, bool, char və yalnız onlardan ibarət kortejlər Copy tiplərdir: onlar bütövlüklə stekdə yaşayır və surət çıxarmaq ucuzdur. Belə qiymətlər ötürülmür, surəti çıxarılır — let b = a;-dan sonra hər iki dəyişən işləkdir. Funksiyaya arqument vermək də eyni qaydaya tabedir:

fn take(text: String) {
    println!("took: {text}");
}

fn show(n: i32) {
    println!("copied: {n}");
}

fn main() {
    let city = String::from("Ganja");
    take(city);
    // println!("{city}"); // error E0382: city was moved

    let year = 2024;
    show(year);
    println!("still have: {year}");
}

took: Ganja
copied: 2024
still have: 2024

İstinadlar və borc götürmə

Hər dəfə sahibliyi verib geri almaq yorucudur. Bunun əvəzinə qiyməti borc vermək olar: &name sahibliyi götürməyən istinad yaradır. Funksiya istinadla qiyməti oxuyur, iş bitəndə isə sahib dəyişmir. Qiyməti dəyişmək üçün dəyişən istinad &mut lazımdır — bunun üçün dəyişənin özü də mut olmalıdır.

fn length(text: &String) -> usize {
    text.len()
}

fn add_suffix(text: &mut String) {
    text.push_str(" city");
}

fn main() {
    let mut name = String::from("Baku");
    let len = length(&name);
    println!("{name} has {len} letters");

    add_suffix(&mut name);
    println!("{name}");
}

Baku has 4 letters
Baku city

fn main() {
    let mut s = String::from("hi");
    let r1 = &mut s;
    let r2 = &mut s;
    r1.push('!');
    r2.push('?');
    println!("{s}");
}

fn main() {
    let mut s = String::from("hi");
    let r1 = &mut s;
    r1.push('!');
    let r2 = &mut s;
    r2.push('?');
    println!("{s}");
}

fn main() {
    let mut scores = vec![90, 85];
    let first = &scores[0];
    scores.push(70);
    println!("{first}");
}

fn main() {
    let mut scores = vec![90, 85];
    let first = scores[0];
    scores.push(70);
    println!("{first}");
}

error[E0502]: cannot borrow `scores` as mutable because it is also borrowed as immutable
 --> src/main.rs:4:5
  |
3 |     let first = &scores[0];
  |                  ------ immutable borrow occurs here
4 |     scores.push(70);
  |     ^^^^^^^^^^^^^^^ mutable borrow occurs here
5 |     println!("{first}");
  |               ------- immutable borrow later used here

Dilimlər: String və &str

Dilim (slice) kolleksiyanın bir hissəsinə istinaddır: &numbers[1..4] 1, 2 və 3 indeksli elementləri göstərir. Mətn dilimi &str tipindədir. Proqramdakı hər mətn literalı ("hello") da &str-dir: o, proqram faylının içindəki mətnə baxan istinaddır. String isə öz məlumatının sahibidir, heap-də yaşayır və böyüyə bilər.

fn first_word(text: &str) -> &str {
    for (i, ch) in text.char_indices() {
        if ch == ' ' {
            return &text[..i];
        }
    }
    text
}

fn main() {
    let sentence = String::from("hello brave world");
    let word = first_word(&sentence);
    println!("{word}");
    println!("{}", first_word("Rust"));

    let numbers = [10, 20, 30, 40, 50];
    let middle = &numbers[1..4];
    println!("{:?} len={}", middle, middle.len());
}

hello
Rust
[20, 30, 40] len=3