advance/circle-self-ref/self-referential

[giscus[bot]]

advance/circle-self-ref/self-referential

https://course.rs/advance/circle-self-ref/self-referential.html

[Jesse-666]

这章看得我一脸懵逼

[siu91]

头痛！

[AceRogue]

头疼 决定跳过

[httaotao]

无法被移动的 Pin 这里，代码中有一段注释,

[httaotao]

// 只要结构体没有被转移，那指针就应该指向正确的位置，而且我们可以随意移动指针
let mut still_unmoved = unmoved;
这句话是什么意思？

[zd08135]

只要结构体没有被转移，那么指向该结构体的指针，在初始化之后就一定会指向正确的值，即便这个指针的所有权被随便转移。
比如，如果该结构体的地址为100，被绑定给某个变量x，那么只要结构体的地址维持100，不论x转移给y，又转移给z，依旧能通过这变量访问到指针100的结构体...

[zd08135]

上面的解释不太对，实际应该是这样：结构体没有被转移，那么这个结构体里面的自引用的指针在初始化之后一定会指向正确的值(即slice的值一定会是data的地址)，即便这个结构体的指针的所有权被随便转移到不同的变量上。

[Justinlaau]

是不是如果在vec 裏面，就會有機會指向錯誤的值

[zhaojuncw]

麻了

[NicholasFirst]

脑壳疼, 还是学会再来吧...

[licq]

配套的练习目前还没出来，配合练习还是会好很多。

[lonexw]

这块确实复杂，如果不是实现特定算法，基本还是少用自引用这种结构设计

[SifungLei]

头痛，哈哈

[cbbb8533]

#[derive(Debug)]
struct WhatAboutThis<'a> {
name: String,
nickname: Option<&'a str>,
}

impl<'a> WhatAboutThis<'a> {
fn tie_the_knot(&'a mut self) {
self.nickname = Some(&self.name[..4]);
}
}

fn main() {
let mut tricky = WhatAboutThis {
name: "Annabelle".to_string(),
nickname: None,
};
tricky.tie_the_knot();

// cannot borrow `tricky` as immutable because it is also borrowed as mutable
// println!("{:?}", tricky);

}
这段代码中如果把最后一句println!("{:?}", tricky)注释放开，为什么会报“cannot borrow tricky as immutable because it is also borrowed as mutable”
与上述代码几乎一样道理的这个：println!("{}",s);就不报错呢？没搞明白！
fn main() {
let mut s = String::from("hello");

change(&mut s);
println!("{}",s);

}

fn change(some_string: &mut String) {
some_string.push_str(", world");
}
哪位大神来解释一下

[cbbb8533]

一脸懵逼的进来一脸懵逼的出去，我看的是外星文

[Saltedf]

发表一下个人愚见. 有错误还请指出.
问题出在 fn tie_the_knot(&'a mut self) 这里创建了一个可变引用, 且它的生命周期和 struct WhatAboutThis<'a> 是一样长的. 因此在main()中的代码, tricky.tie_the_knot();所隐含创建的可变借用的生命周期和tricky这个struct值的生命周期是一样长的, 都截至到main()函数结尾. 因此编译器可能不太聪明的认为: 在tricky.tie_the_knot(); 之后(main结束前) 都存在一个对tricky的可变借用, 因此不能再创建对tricky的其它借用了. 但println! 会创建一个不可变借用, 因此编译器认为这违反了借用规则.

另一个例子中的change()可以改写成 等价 形式 :

fn change<'a>(some_string: &'a mut String) {
    some_string.push_str(", world");
}

区别在于这里的生命周期注解不像上面那个有额外的限制: 'a首先是struct WhatAboutThis的生命周期, 并且也是fn tie_the_knot(&'a mut self) 中隐含创建的可变引用的生命周期.

因此问题在于(在编译器看来)可变引用的生命周期过大了, 进而遇到借用检查的阻挠. 一个解决的办法就是将其改为不可变引用, 但同时也要有能力来修改struct中的nickname字段, 因此要"包裹"一层 RefCell<> :

    use std::cell::* ;
    
    #[derive(Debug)]
    struct WhatAboutThis<'a> {
        name: String,
        nickname: RefCell<Option<&'a str> > , // <<======
    }

    impl<'a> WhatAboutThis<'a>      
    {
        fn tie_the_knot(&'a self) { // <<====== 不可变借用 !
            *self.nickname.borrow_mut() =  Some(&self.name[..4]); 
        }
    }

    fn main() {
        let mut tricky = WhatAboutThis {
            name: "Annabelle".to_string(),
            nickname: RefCell::new(None) , // <<======
        };
        
        tricky.tie_the_knot(); 

        println!("===> {:?}", tricky); 

    }

[SUN-LG]

还是有问题，并不能修改name的值。会同时存在可变和不可变引用。
将name改成RefCell，又会出现用临时值赋给结构体的问题

[sinopec]

pin劝退了。。。

[huyanhai]

一脸懵

[csx12588]

看这一节特别的快，

[wupeaking]

跳过pin 反正不行我就不用这种方式去写。

[wuhaiji]

麻了

[lihongtao1024]

这章学得好懵逼：
1.为什么去掉PhantomPinned以后也不影响代码正确性。
2.网上说PhantomPinned是编译期标记，用来指明该结构体不实现Unpin，那为什么我的结构体还是可以移动。

use std::fmt::Display;
use std::fmt::Formatter;
use std::fmt::Result;
use std::marker::PhantomPinned;
use std::ptr;
use std::ptr::NonNull;
use std::pin::Pin;
use std::mem;

///不安全的实现
struct RefSelf1<T: Display> {
    value: T,
    ref_value: *const T,
}

impl<T: Display> Display for RefSelf1<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        write!(
            f, 
            "RefSelf1 {{ value: {:p}-{}, ref_value: {:p}-{} }}",
            &self.value,
            self.value,
            self.ref_value,
            unsafe { &*self.ref_value },
        )
    }
}

impl<T: Display> RefSelf1<T> {
    fn new(value: T) -> Self {
        let mut this = Self { value, ref_value: ptr::null() };
        this.ref_value = &this.value as *const T;
        this
    }
}

///固定到堆上的实现
struct RefSelf2<T: Display> {
    value: T,
    ref_value: NonNull<T>,
    _marker: PhantomPinned,
}

impl<T: Display> Display for RefSelf2<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        write!(
            f, 
            "RefSelf2 {{ value: {:p}-{}, ref_value: {:p}-{} }}",
            &self.value,
            self.value,
            self.ref_value,
            unsafe { self.ref_value.as_ref() },
        )
    }
}

impl<T: Display> RefSelf2<T> {
    fn new(value: T) -> Pin<Box<Self>> {
        let mut this = Box::pin(Self {
            value,
            ref_value: NonNull::dangling(),
            _marker: PhantomPinned,
        });
        unsafe {
            this.as_mut().get_unchecked_mut().ref_value = NonNull::from(&this.value);
        }
        this
    }
}

fn main() {
    let mut refself11 = RefSelf1::new("hello".to_owned());
    println!("refself11 = {}", refself11);

    let mut refself12 = RefSelf1::new("world".to_owned());
    println!("refself12 = {}", refself12);

    mem::swap(&mut refself11, &mut refself12);
    println!("refself11 = {}", refself11);
    println!("refself12 = {}", refself12);

    let mut refself21 = RefSelf2::new("hello".to_owned());
    println!("refself21 = {}", refself21);

    let mut refself22 = RefSelf2::new("world".to_owned());
    println!("refself22 = {}", refself22);

    mem::swap(&mut refself21, &mut refself22);
    println!("refself21 = {}", refself21);
    println!("refself22 = {}", refself22);
}

[lihongtao1024]

越学越懵逼。

为什么结构标记PhantomPinned，未实现Unpin，还是可以转移所有权？

    let mut aa = RefSelf2 { value: "hello", ref_value: NonNull::dangling(), _marker: PhantomPinned };
    aa.ref_value = NonNull::from(&aa.value);
    println!("aa = {}", aa);
    
    let bb = aa;
    println!("bb = {}", bb);

    /// 输出结果如下,确实是出错了。但为什么不阻止我move?
    aa = RefSelf2 { value: 0x8227fbf428-hello, ref_value: 0x8227fbf428-hello }
    bb = RefSelf2 { value: 0x8227fbf480-hello, ref_value: 0x8227fbf428-hello }

用Pin保护起来测试move。

    unsafe {
        let mut aa = Box::pin(RefSelf2 { value: 10, ref_value: NonNull::dangling(), _marker: PhantomPinned });
        aa.as_mut().get_unchecked_mut().ref_value = NonNull::from(&aa.value);
        println!("aa = {}", aa);
        
        let bb = aa;
        println!("bb = {}", bb);
    }

    /// 输出结果如下，是正确的。但我去掉PhantomPinned结果也是正确的，那PhantomPinned的意义是什么，这里没弄懂。
    aa = RefSelf2 { value: 0x22305f4d238-10, ref_value: 0x22305f4d238-10 }
    bb = RefSelf2 { value: 0x22305f4d238-10, ref_value: 0x22305f4d238-10 }

[whtblktone]

这个问题，我觉得是rust没有构造函数导致的。因为没有构造函数，无法在结构体初始化的过程中通过self引用value给pointer_to_value赋值。所以只能想办法把pointer_to_value占个位空着，先把结构体构造出来，然后再去赋值

[liyan-ah]

在一个 &mut self 的方法里调用 &mut self 的方法，是不是自引用的范畴。

[Tianyi822]

卧槽，麻了呀

[XPJ1993]

这个是链表和树的基础呀，但是真的难

[ShockYoungCHN]

fn creator<'a>() -> WhatAboutThis<'a> {
    let mut tricky = WhatAboutThis {
        name: "Annabelle".to_string(),
        nickname: None,
    };
    tricky.nickname = Some(&tricky.name[..4]);

    tricky
}

的解释可能有误导性；“其实从函数签名就能看出来端倪，'a 生命周期是凭空产生的！”这句话是对的，但是不是报错的直接原因，Rust不会阻止自引用类型。

事实上，name字段底层数据分配在堆上，move并不会影响reference。但是Rust并没有意识到这一点，仍然采取一种保守的假设：移动可能会使任何现存的引用失效。

[zhfs]

我选unsafe

[Liccsu]

最复杂的一集

[windqyoung]

说了这么多, 只证明一件事, rust解决不了自引的问题.
千万别说什么自引用在代码中用的少.
别人用的少, 不代码rust无能就是正确的.

[wzwmzm]

最新的推荐方法是: 不存储对name的直接引用, 可以改为在需要时动态计算昵称，即nickname不是引用, 而是方法nickname(), 在需要时实时计算出结果.
impl WhatAboutThis {
fn nickname(&self) -> Option<&str> {
if self.name.len() > 3 {
Some(&self.name[..4])
} else {
None
}
}
}

[KiSetsuFu-PuLiN]

有可能自引用压根就不应该存在，引用了自身的字段，就意味着这个自身不能存在于栈上、只能存在于堆上，不然随随便便一个move或copy都会导致悬空指针的风险。
应该在对自身结构的特性实现里添加访问器来借助self指针实现“自引用”

[Justinlaau]

borrow 之后 不是不能move吗？ 取得 iOS 版 Outlook<https://aka.ms/o0ukef>

…

________________________________ 寄件者: 蒲灵 ***@***.***> 寄件日期: Sunday, June 30, 2024 8:23:03 PM 收件者: sunface/rust-course ***@***.***> 副本: Justin ***@***.***>; Comment ***@***.***> 主旨: Re: [sunface/rust-course] advance/circle-self-ref/self-referential (Discussion #758) 有可能自引用压根就不应该存在，引用了自身的字段，就意味着这个自身不能存在于栈上、只能存在于堆上，不然随随便便一个move或copy都会导致悬空指针的风险。 应该在对自身结构的特性实现里添加访问器来借助self指针实现“自引用” ― Reply to this email directly, view it on GitHub<#758 (comment)>, or unsubscribe<https://github.com/notifications/unsubscribe-auth/A5WLHZ5FRXNMRBPQIEIRNXLZJ72CPAVCNFSM5S5EFKY2U5DIOJSWCZC7NNSXTOKENFZWG5LTONUW63SDN5WW2ZLOOQ5TSOJRGY3DANQ>. You are receiving this because you commented.Message ID: ***@***.***>

[heixiah]

催眠神书，真的看着看着就困了

[lifean]

这章真麻了

[hiddenpath]

谁能用rust写dancinglinks算法绝对是高手。看看这个，new()中不能访问上下左右：
type NodeRef = Rc<RefCell>;

#[derive(Debug)]
struct Node {
left: Option,
right: Option,
up: Option,
down: Option,
column: Option, // 列头引用
row_info: Option<(usize, usize, u8)>, // 用于重建解，存储(row, col, val)
}

impl Node {
fn new() -> NodeRef {
let node = Rc::new(RefCell::new(Node {
left: None,
right: None,
up: None,
down: None,
column: None,
row_info: None,
}));

    {
        let node_mut = node.borrow_mut().deref_mut();
        node_mut.left = Some(Rc::clone(&node));
        node_mut.right = Some(Rc::clone(&node));
        node_mut.up = Some(Rc::clone(&node));
        node_mut.down = Some(Rc::clone(&node));
    }

    node
}

}

是的，没错，我第一步就写不下去了，高手出手吧

[yinyangdao123]

新版是不是没有这个问题了，为什么我试了一下不需要这么复杂呢？

#[derive(Debug)]
struct WhatAboutThis<'a> {
name: String,
nickname: &'a str,
}

fn main() {
let mut tricky = WhatAboutThis {
name: "Annabelle".to_string(),
nickname: "",
};
tricky.nickname = &tricky.name[..];
println!("{:?}", tricky);
println!("{}, {:p}, {:p}", tricky.name, tricky.name.as_ptr(), tricky.nickname);
}

/*
WhatAboutThis { name: "Annabelle", nickname: "Annabelle" }
Annabelle, 0x12ae05f70, 0x12ae05f70
*/

[WangXiaogangX]

循环引用与自引用 看的有点懵 过一遍 等以后写代码出现这类问题 再回头看把

[cctga]

这么大一坨，只能说 RUST 为了垃圾回收，让用户付出了太多