advance/smart-pointer/cell-refcell

[sunface]

https://course.rs/advance/smart-pointer/cell-refcell.html

[lam2018]

我很善变，还拥有多个主人 我被这里的代码示例笑喷了，真形像。

[FlorentinoJink]

给一个Chatgpt的示例，看下就明白了

use std::cell::RefCell;

// 定义银行结构体
struct Bank {
    // 使用RefCell存储余额，因为余额是内部可变的
    balance: RefCell<i32>,
}

impl Bank {
    // 创建一个新的银行对象
    fn new() -> Bank {
        // 初始化余额为0
        Bank { balance: RefCell::new(0) }
    }

    // 存款
    fn deposit(&self, amount: i32) {
        // 获取内部可变引用
        let mut balance = self.balance.borrow_mut();
        // 修改余额
        *balance += amount;
    }

    // 取款
    fn withdraw(&self, amount: i32) -> bool {
        // 获取内部可变引用
        let mut balance = self.balance.borrow_mut();
        // 如果余额充足，则修改余额并返回true
        if *balance >= amount {
            *balance -= amount;
            true
        // 否则返回false
        } else {
            false
        }
    }
}

fn main() {
    // 创建一个新的银行
    let bank = Bank::new();
    // 存款100元
    bank.deposit(100);
    // 取款50元，余额应该是50元
    assert!(bank.withdraw(50));
    assert_eq!(*bank.balance.borrow(), 50);
}

[lihongtao1024]

这个场景使用RefCell性能不高。i32实现了Copy，可以直接使用cell，没有额外的性能损耗。

[itfanr]

use std::cell::Cell;

// 定义银行结构体
struct Bank {
    // 使用Cell存储余额，因为余额是内部可变的
    balance: Cell<i32>,
}

impl Bank {
    // 创建一个新的银行对象
    fn new() -> Bank {
        // 初始化余额为0
        Bank {
            balance: Cell::new(0),
        }
    }

    // 存款
    fn deposit(&self, amount: i32) {
        // 修改余额
        self.balance.set(self.balance.get() + amount);
    }

    // 取款
    fn withdraw(&self, amount: i32) -> bool {
        // 如果余额充足，则修改余额并返回true
        if self.balance.get() >= amount {
            self.balance.set(self.balance.get() - amount);
            true
        // 否则返回false
        } else {
            false
        }
    }
}

fn main() {
    // 创建一个新的银行
    let bank = Bank::new();
    // 存款100元
    bank.deposit(100);
    // 取款50元，余额应该是50元
    assert!(bank.withdraw(50));
    assert_eq!(bank.balance.get(), 50);
}

[TsGanT]

我寻思理论上 其实直接 &mut self 就可以了对吧？

struct Bank {
    balance: i32
}
impl Bank {
    fn new(b: i32) -> Bank {
        Bank { balance: b }
    }
    fn withdraw (&mut self, amout: i32) {
        let b = self.balance - amout;
        self.balance = b;
    }
    fn save(&mut self, amout: i32) {
        self.balance = self.balance + amout;
    }
}
fn main() {
    let mut b = Bank::new(100);
    b.withdraw(50);
    println!("You now have: {}", b.balance);
    b.save(100);
    println!("U now have: {}", b.balance);
}
// 或者如果说Cell的好处，那其实还是比强行在结构体里使用 可变引用+生命周期舒服？
struct Bank<'a> {
    balance: &'a mut i32
}
impl<'a> Bank<'a> {
    fn new(b: &'a mut i32) -> Bank<'a> {
        Bank { balance: b }
    }
    fn withdraw (&mut self, amout: i32) {
        *self.balance = *self.balance - amout;
    }
    fn save(&mut self, amout: i32) {
        *self.balance = *self.balance + amout;
    }
}
fn main() {
    let mut balance_init = 100;
    let mut b = Bank::new(&mut balance_init);
    b.withdraw(50);
    println!("You now have: {}", b.balance);
    b.save(100);
    println!("U now have: {}", b.balance);
}

[marxlee]

这个是不是因为线程安全才会考虑 rc+cell的模式呢

[sunface]

我很善变，还拥有多个主人 我被这里的代码示例笑喷了，真形像。

但我代表它( RefCell )给你的赞绝对始终如一 :P

[Rustln]

由于 Rust 的 mutable 特性，一个结构体中的字段，要么全都是 immutable，要么全部是 mutable，不支持针对部分字段进行设置。比如，在一个 struct 中，可能只有个别的字段需要修改，而其他字段并不需要修改，为了一个字段而将整个 struct 变为 &mut 也是不合理的。

所以，实现 内部可变性 的 Cell 和 RefCell 正是为了解决诸如这类问题存在的，通过它们可以实现 struct 部分字段可变，而不用将整个 struct 设置为 mutable。

[lihongtao1024]

确实如此，大部分的情况下一个struct只有个别field需要可变。

[itfanr]

实际上就是封装，可变成员的在结构体的内部逻辑使用。

[TsGanT]

说的太好了，没有必要为了结构体里的一个字段的可变性，而使用mut self导致所有的字段都一起可变！

[h2222]

上面那句话的实际例子

fn main() {

    #[allow(dead_code)]
    #[derive(Debug)]
    struct  AAA<'a> {
        x: String,
        y: &'a str
    }

    #[allow(dead_code)]
    #[derive(Debug)]
    struct  BBB<'a> {
        x: RefCell<String>,
        y: &'a str
    }

    let aaa = AAA{x: "需要替换掉".to_string(), y: "不需要替换"};
    // 这里, 因为 aaa 是 immutable 的, 因此无法对 x 进行替换
    // x 需要替换, y 不需要替换, 因此如果为 x 将 aaa 设置为mut是不合理的
    // aaa.x = "aaaa"; // 报错: cannot mutate immutable variable `aaa`
    println!("aaa: {:?}", aaa);

    // 因此我们可以采用 RefCell 将 x 作为 RefCell 指针, 这样我们就可以只对 x指向的数据进行修改, 而不改变aaa的可变性了
    let bbb = BBB{x: RefCell::new("需要替换掉".to_string()), y: "不需要替换"};
    *bbb.x.borrow_mut() = "bbbb".to_string();
    println!("bbb: {:?}", bbb);

}

[Levio-z]

考虑直接将这段评论提交到正文里吗，早看到这句话，我感觉我不用花20分钟时间去查资料理解了

[einQimiaozi]

关于rc和refcell联合使用的例子在我本地的环境下无法运行，错误信息如下

error[E0599]: no method named `push_str` found for mutable reference `&mut Rc<RefCell<String>>` in the current scope
  --> src/main.rs:68:21
   |
68 |     s2.borrow_mut().push_str(", on yeah!");
   |                     ^^^^^^^^ method not found in `&mut Rc<RefCell<String>>`

请问是什么原因导致的呢？我的本地版本如下

rustc 1.61.0-nightly (76d770ac2 2022-04-02)

[Rustln]

不应该是 &s2.borrow_mut() 么。。。

[einQimiaozi]

又试了一下，确实是类型推断的问题，在我的mac上必须手动解引用

let ss:&RefCell<String> = &s2;
let mut res = ss.borrow_mut();
res.push_str(", on yeah!");

这样res才能是RefMut类型，但是同样的代码在linux上就没问题，rust环境版本都一样，可能是rust在mac上的的bug？

[Rustln]

没这回事呀，您之前的代码本身就需要解引用一次才是对的，因为智能指针都是 newtype 类型，所以需要解引用一次才能获取到实际的值，目前我在 windows 11 和 mac m1 上都没问题哦。

[einQimiaozi]

我也不太清楚.....在我的mac上s2.borrow_mut()后会被编译器推断为&mut Rc<RefCell>类型，但是手动解引用就可以变成RefMut类型，在linux上就没问题......

[lijing-2008]

borrow_mut使用的库不对，估计你用的是use std::borrow::BorrowMut;把这个use去掉就好了，使用RefCell中的borrow_mut。

[zwq1792966796]

Cell 指针存放在栈上？

[greyhawk]

指针都在栈上啊

[TsGanT]

这不一定呀 比如 Vec[Box::new(0), Box::new(1)] 这样的，Vec本身就是返回一个指针，其内容存在堆上，因此Box返回的指针就是存在 Vec指针指向的堆中；

[TsGanT]

不对 说错了 Vec[Cell::new(0), Cell::new(1)]

[wuhaiji]

感觉最后一个例子遍历集合的同时修改集合，容易出bug

    fn is_even(i: &i32) -> bool {
        i % 2 == 0
    }

    fn retain_even(nums: &mut Vec<i32>) {
        let mut vec: Vec<i32> = nums
            .iter()
            .filter(|num| is_even(num))
            .copied()
            .collect();
        nums.clear();
        nums.append(&mut vec);
    }

[duanyuluo]

最爱这种风格～用下标太容易出问题

[googya]

直接这样更简单了

    nums.retain(|num| is_even(*num));

[Ryu2u]

对于Rc+RefCell组合的问题，这两种情况为什么打印的不一样?

    #[test]
    fn test_rc_RefCell(){
        let s1 = Rc::new(RefCell::new(String::from("test")));
        let s2 = Rc::clone(&s1);
        
        // let mut s3 = s2.borrow_mut();
        // s3.push_str(" rc+refCell");

        s2.borrow_mut().push_str(" rc+refCell");

        println!("{:?}", s2);
        println!("{:?}", s1);
    }

这样直接打印是可以打印出来的，但是如果使用了s3就打印不出来
是这样

RefCell { value: <borrowed> }
RefCell { value: <borrowed> }

[Takumi-wake]

s1和s2被s3借用，这里s3的作用域一直到下面大括号，所以打印为

RefCell { value: <borrowed> }
RefCell { value: <borrowed> }

可以尝试将s3的处理使用{}括起来，就可以得到同样的结果了，即如下所示

#[test]
    fn test_rc_RefCell(){
        let s1 = Rc::new(RefCell::new(String::from("test")));
        let s2 = Rc::clone(&s1);
        
       {
            let mut s3 = s2.borrow_mut();
            s3.push_str(" rc+refCell");     // s3在大括号后被释放
        }

        // s2.borrow_mut().push_str(" rc+refCell");

        println!("{:?}", s2);
        println!("{:?}", s1);
    }

[woodrow-wong]

我的理解是，你的s3本质上是对s2的可变借用，并没有像s1和s2那样“共同拥有”对字符串的所有权；所以当s3这个可变借用本身还存活时，从这个变量的所有者来看，自然是值被借用的状态（个人理解）

[zleihao]

好像是因为Debug trait里面使用了不可变借用，如果使用s3的话，s3在这里是一个可变借用，s3是在main函数结束后才会drop，此时对于s2来说同时存在了可变借用和不可变借用。解决办法的话就是用{}把s3包括起来，在调用println! 把s3 Drop掉。

[zwq1792966796]

那是因为s2的借用转给了s3，s3的作用域到最后的括号，所以s1，s2 是borrowed

…

------------------&nbsp;原始邮件&nbsp;------------------ 发件人: ***@***.***&gt;; 发送时间: 2023年1月2日(星期一) 晚上9:19 收件人: ***@***.***&gt;; 抄送: ***@***.***&gt;; ***@***.***&gt;; 主题: Re: [sunface/rust-course] advance/smart-pointer/cell-refcell (Discussion #617) 对于Rc+RefCell组合的问题，这两种情况为什么打印的不一样? #[test] fn test_rc_RefCell(){ let s1 = Rc::new(RefCell::new(String::from("test"))); let s2 = Rc::clone(&amp;s1); // let mut s3 = s2.borrow_mut(); // s3.push_str(" rc+refCell"); s2.borrow_mut().push_str(" rc+refCell"); println!("{:?}", s2); println!("{:?}", s1); } 这样直接打印是可以打印出来的，但是如果使用了s3就打印不出来 是这样 RefCell { value: <borrowed&gt; } RefCell { value: <borrowed&gt; } — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you commented.Message ID: ***@***.***&gt;

[loheagn]

提一个不成熟的观点。虽然 Cell 和 RefCell 看起来可以破坏Rust的借用和可变不可变的规则，但事实上，我们如果把它们和“纯粹”的变量和变量引用放到一起理解会造成困扰。而如果仅仅把它们看做是一种特殊的“容器”，把它们的特性理解为语言核心之外的一种“外部库函数”，这样理解起来就非常清晰了。

[taurus-prog]

现在版本 Cell::new是可以生成值。只是某些方法要求T:Copy

[fenixc9]

“Cell 和 RefCell 在功能上没有区别，区别在于 Cell 适用于 T 实现 Copy 的情况："

现在对于非Copy的类型也可以replace或者swap了

[CedricYin]

  let c = Cell::new("asdf");
  let one = c.get();
  c.set("qwer");
  let two = c.get();
  println!("{},{}", one, two);

为啥 c前面不加mut，c.set可以编译通过？

[lihongtao1024]

前面已经讲了啊，内部可变。
使用了Cell或RefCell就可以让一个不可变通过它成为可变。同时借用检查从编译时延迟到了运行时。
其实这俩底层都是对UnsafeCell的封装，底层用的unsafe代码，api封装成了safe。

[ivicel]

Cell 和 RefCell 在功能上没有区别，区别在于 Cell 适用于 T 实现 Copy 的情况

Cell 对 T 的约束只有 ?Sized, 所以 Cell 是可以的

let c = Cell::new(String::from("asdf"));

这里并不会报错, 除非调用 Cell::get , 因为对 get 是 impl<T> Cell<T> where T: Copy
https://doc.rust-lang.org/stable/std/cell/struct.Cell.html#impl-Cell%3CT%3E-1

[tanshion]

看起来下面第2，3种写法有安全问题，实际会用这样的写法吗

{
       #[derive(Debug, Clone, Copy)]
       pub struct Foo {
           a: u32,
       }
       let x = Cell::new(Foo { a: 12 });
       let y = &x;
       let z = &x;
       x.set(Foo { a: 13 });
       y.set(Foo { a: 14 });
       print!("{:?}", y.get());
       print!("{:?}", x.get());
       print!("{:?}", z.get());
   }

   {
       #[derive(Debug)]
       pub struct Foo {
           a: u32,
       }
       let x = Cell::new(&Foo { a: 12 });
       let y = &x;
       let z = &x;
       x.set(&Foo { a: 13 });
       y.set(&Foo { a: 14 });
       print!("{:?}", x.get());
       print!("{:?}", y.get());
       print!("{:?}", z.get());
   }

   {
       #[derive(Debug)]
       pub struct Foo {
           a: u32,
       }
       let x = Rc::new(RefCell::new(Foo { a: 12 }));
       let y = Rc::clone(&x);
       let z = Rc::clone(&x);

       // 在 Mutex 中进行修改
       *x.borrow_mut() = Foo { a: 13 };

       *y.borrow_mut() = Foo { a: 14 };

       // 在 Mutex 中获取值
       let x_value = x.borrow();
       let y_value = y.borrow();
       let z_value = z.borrow();

       println!("{:?}", *x_value);
       println!("{:?}", *y_value);
       println!("{:?}", *z_value);
   }

[tanshion]

chatapt的答案：

在rust的实际应用中会使用Cell 存储引用吗
ChatGPT
在 Rust 的实际应用中，通常不会使用 Cell 来存储引用，因为 Rust 提供了更安全和更灵活的方式来处理可变性和引用。 Cell 主要用于在特定情况下实现内部可变性，例如在具有不可变引用的情况下修改引用的目标对象，但这通常不是常见的用例。

在 Rust 中，通常会使用以下方法来处理可变性和引用：

可变引用 (&mut T)： Rust 允许使用可变引用来修改数据。这是最常见的方式，适用于大多数情况。

RefCell： 如果需要在具有不可变引用的情况下修改数据，可以使用 RefCell。 RefCell 允许在运行时检查借用规则，并在需要时允许修改数据。这在某些特殊情况下很有用，但要小心处理可能导致运行时 panic 的情况。

Mutex 和 RwLock： 如果需要在多线程环境中处理共享可变数据，可以使用 Mutex 或 RwLock 来实现线程安全的可变性。

Cell 和 RefCell 的引用计数版本： 如果需要在多个所有者之间共享可变数据，可以考虑使用 Rc + Cell 或 Rc + RefCell。这种情况下， Rc 用于引用计数，Cell 或 RefCell 用于内部可变性。

总之，在 Rust 中，Cell 主要用于特殊情况，通常不是常见的数据管理工具。大多数情况下，你可以使用可变引用、RefCell 或其他 Rust 提供的工具来更安全地处理可变性和引用。

[yuliang0225]

是艾丽

[DaZhou-ECHO]

对于let c =Cell::new(String::from("wadad"));这一行，编译器没有报错，推测是因为Rust的惰性初始化，而且第二行把第一行的c给覆盖了，所以后续没有报错
不知道大家怎么看
use std::cell::Cell;
fn main(){
//Cell里面不能存放String,因为String没有实现Copy特征
//但是这里没有报错,推测是因为惰性初始化
let c =Cell::new(String::from("wadad"));
//"asda"为&str类型,实现了Copy特征
let c = Cell::new("awda");
let one =c.get();
c.set("awdaw");
let two = c.get();
println!("{} , {}",one,two);
}

[Endermanbugzjfc]

请留意上面的评论

[Lixuhuilll]

第一个例子中，有没有 Cell 不是一样吗

fn main() {
    let mut c = "asdf";
    let one = c;
    c = "qwer";
    let two = c;
    println!("{},{}", one, two);
}

[glaceglace]

不一样的， 你的代码c在最后把所有权移交给了two，就不能再调用变量c了。但是第一个例子里面后面还能继续使用c.get()获取和two一样的值

use std::cell::Cell;
fn main() {
    let c = Cell::new("asdf");
    println!("c addr is {:X}", c.as_ptr() as usize);
    let one = c.get();
    println!("one addr is {:X}", one.as_ptr() as usize);
    println!("c addr is {:X}", c.as_ptr() as usize);
    c.set("qwer");
    println!("c addr is {:X}", c.as_ptr() as usize);
    let two = c.get();
    println!("one addr is {:X}", one.as_ptr() as usize);
    println!("two addr is {:X}", two.as_ptr() as usize);
    println!("c addr is {:X}", c.as_ptr() as usize);
    let three = c.get();
    println!("c addr is {:X}", c.as_ptr() as usize);
    println!("one addr is {:X}", one.as_ptr() as usize);
    println!("two addr is {:X}", two.as_ptr() as usize);
    println!("three addr is {:X}", three.as_ptr() as usize);
    println!("{},{},{}", one, two,three);
}

[Endermanbugzjfc]

读完 只被调用一次的函数 @ 4.6.2 才发现 Cell 可以让 unsafe 的可变静态全局变量变成 safe：

因为允許了中斷，所以不存在真正的單線程程式碼。

Cell 确保了不同步（!Sync）的基本類型可變性，（这意味著它会明確阻止多線程訪問）。

https://stackoverflow.com/a/72369696

[vince-1998]

use std::cell::RefCell;
use std::rc::Rc;
fn main() {
let s = Rc::new(RefCell::new("我很善变，还拥有多个主人".to_string()));

let s1 = s.clone();
let s2 = s.clone();
// let mut s2 = s.borrow_mut();
s2.borrow_mut().push_str(", oh yeah!");

println!("{:?}\n{:?}\n{:?}", s, s1, s2);

}

我觉得这个例子举的不够好，因为之前说了RefCell只是避免了编译器的可变和不可变的冲突，但是运行时会检查的。然后我修改了一下代码
fn main() {
let s = Rc::new(RefCell::new("我很善变，还拥有多个主人".to_string()));

let s1 = s.clone();
let s2 = s.clone();
// let mut s2 = s.borrow_mut();
s2.borrow_mut().push_str(", oh yeah!");
// let a3 = s2.borrow_mut();
let s3 = s1.borrow();

println!("{:?}\n{:?}\n{:?}\n{:?}", s, s1, s2, s3);

}
上面这段其实是能编译并运行通过的，但是其实这里并没有发生可变和不可变的同时存在，因为 s2.borrow_mut().push_str(", oh yeah!");借完马上释放了

[rtpacks]

RefCell 关注点在为一个无论是否可变的类型（变量/值），对外提供该类型的不可变引用和可变引用，这里是 unsafe 的实现，不受借用规则限制。
而接收不可变引用和可变引用的变量不属于 RefCell 的关注点，它们依然要符合借用规则，以保证 RefCell 智能指针的正常运行。

[Ucag]

有一个问题, 如何在下面的代码中调用 cache 方法?

struct MsgQueue {
    msg_cache: std::cell::RefCell<Vec<String>>,
    // msg_cache: &'a mut Vec<String>
}
// impl<'a> MsgQueue<'a> {
impl MsgQueue {
    fn cache(&mut self, s: String)
    {
        self.msg_cache.borrow_mut().push(s);
    }
}

impl Messenger for MsgQueue {
    fn send(&self, msg: String) {
       // 这样写是错误的 self.cache(msg);
    }
}

而且发现 RefCell 一个不好用的地方, 在本来的可变引用函数中, 也必须 borrow 了, 有什么更好的方法吗?

[Justinlaau]

但是refcell 本來用處是 讓部分字段 可以修改，但對外提供 不可修改的引用。你沒有必要 定義cache 為 &mut self, 直接 &self 就行了，不是嗎？

[Anthony-Dong]

只能说 兜兜转转 回到了 c++，没有所谓的安全，只有相对安全，通过编译器解决内存安全不是银弹，更多的还是理解内存管理和如何安全的操作内存！

[sosotan]

感觉RefCell和写unsafe没太大差别

[xiaguangbo]

use std::borrow::BorrowMut; // if add this, will err
use std::cell::RefCell;
use std::rc::Rc;
fn main() {
    let s = Rc::new(RefCell::new("我很善变，还拥有多个主人".to_string()));

    let s1 = s.clone();
    let s2 = s.clone();
    // let mut s2 = s.borrow_mut();
    s2.borrow_mut().push_str(", oh yeah!");

    println!("{:?}\n{:?}\n{:?}", s, s1, s2);
}

[wangmj]

手写了一个refcell的例子
Y1S1，RUST写起来好难。

use std::{cell::RefCell, fmt::Display, rc::Rc};

/*
本例着重实现 refcell的使用。
场景说明：家庭中有个小朋友，小朋友上学属于某一个班级，家庭给小朋友改名字，班级中的小朋友的名字也修改了
 */
fn main() {
    let mut family = Family::new();
    let mut class = Class::new();
    class.recruit(family.kid.clone());
    println!("{}", class);
    family.modify_kid_name("小丽");
    println!("{}", class);
}
struct SmallFirend {
    pub name: String,
    age: u8,
}
struct Family {
    kid: Rc<RefCell<SmallFirend>>,
}
impl Family {
    fn new() -> Self {
        let kid = SmallFirend {
            name: "小花".to_string(),
            age: 6,
        };
        Self {
            kid: Rc::new(RefCell::new(kid)),
        }
    }
    fn modify_kid_name(&mut self, new_name: &str) {
        let oldname = self.kid.borrow().name.clone();
        self.kid.borrow_mut().name = new_name.to_string();
        println!(" “{}” 改名字 叫 “{}” 啦", oldname, new_name);
    }
}
struct Class {
    students: Vec<Rc<RefCell<SmallFirend>>>,
}
impl Display for Class {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        for stu in &self.students {
            write!(
                f,
                "学生姓名：{},学生年龄：{}",
                stu.borrow().name,
                stu.borrow().age
            )?;
        }
        Ok(())
    }
}

impl Class {
    fn new() -> Self {
        Self {
            students: Vec::new(),
        }
    }
    fn recruit(&mut self, student: Rc<RefCell<SmallFirend>>) {
        self.students.push(student);
    }
}

[cctga]

fn is_even(i: i32) -> bool {
    i % 2 == 0
}

fn retain_even(nums: &mut Vec<i32>) {
    let mut i = 0;
    for num in nums.iter().filter(|&num| is_even(*num)) {
        nums[i] = *num;
        i += 1;
    }
    nums.truncate(i);
}

这个代码报错我认为更确切的说法是使用了以修改的不可变引用，迭代器是不可变的

[xwlcn]

人生无常，大肠包小肠。。
看到这代码：

use std::cell::Cell;

fn retain_even(nums: &mut Vec<i32>) {
    let slice: &[Cell<i32>] = Cell::from_mut(&mut nums[..])
        .as_slice_of_cells();

    let mut i = 0;
    for num in slice.iter().filter(|num| is_even(num.get())) {
        slice[i].set(num.get());
        i += 1;
    }

    nums.truncate(i);
}

这会比使用索引方式更简洁- -!

[mocanxi]

use std::cell::RefCell;

fn main() {
    let s = RefCell::new(String::from("hello"));
    let s1 = s.borrow();
    println!("s1:{}", s1);
    let mut s2 = s.borrow_mut();
    s2.push_str(",world");

    println!("s2:{}", s2);
}

fn main() {
    let mut s = String::from("hello");
    let s1 = &s;
    println!("s1:{}", s1);
    let mut s2 = &mut s;
    s2.push_str(",world");

    println!("s2:{}", s2);
}

为什么下面这个方法可以正常运行，上面使用了RefCell就会报错了，哪位大佬解答一下

[overcache]

前者是编译期检查, 编译器可以发现s1不再使用, 可以理解为编译器自动帮你加了花括号:

fn main() {
    let mut s = String::from("hello");
    {
        let s1 = &s; // 不可变引用
        println!("s1:{}", s1); // 使用 s1
    } // s1 的生命周期结束
    let s2 = &mut s; // 可变引用
    s2.push_str(",world"); // 使用 s2
    println!("s2:{}", s2);
}

RefCell是运行时检查, 所以你得自己加花括号.

fn main() {
    let s = RefCell::new(String::from("hello"));
   {
        let s1 = s.borrow();
        println!("s1:{}", s1);
    }
    let mut s2 = s.borrow_mut();
    s2.push_str(",world");

    println!("s2:{}", s2);
}

[mocanxi]

感谢答复，但我依旧表示怀疑。你是通过编译后的汇编发现的，还是什么文档上有这样说明，感谢指明。

[PeyChou]

我理解。cell和refcell的用unsafe开了个后门，绕过了编译期检查。cell 操作的是栈上的数据（Copy），不会触发运行时 panic。refcell操作的是堆上的数据，使用不当可能会触发运行时所有权panic

[tjw123hh]

感觉Rust就应该把数组、Vec等中每个元素都放进Cell/RefCell中，或者用Cell/RefCell的形式拿出
1.86.0更新的slice::get_disjoint_mut也差不多一个需求