Rc в Rust: Разделённое владение, циклические ссылки и Weak

 1// ?compile_fail
 2#[derive(Debug)]
 3struct City {
 4    name: String,
 5    history: String,
 6}
 7
 8#[derive(Debug)]
 9struct CitySummary {
10    headline: String,
11    description: String,
12}
13
14fn main() {
15    let history = String::from("Город основан в 1574 году");
16
17    let city = City {
18        name: String::from("Уфа"),
19        history: history,
20    };
21
22    let summary = CitySummary {
23        headline: String::from("Уфа"),
24        description: history, // ❌ перемещено из-под city
25    };
26
27    println!("{:?}, {:?}", city, summary);
28}

 1use std::rc::Rc;
 2
 3#[derive(Debug)]
 4struct City {
 5    name: Rc<String>,
 6    history: Rc<String>,
 7}
 8
 9#[derive(Debug)]
10struct CitySummary {
11    headline: Rc<String>,
12    description: Rc<String>,
13}
14
15fn main() {
16    let name = Rc::new(String::from("Уфа"));
17    let history = Rc::new(String::from("Основан в 1574 году"));
18
19    let city = City {
20        name: Rc::clone(&name),
21        history: Rc::clone(&history),
22    };
23
24    let summary = CitySummary {
25        headline: Rc::clone(&name),
26        description: Rc::clone(&history),
27    };
28
29    println!("Город: {:?} Сводка: {:?}", city, summary);
30    println!("Ссылок на описание: {}", Rc::strong_count(&history));
31}
32

 1use std::rc::Rc;
 2use std::cell::RefCell;
 3
 4fn main() {
 5    let users = Rc::new(RefCell::new(vec!["Алиса".to_string()]));
 6
 7    let session1 = Rc::clone(&users);
 8    let session2 = Rc::clone(&users);
 9
10    session1.borrow_mut().push("Макс".to_string());
11    session2.borrow_mut().push("Петр".to_string());
12
13    println!("Онлайн: {:?}", users.borrow());
14}

 1// ?should_panic
 2#[allow(unused_variables)]
 3use std::rc::Rc;
 4use std::cell::RefCell;
 5
 6fn main() {
 7    let shared = Rc::new(RefCell::new(vec![1, 2, 3]));
 8
 9    let _first = shared.borrow_mut();
10    let _second = shared.borrow_mut(); // ❌ паника: уже есть активный borrow_mut
11}
12

 1#[allow(unused_variables)]
 2use std::rc::Rc;
 3use std::cell::RefCell;
 4fn main() {
 5    let shared = Rc::new(RefCell::new(vec![1, 2, 3]));
 6
 7    {
 8        let mut data = shared.borrow_mut();
 9        data.push(4);
10    }
11
12    let again = shared.borrow_mut();
13    println!("{:?}", again);
14}

 1use std::cell::RefCell;
 2use std::rc::{Rc, Weak};
 3
 4#[derive(Default)]
 5struct Node {
 6    name: String,
 7    next: Option<Rc<RefCell<Node>>>,
 8}
 9
10impl Drop for Node {
11    fn drop(&mut self) {
12        println!("Деструктор узла '{}' вызван!", self.name);
13    }
14}
15
16fn main() {
17    println!("--- Демонстрация сильных ссылок ---");
18    let first = Rc::new(RefCell::new(Node {
19        name: "Узел А".to_string(),
20        next: None,
21    }));
22    
23    let second = Rc::new(RefCell::new(Node {
24        name: "Узел Б".to_string(),
25        next: None,
26    }));
27
28    println!("Сильные ссылки 'first': {}", Rc::strong_count(&first));
29    println!("Сильные ссылки 'second': {}", Rc::strong_count(&second));
30    
31    // Связываем узел А -> узел Б
32    first.borrow_mut().next = Some(Rc::clone(&second));
33    println!("После связывания 'second' strong_count: {}", Rc::strong_count(&second));
34}
35

 1use std::cell::RefCell;
 2use std::rc::{Rc, Weak};
 3
 4struct Gadget {
 5    id: String,
 6    owner: Option<Weak<Owner>>, // Ослабленная ссылка на владельца предотвращает циклический вызов Drop!
 7}
 8
 9struct Owner {
10    name: String,
11    gadgets: RefCell<Vec<Rc<RefCell<Gadget>>>>,
12}
13
14impl Drop for Gadget {
15    fn drop(&mut self) {
16        println!("Устройство '{}' удалено из памяти", self.id);
17    }
18}
19
20impl Drop for Owner {
21    fn drop(&mut self) {
22        println!("Владелец '{}' удален из памяти", self.name);
23    }
24}
25
26fn main() {
27    println!("--- Безопасная связь через Weak ---");
28    
29    let owner = Rc::new(Owner {
30        name: "Алексей".to_string(),
31        gadgets: RefCell::new(Vec::new()),
32    });
33
34    let gadget = Rc::new(RefCell::new(Gadget {
35        id: "Смартфон".to_string(),
36        owner: Some(Rc::downgrade(&owner)), // Создаем ослабленную ссылку Weak<Owner>
37    }));
38
39    owner.gadgets.borrow_mut().push(Rc::clone(&gadget));
40
41    println!("Сильные ссылки владельца: {}", Rc::strong_count(&owner));
42    println!("Слабые ссылки владельца: {}", Rc::weak_count(&owner));
43
44    // Для обращения к владельцу из устройства используем upgrade():
45    if let Some(ref weak_owner) = gadget.borrow().owner {
46        if let Some(upgraded_owner) = weak_owner.upgrade() {
47            println!("Устройство принадлежит владельцу: {}", upgraded_owner.name);
48        }
49    }
50}
51