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]

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

[jyutjyu]

头痛，哈哈

[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占个位空着，先把结构体构造出来，然后再去赋值

[jim-yefeng]

new 就是约定的构造函数，问题还是在所有权转移和引用同时生效引起了编译错误

[liyan-ah]

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

[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 为了垃圾回收，让用户付出了太多

[xwlcn]

感觉在啃依托答辩。

[Steven-hsm]

看来和我一样，大家都麻了

[jim-yefeng]

确实想吐，所有权和借用规则带来的复杂度不是一点点

[hellorust2056]

Rust的Pin并不可怕 https://zhuanlan.zhihu.com/p/1938905968348987723

[hellorust2056]

Rust 的 Unpin Trait 也不可怕 https://mp.weixin.qq.com/s/pOcQTCW_n7ywGV0gbCretA?token=1354069031&lang=zh_CN

[PPPPigggg]

skip

[hwq123vip]

4.5这这章套中套中套看得劝退

[xiaofeng-zerone]

妥妥的语言设计上的失败

[dinhyu]

谈谈我的理解。
1.结构体内部有自引用，那么为了确保内部的指针的指向保持正确，结构体在内存中的位置就不能变了。
什么时候结构体在内存中的位置会变，转移所有权的时候就会变。

struct Person {
    name: String,
    slice: &str,
}
//impl//用new方法返回Person,且slice指向name
fn main(){
    let a = Person::new();
    let b = a;//此时Person实例被移动了//指针失效了
}

2.怎么办，Rust使用Pin包装对象，使得其不被移动。

let res = Person::new();
let mut boxed = Box::pin(res);
let mut another_boxed = boxed;//Person实例不被移动，Pin指针被移动

实际上，用Box直接包装也可以保障Person实例不被移动，但Pin会有额外的检查和阻止行为。
被Pin包装后，编译器会确保：

• 无法获得该结构体的&mut T引用
• 无法使用mem::replace等移动操作

3.为了使用Pin的阻止功能，需要对象实现!Unpin Trait
而在结构体中添加_pin: std::marker::PhantomPinned字段后，编译器会自动为其实现!Unpin Trait

struct Person {
    name: String,
    slice: &'static str, // 使用'static生命周期简化示例
    _pin: PhantomPinned,
}

impl Person {
    fn new() -> Self {
        let name = String::from("Alice");
        let slice_ptr: *const str = &name as &str;
        
        // 创建结构体实例
        let person = Person {
            name,
            slice: unsafe { &*slice_ptr }, // 创建自引用
            _pin: PhantomPinned,
        };
        
        person
    }
    
    fn display(&self) {
        println!("Name: {}, Slice: {}, Slice addr: {:p}, Name addr: {:p}", 
            self.name, self.slice, self.slice, self.name.as_str());
    }
}

fn main() {
    // 创建结构体实例
    let mut a = Person::new();
    a.display();
    
    // 尝试移动 - 这会编译通过，因为还没有用Pin包装
    let mut b: Person;
    unsafe {
        // 注意：这个移动会导致slice指向错误的内存！
        b = mem::transmute_copy(&a);
    }
    
    println!("--- 使用Pin包装后 ---");
    
    // 用Pin包装结构体
    let mut pinned_a = Box::pin(Person::new());
    
    // 尝试使用Pin的安全API访问数据
    pinned_a.as_ref().display();
    
    // 下面的代码会编译错误 - 这就是Pin的保护作用
    // let mut another = Person::new();
    // mem::swap(&mut *pinned_a, &mut another);
    
    println!("演示完成！");
}