advance/smart-pointer/deref

[giscus[bot]]

advance/smart-pointer/deref

https://course.rs/advance/smart-pointer/deref.html

[Nanbert]

干巴巴讲的挺好的，讲到标准库我就不理解了，*self类型不是T吗？怎么函数头返回的却是**&T**

impl<T: ?Sized> Deref for &T {
    type Target = T;

    fn deref(&self) -> &T {
        *self
    }
}

[duanyuluo]

@sperains 解释的很对。另外要理解rust的一个关键点：
impl Deref for &T 和 impl Deref for T是完全不同的两回事。
基本上实现后者没有任何意义，因为deref都是针对一个引用，而不是实例对象。所以，当你调用&T的解引用时，rust并不会去找T有没有实现Deref，只会看&T有没有实现Deref Trait

[kunlongxu]

请问一下,这个impl<T: ?Sized> const Deref for &T 已经包含在prelude中了吗?如果已经包含了.这种实现 trait 的方法是不是对所有类型都起作用了?没看到哪里文档有讲这个 for &T 这种写法

[AoranAllen]

标准库这里的impl for的是 &T, 而deref()方法的签名是：deref(&self)，所以函数里内部的self实际是&&T，那么*self就是&T呀

[arielherself]

分享文档里的一句话：

The &self is actually short for self: &Self

[Luyoung0001]

cuz "for &T" ,so self is &T, and *self is T actually

[uniphone]

最新的rust “ assert_eq!(5, *y); ” 是否已经是相等的了？ 执行了一遍发现没有告警了。从语义上讲的确 *(&y) 应该等于 y

[lonexw]

我猜，你应该看错文字/代码了。

[xiaohongxiedaima]

let str1: &str = "hello";
let str2: &str = &"hello";

println!("str1: {}, str2: {}", str1, str2);

[xiaohongxiedaima]

为什么 "hello" &"hello" 都是字符串切片呢

[MaxCrazy1101]

实际上str2是&&str

[jmu]

我的理解：str2的定义是 &str， 所以类型肯定是&str。 之所以也可以的原因是 &&str -> &str 编译器帮你自动解掉了。

[alexnest]

有一处疑惑的地方，希望各位不吝赐教
原文中有这样一句话：必须使用 &s 的方式来触发 Deref(仅引用类型的实参才会触发自动解引用)
原文中有这样一个例子：
fn main() {
let s = MyBox::new(String::from("hello, world"));
let s2: String = s.to_string();
}
疑惑之处:s并没用到&，为什么可以自动解引用为&str

[Tianyi822]

#[doc(hidden)]
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "string_to_string_specialization", since = "1.17.0")]
impl ToString for String {
    #[inline]
    fn to_string(&self) -> String {
        self.to_owned()
    }
}

[lilhammer111]

还有个东西叫自动再借用(reborrow)，了解一下这个应该就懂了

[lilhammer111]

对于上面的回复，我觉得应该是只有引用类型才能触发自动解引用的，比如说这里的let s1: &str = &s;可以触发自动解引用，但是let s1: &str = s;就无法触发自动解引用因此编译不通过，这里的s是一个MyBox类型并不是引用类型，但s.push()可以调用成功（即使push方法的入参是&self），本质还是因为发生了自动再借用吧，这是我的理解，不知道对错与否，欢迎指正！

[horizonshd]

描述的这个问题是属于 自动引用解引用，提到的原文中的话对应的是 函数和方法的隐式解引用强制转换（作用与函数和方法的参数上）。

[horizonshd]

描述的这个问题是属于 自动引用和解引用（作用于调用方法的“对象”上），提到的原文中的话对应的是 函数和方法的隐式解引用强制转换（作用于函数和方法的参数上）。

[zwq1792966796]

struct MyBox(T);
impl MyBox{
fn new(x:T)->Self{
Self(x)
}

}
use std::ops;
impl ops::Deref for MyBox{
type Target = T;
fn deref(&self) -> &Self::Target {
&self.0
}
}

fn main() {
let a=MyBox::new("123".to_string());
println!("{}",*a);
let b=*a;//这一条为啥会报错，仅仅是应为String没有实现Copy，但是Box中的解引用确实正确的

let c=Box::new("123".to_string());
let d=*c; //这一条编译正确
}

[OliverChao]

代码泛型部分写错了, 可能是想表达为自己的结构实现某几个trait impl SomeTrait for MyBox {} , 已达到可以像Box那么的可以解引用并且转移所有权.
就目前而言是不可以的, 这是 Box 的独有"魔法" 😂
Box是有很多特殊性质的, 完全可以把他当作原生类型看待. 比如他的Deref实现就很特殊,(明明看上去是无限递归, 但是编译器却明白他的含义).

---

但是并不代表以后不可以, 你可以看一下这个提案:
rust-lang/rfcs#997

---

不过你想要实现解引用并且转移所有权, 可以实现 一个into_inner()方法, 夺取所有权,返回内部结构

#[derive(Clone)]
struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> Self {
        Self(x)
    }
    fn into_inner(self) -> T {
        self.0
    }
}
use std::ops;
impl<T> ops::Deref for MyBox<T> {
    type Target = T;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

fn main() {
    let a = MyBox::new("123".to_string());
    println!("{}", *a);
    //这一条为啥会报错，仅仅是应为String没有实现Copy，但是Box中的解引用确实正确的
    // let b = *a;
    let b = a.into_inner();

    let c = Box::new("123".to_string());
    let d = *c; //这一条编译正确
}

[shenyongqing]

//let b =*a //编译不通过，改为&String，让编译器自己转换
let b = &*a as &String //强转为&引用类型
println!("{}", b)

[sunfu12]

这本书是英文版翻译过来的吧？

[sunface]

只能说借鉴了不少内容

[duanyuluo]

有个建议，关键概念在翻译的同时注明英文，每个程序员都必须迟早去啃英文资料的。

[fjchen7]

下面的我的理解，不知道对否？

struct Foo;

impl Foo {
    fn foo(&self) { println!("Foo"); }
}

let f = Foo;

// 这里发生了自动的*引用*。这个机制似乎跟文章里提的这些没有关系，是针对self的独特机制。
f.foo();  // 发生了f -> &f

// 这里发生了自动的*解引用*，也就是文章里的隐式Deref转换
(&&f).foo();  // 发生了&&f -> &f

[duanyuluo]

因为foo是Foo的Associate Method，所以，他的调用的完全方式是：
Foo::foo(&f);

[1654364091]

f.foo()的“完全限定”表述形式是“ Foo::foo(&f)”，编译层面就是直接把&f带入到方法中

[fjchen7]

是不是只有加上*才会发生隐式解引用？

let a = Box::new(3);
println!("a = {}", a);   // 这句话发生了隐式解引用吗？

[Ryu2u]

这是因为Box实现了Display特征，你试试MyBox就不行，即使实现了Deref

[showyou2023]

表达式中药显式解引用，函数参数是链式隐式deref转换

[duanyuluo]

let a = Box::new(3_i32);
let b:i32 = 3;
assert_eq!(a, b);

[duanyuluo]

不但不会解引用，而且连编译都过不去，类型不同。

[Endermanbugzjfc]

就算是比较它们的引用也不行：

fn main() {
	let b = Box::new(3i32);
	let t = 3i32;
	dbg!(&b == &t);
}

error[E0277]: can't compare `Box<i32>` with `i32`
 --> compiler.rs:4:10
  |
4 |     dbg!(&b == &t);
  |             ^^ no implementation for `Box<i32> == i32`
  |
  = help: the trait `PartialEq<i32>` is not implemented for `Box<i32>`
  = help: the trait `PartialEq` is implemented for `Box<i32>`
  = help: for that trait implementation, expected `Box<i32>`, found `i32`
  = note: required for `&Box<i32>` to implement `PartialEq<&i32>`

error: aborting due to previous error

For more information about this error, try `rustc --explain E0277`.

[apodemakeles]

因为一般教程讲到Deref的时候都是从解引用操作开始的，比如本文中的(y.deref())那段，所以总让人迷惑。
这也难怪，deref这方法名称就是解引用。
但我发现如果换个角度，你把deref当做一个普通方法，Rust编译器满足一个核心规则：“假如deref(&T)->&U，那&T可以出现在&U能出现的任意地方”，会不会好理解一点？（当然这个任意，以我的水平无法确认是否有例外，大家明白上下文就好了）
这样很多难懂的情况，其实和这个核心规则没关系，比如xxx(&self)其实是xxx(self: &Self)，T.xxx()其实是进行了自动引用：xxx(&T)

[daydaystudylab]

应该是有些场景需要引用的地方会隐式调用defef()，解引用只是其中一个场景

[shenyongqing]

Deref for &T的实现模版

impl<T: ?Sized> const Deref for &T {
    type Target = T;

    #[rustc_diagnostic_item = "noop_method_deref"]
    fn deref(&self) -> &T {
        *self
    }
}

Clone for &T的实现模版

impl<T: ?Sized> const Clone for &T {
    #[inline(always)]
    #[rustc_diagnostic_item = "noop_method_clone"]
    fn clone(&self) -> Self {
        *self
    }
}

为什么两个“相同”的函数的语义是不一样？clone(&self)->Self和dere(&self)->&T只有返回值的形式不一样，一个是Self，一个是&T。难道编译器对‘引用&’有特殊处理？

[asuper0]

这里两个函数是等效的，我测试了，只要是引用类型，clone()的结果都是相当于deref()，例如

    let i = 5;
    let i1 = &i;

    let p0: i32=i.clone();
    let p1: i32 = i1.clone();
    let p2: &i32 = i1.clone();   //这一行会报错

后面我也想通了，当我拿到一个变量的不可变借用，我会希望clone出来的是原变量的值，而不是clone出来还是一个借用，否则clone来clone去都是对原变量的不可变借用，那就不是clone了

[Endermanbugzjfc]

@shenyongqing 前者返回的其实是 &&T

[lihongtao1024]

其实就是c++里的重载*运算符吧？

[leaf-potato]

多了函数调用传参的隐式转换

[opink]

有朋友知道，Rust 的Deref里，这个 self.0 是什么用法么？

[asuper0]

元组结构体，指向第0个元素
元组结构体

[3517277]

fn main() {
let s = MyBox::new(String::from("hello world"));
display(&s)
}

fn display(s: &str) {
println!("{}",s);
}
这里我们使用了之前自定义的智能指针 MyBox，并将其通过连续的隐式转换变成 &str 类型：首先 MyBox 被 Deref 成 String 类型。这里是不是有错误？MyBox的Deref不是返回一个&T的吗？也就是&String吗？为什么这里说是String?

[Hughsean]

关于Box的Deref实现：

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized, A: Allocator> Deref for Box<T, A> {
    type Target = T;

    fn deref(&self) -> &T {
        &**self
    }
}

我的理解是*self得到Box<T>，**self得到T，最后返回T的引用。那**self是怎么取出T呢？

[Rgoogle]

impl<T: ?Sized> Deref for &T {
type Target = T;

fn deref(&self) -> &T {
    *self
}

}

这个还是不懂。如果有一个是&&&&T
那么这个类型就和&T就不一样了。就不会有deref实现的方法。因为类型不一样就没有实现。还有*self为什么得到&T

如果一个self类型。

[IronPanda0]

&&&&T = &(&(&(&T))))，实现了Deref特征Rust会一直自动往里解引用。

[arielherself]

&&&&T = &(&(&(&T))))，实现了Deref特征Rust会一直自动往里解引用。

就算T没有实现Deref，在调用方法的时候也会自动解引用。

[Endermanbugzjfc]

刚刚看到了一个类似的特征 AsRef （转引用）
但跟 Deref （解引用）还是有本质的差别

• 分类： Deref 是 ops 模组的，隱式地重載了 * 操作符；AsRef 则是 convert 模组
• 实现： Deref 使用的是关联类别，意味着解引用后的类型永远相同；AsRef 使用的是泛型参数，编译器会推导类型

https://dev.to/zhanghandong/rust-concept-clarification-deref-vs-asref-vs-borrow-vs-cow-13g6
https://doc.rust-lang.org/std/convert/trait.AsRef.html

[Endermanbugzjfc]

刚刚又双叒叕看到了

实现 Deref 的类型应考虑实践 AsRef<T>，如下所示：

impl<T> AsRef<T> for SomeType
where
    T: ?Sized,
    <SomeType as Deref>::Target: AsRef<T>,
{
    fn as_ref(&self) -> &T {
        self.deref().as_ref()
    }
}

（<SomeType as Deref>::Target: AsRef<T>, 一行约束了 Deref 的关联类型——即被解的引用必须实现 AsRef<T>，T 为目前 SomeType 实现中的所转引用）

https://doc.rust-lang.org/std/convert/trait.AsRef.html#generic-implementations

[Lixuhuilll]

对于Box，为什么*(box.deref()) 无法被转移所有权（很合理），而 *box 可以被转移所有权（？？？），这是什么原理？

[Lixuhuilll]

如果自己编写一个struct，内部持有一个值的所有权，并实现Deref，那么是不能用*解引用后转移不具备Copy特性的值的所有权的，但Box可以

[Lixuhuilll]

而且Box的Deref的实现是对自身解引用后将引用传递出去，而且不会无限递归。。。看上去Box的解引用其实在编译器内另有黑魔法，和常规类型的Deref不是一回事

[lgln0]

确实是黑魔法，看看deref的实现就知道了：

fn deref(&self) -> &T {
        &**self
}

这里&self直接两次解引用，得到类型T，但Box的解引用此时都还没定义呢。。

[bcdax110]

感觉(通过 * 获取引用背后的值)[https://course.rs/advance/smart-pointer/deref.html#%E9%80%9A%E8%BF%87--%E8%8E%B7%E5%8F%96%E5%BC%95%E7%94%A8%E8%83%8C%E5%90%8E%E7%9A%84%E5%80%BC]在讲引用的时候讲可以让有c/cpp经验的人更好的理解Rust的引用，更好的理清引用关系

[Dyqer]

在这段源码中，&T 被自动解引用为 T，也就是 &T: Deref<Target=T> , 这里是不是&&T->&T呀

[ShyunnY]

现在我们针对 &T: Deref<Target=U>

现在有以下例子:

• &&&x: 我们将 &&&x 看成 T, 那么可以得出 U=&&x
• &&x: 我们将 &&x 看成 T, 那么可以得出 U=&x
• &x: 我们将 &x 看成 T, 那么可以得出 U=x

[drowchaeshew]

看中间的例子时总是想Box::new(String::from("hello"))是否能转换成String类型; 后来搞明白了: Deref 是在 不同引用 之间做变换的写法; 而 String 不是引用, 因此是无法通过 Deref 获取的; 而 &String 却是可以的. 下面补充几个例子:

fn main() {
    let s = Box::new(String::from("hello, world"));
    let s1: &String = &s;   // Ok,  &Box<String> -> &String
    let s2: &str = &s;      // Ok,  &Box<String> -> &String -> &str
    // let s3: String = &s;    // Err, &Box<String> -> &String -x-> String
    let s4: String = *s;    // Ok,  Box<String> -> String. (`s` moved, can't be used later)
    let s5: &str = &s4;     // Ok,  String -> &str
}

[leaf-potato]

同时也是方法调用的时候进行转换。

[Celiiina]

eq函数没有实现引用归一化吗？

[Celiiina]

fn main() {
let n = 3;
let nn = &&n;
println!("{}", nn.eq(&3));
}

[Celiiina]

nn并不会被引用归一化为&i32

[ADkun]

大家如果使用VSCode的rust-analyzer插件，可以在settings.json里面加入这些：

    "rust-analyzer.inlayHints.reborrowHints.enable": "always",
    "rust-analyzer.inlayHints.bindingModeHints.enable": true,
    "rust-analyzer.inlayHints.closureCaptureHints.enable": true,
    "rust-analyzer.inlayHints.closureReturnTypeHints.enable": "always",
    "rust-analyzer.inlayHints.expressionAdjustmentHints.enable": "always",
    "rust-analyzer.inlayHints.lifetimeElisionHints.enable": "always",
    "rust-analyzer.inlayHints.lifetimeElisionHints.useParameterNames": true,
    "rust-analyzer.inlayHints.discriminantHints.enable": "always",

这样就可以让rust-analyzer自动把这些隐式的语法糖转换给显示出来了。

[AbyssSkb]

为什么这里调用 hello_world 会报错呢？

fn main() {
    let a = [1, 2, 3, 4];
    let b = &a;
    hello_world(&b);
}

fn hello_world(a: &[i32]) {
    
}

报错显示

mismatched types
expected reference `&[i32]`
   found reference `&&[{integer}; 4]`

rust 不是能自动解多层引用吗？

[arielherself]

自动解引用指的是在调用foo.bar()的时候会对foo自动解引用，不是什么场景下都自动解引用。

[xyt-dev]

当我们对智能指针 Box 进行解引用时，实际上 Rust 为我们调用了以下方法：

*(y.deref())

首先调用 deref 方法返回值的常规引用，然后通过 * 对常规引用进行解引用，最终获取到目标值。

至于 Rust 为何要使用这个有点啰嗦的方式实现，原因在于所有权系统的存在。如果 deref 方法直接返回一个值，而不是引用，那么该值的所有权将被转移给调用者，而我们不希望调用者仅仅只是 *T 一下，就拿走了智能指针中包含的值。

这写的啥？？？

let a = Box::new(String::from("😅"));
let b = *a;
println!("{b}");

事实就是*T了以下就拿走了值和所有权啊。

而且也没有说解引用Box为什么能够获得所有权, 你不能通过一个引用移动其引用变量的所有权。

[arielherself]

Box是特殊类型。

[zhangdafeihhh]

智能指针应该不叫自动脱壳吧，就是自动解引用。

[justin-z0]

准确的说，总结里应该是 &Box -> &String -> &st 吧

[adamXBT]

看迷糊了,panic!

[inblossoms]

1. Deref Trait 主要是用于智能指针（如 Box, String, Vec 等），它们不是简单的引用，而是拥有数据的类型。Deref 允许这些智能指针在被解引用时，表现得像一个普通的引用一样。

[inblossoms]

2. Rust 语言本身就定义了普通引用如何被自动解引用和自动引用的规则，当在一个值上使用点操作符（.）来调用方法时（例如 value.method()），Rust 编译器会非常智能地尝试找到那个方法。如果 value 本身不是方法所属的类型，编译器会尝试以下几步，直到找到匹配的方法为止：

直接在 value 的类型上查找方法。
如果没找到，编译器会尝试自动解引用 value 一次。如果 value 是一个引用（&T 或 &mut T），它会尝试在 T 类型上查找方法。这个过程会递归进行。

以上文中的代码为例：

struct Foo;

impl Foo {
    fn foo(&self) { println!("Foo"); } // foo 方法定义在 Foo 类型上，接收 &self
}

let f = &&Foo; // (A) f 的类型是 &&Foo

就有：
f.foo()：
f 的类型是 &&Foo。
编译器查找：&&Foo 上有没有 foo 方法？没有。
编译器自动解引用一次：f 得到 &Foo。
编译器查找：&Foo 上有没有 foo 方法？没有（foo 方法定义在 Foo 上）。
编译器再次自动解引用一次：(&Foo) 得到 Foo。
编译器查找：Foo 上有没有 foo 方法？有！fn foo(&self)。
编译器检查签名：foo 方法需要 &self，而我们现在有 Foo 类型。编译器可以从 Foo 类型那里自动取引用 &Foo，然后调用 Foo::foo(&Foo)。
调用成功。

[hwq123vip]

#[derive(Debug)]
struct Person {
name: String,
age: u8
}

impl Person {
fn new(name: String, age: u8) -> Self {
Person { name, age}
}

fn display(self: &mut Person, age: u8) {
    let Person{name, age} = &self;
}

}
看不懂这个，怎么用结构体的里面的age作为参数的

[Rgoogle]

// 使用 Debug 特性，允许我们使用 {:?} 来打印结构体的调试信息
#[derive(Debug)]
struct Person {
// name 字段的类型是 String，表示一个可变的、可增长的字符串
name: String,
// age 字段的类型是 u8，表示一个无符号的 8 位整数（范围 0 到 255）
age: u8,
}

// 为 Person 结构体实现方法
impl Person {
// 关联函数 new，用于创建新的 Person 实例
// 参数 name 的类型是 String
// 参数 age 的类型是 u8
// 返回类型是 Self，即 Person 结构体本身
fn new(name: String, age: u8) -> Self {
// 创建一个新的 Person 实例，并返回
// name 和 age 字段的类型分别是 String 和 u8
Person { name, age }
}

// 方法 display，用于显示和更新年龄
// 参数 &mut self 的类型是 &mut Person，表示一个对 Person 实例的可变引用
// 参数 age 的类型是 u8
fn display(&mut self, age: u8) {
    // 通过引用访问字段并打印
    // self.name 的类型是 &String，因为 self 是一个引用
    // self.age 的类型是 &u8，同样是通过引用访问
    println!("Name: {}, Age: {}", self.name, self.age);
  
    // 更新结构体的 age 字段
    // 左侧 self.age 的类型是 &mut u8，因为 self 是一个可变引用
    // 右侧 age 的类型是 u8
    self.age = age;
}

}

// 主函数
fn main() {
// 创建一个可变的 Person 实例
// String::from("Alice") 的类型是 String
// 30 的类型是 u8
// Person::new(String::from("Alice"), 30) 的返回类型是 Person
// person 的类型是 mut Person，表示一个可变的 Person 实例
let mut person = Person::new(String::from("Alice"), 30);

// 调用 display 方法，并传入新的年龄 31
// 31 的类型是 u8
person.display(31);

// 输出更新后的结构体
// person 的类型是 Person
// 使用 {:?} 格式化字符串，利用了 Debug 特性来输出结构体的调试信息
println!("Updated Person: {:?}", person);

}

[Rgoogle]

在 Rust 中，尽管 self.age 的类型是 &mut u8（可变引用），而 age 的类型是 u8（值类型），但你仍然可以直接进行赋值操作。这是因为 Rust 在赋值时会自动进行 解引用（dereference）操作，允许你通过可变引用修改字段的值。下面我将通过详细的注释来解释这一过程。

fn update_age(&mut self, new_age: u8) {
// 左侧 self.age 的类型是 &mut u8，因为 self 是一个可变引用
// 右侧 new_age 的类型是 u8
// Rust 在赋值时会自动进行解引用操作，将 &mut u8 解引用为 u8，允许修改字段的值
self.age = new_age;
}

[Rgoogle]

解引用之后是基本类型 ，基本类型 值拷贝

[chunchunyd]

说实话我回过头来看还是不太理解这段标准库代码。

impl<T: ?Sized> const Deref for &T {
    type Target = T;

    #[rustc_diagnostic_item = "noop_method_deref"]
    fn deref(&self) -> &T {
        *self			// 注意这里self为&&T类型，因为&self是self: &Self的语法糖，Self为&T，所以self为&&T
    }
}

举例而言，&&&10.deref()，会调用的是对什么类型实现的deref()？

如果调用的是impl Deref for &&&i32上的deref()，那么它的行为难道不是，把&&&i32在deref()中引用为&&&&i32，再解引用成&&&i32返回？这样就没有发生变化。

如果调用的是impl Deref for &&i32上的deref()，这个调用是如何匹配上的？

实际上，我看了编译器的提示：
https://imgur.com/a/wjsonoG

可以看到，&&&10.deref()确实调用的是&&i32上的方法，而不是&&&i32上的方法，&T对应的是&&i32（T是&32），为什么呢？