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);
}

[sunface]

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

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

[Rustln]

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

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

[BruceChar]

这编辑有问题，Rc<RefCell<>> 和 RefCell<Rc<>>的区别

[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);

}

[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]

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

[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);
    }

[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 智能指针的正常运行。