Ownership и Borrowing: понимание модели памяти

1fn main() {
2    let s1 = String::from("hello");
3    let s2 = s1; // s1 перемещено в s2
4
5    // println!("{}", s1); // Ошибка: s1 больше не владеет данными
6    println!("{}", s2); // OK
7}

1fn main() {
2    let s1 = String::from("hello");
3    let s2 = s1.clone(); // Глубокое копирование
4
5    println!("s1 = {}, s2 = {}", s1, s2); // Оба работают
6}

1fn main() {
2    let s = String::from("hello");
3
4    // Можно иметь несколько иммутабельных заимствований
5    let r1 = &s;
6    let r2 = &s;
7    println!("{} and {}", r1, r2);
8}

1fn main() {
2    let mut s = String::from("hello");
3
4    // Можно иметь только одно мутабельное заимствование
5    let r1 = &mut s;
6    r1.push_str(", world");
7    println!("{}", r1);
8}

1fn main() {
2    let mut s = String::from("hello");
3
4    let r1 = &s;      // OK
5    let r2 = &s;      // OK
6    // let r3 = &mut s; // Ошибка: нельзя мутабельно заимствовать при иммутабельных
7
8    println!("{} and {}", r1, r2);
9
10    let r3 = &mut s;  // OK после последнего использования r1 и r2
11    r3.push_str("!");
12}

1// Без lifetime'ов
2fn first_word(s: &str) -> &str {
3    let bytes = s.as_bytes();
4    for (i, &item) in bytes.iter().enumerate() {
5        if item == b' ' {
6            return &s[0..i];
7        }
8    }
9    &s[..]
10}
11
12// С lifetime'ами (явно)
13fn first_word<'a>(s: &'a str) -> &'a str {
14    // ...
15}

1struct ImportantExcerpt<'a> {
2    part: &'a str,
3}
4
5impl<'a> ImportantExcerpt<'a> {
6    fn level(&self) -> i32 {
7        3
8    }
9
10    fn announce_and_return_part(&self, announcement: &str) -> &str {
11        println!("Attention please: {}", announcement);
12        self.part
13    }
14}

1// Это:
2fn first_word(s: &str) -> &str { ... }
3
4// Эквивалентно:
5fn first_word<'a>(s: &'a str) -> &'a str { ... }
6
7// Правила elision:
8// 1. Каждый параметр-заимствование получает свой lifetime
9// 2. Если ровно один входной lifetime, он присваивается всем выходным
10// 3. Если есть &self или &mut self, lifetime self присваивается всем выходным

1// Heap-allocated, owns its data
2let s = String::from("hello");
3let s = "hello".to_string();
4let s = format!("hello {}", "world");

1// Borrowed string slice
2let s: &str = "hello"; // Строковый литерал
3let s: &str = &string[..]; // Срез строки

1fn takes_ownership(s: String) {
2    println!("{}", s);
3} // s уничтожается
4
5fn makes_copy(x: i32) {
6    println!("{}", x);
7} // x копируется
8
9fn main() {
10    let s = String::from("hello");
11    takes_ownership(s); // ownership перемещается
12
13    let x = 5;
14    makes_copy(x); // x копируется, оригинальное значение доступно
15    println!("{}", x); // OK
16}

1fn gives_ownership() -> String {
2    let s = String::from("hello");
3    s // ownership возвращается вызывающему
4}
5
6fn takes_and_gives_back(s: String) -> String {
7    s // ownership возвращается
8}

1let s1 = String::from("hello");
2let s2 = s1;
3// println!("{}", s1); // Ошибка

1let mut s = String::from("hello");
2let r1 = &mut s;
3let r2 = &mut s; // Ошибка

1fn dangle() -> &String { // Ошибка: нет lifetime
2    let s = String::from("hello");
3    &s // s уничтожается, ссылка недействительна
4}

1fn process(data: &Data) {
2    // Если нужно передать владение
3    let data_clone = data.clone();
4    spawn(move || {
5        // Используем data_clone
6    });
7}

1use std::sync::Arc;
2
3let data = Arc::new(vec![1, 2, 3]);
4
5for i in 0..3 {
6    let data = Arc::clone(&data);
7    spawn(move || {
8        println!("{:?}", data);
9    });
10}