在Rust中，如何避免借用冲突和悬垂指针的问题

let mut s = String::from("hello");
let r1 = &s;        // 不可变借用开始
let r2 = &mut s;    // ❌ error[E0502]: cannot borrow `s` as mutable
println!("{}", r1); // 编译器发现 r1 后续还被使用

let mut s = String::from("hello");
{
    let r1 = &s;
    println!("{}", r1);
}                   // r1 在此处失效
let r2 = &mut s;    // ✅ 现在可以可变借用

// 返回的 &str 生命周期与 x 和 y 中较短者一致
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

let s1 = String::from("long");
{
    let s2 = String::from("x");
    let result = longest(&s1, &s2); // result 的生命周期受限于 s2 的作用域
    println!("{}", result);
} // s2 离开作用域，result 在此之后不可再用

use std::cell::RefCell;

struct Node {
    value: i32,
    children: RefCell<Vec<Rc<Node>>>,
}

let node = Rc::new(Node { value: 1, children: RefCell::new(vec![]) });
node.children.borrow_mut().push(Rc::clone(&node)); // 运行时检查通过即可修改

use std::pin::Pin;
use std::marker::PhantomPinned;

struct SelfReferential {
    data: String,
    pointer_to_data: *const String,
    _pin: PhantomPinned,  // 禁止隐式 Unpin
}

impl SelfReferential {
    fn new(data: String) -> Pin<Box<Self>> {
        let mut boxed = Box::pin(Self {
            data,
            pointer_to_data: std::ptr::null(),
            _pin: PhantomPinned,
        });
        let ptr: *const String = &boxed.data;
        unsafe {
            let mut_ref: Pin<&mut Self> = Pin::as_mut(&mut boxed);
            Pin::get_unchecked_mut(mut_ref).pointer_to_data = ptr;
        }
        boxed
    }

    fn data_pointer(&self) -> &String {
        unsafe { &*self.pointer_to_data }
    }
}

use std::rc::{Rc, Weak};
use std::cell::RefCell;

struct Node {
    value: i32,
    parent: RefCell<Weak<Node>>,   // 向上用弱引用
    children: RefCell<Vec<Rc<Node>>>, // 向下用强引用
}

let leaf = Rc::new(Node { value: 3, parent: RefCell::new(Weak::new()), children: RefCell::new(vec![]) });
let branch = Rc::new(Node { value: 5, parent: RefCell::new(Weak::new()), children: RefCell::new(vec![Rc::clone(&leaf)]) });

*leaf.parent.borrow_mut() = Rc::downgrade(&branch); // ✅ Weak 不增加引用计数

// branch 离开作用域后，leaf.parent 自动变为无效（upgrade() 返回 None）

/// 安全封装：将原始指针转换为引用
pub fn as_ref<T>(ptr: *const T) -> Option<&T> {
    if ptr.is_null() {
        None
    } else {
        // 调用者必须已保证指针有效且生命周期合理
        Some(unsafe { &*ptr })
    }
}

use std::rc::Rc;
use std::cell::RefCell;

fn main() {
    let mut data = Rc::new(RefCell::new(10));

    {
        let borrowed1 = Rc::clone(&data);
        let _borrowed2 = &*borrowed1.borrow();
    }

    println!("Value: {}", *data.borrow());
}

fn use_data(data: &Rc<RefCell<i32>) {
    let _value = data.borrow();
}