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

[showyou2023]

Self=&T--->&self=&&T--->*self=&T-->&T=&Self(Self=T)

[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

[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会一直自动往里解引用。

[IronPanda0]

我觉得应该强调一下因果关系：
(&&&&&&&&f).foo();
之所以成功是因为标准库里为 &T 这种形式实现了Deref

[freesrz93]

可以看下这篇文章:
https://manishearth.github.io/blog/2017/01/10/rust-tidbits-box-is-special
另外 Box::new 也很有意思

impl<T> Box<T> {
    pub fn new(x: T) -> Self {
        #[rustc_box]
        Box::new(x)
    }
...
...
...

[Rgoogle]

首先 MyBox 被 Deref 成 String 类型，结果并不能满足 display 函数参数的要求，编译器发现 String 还可以继续 Deref 成 &str
这里错误了，正确的是这个
首先 MyBox 被 Deref 成 &String 类型，结果并不能满足 display 函数参数的要求，编译器发现 &String 还可以继续 Deref 成 &str

[HC-miss]

本来还好，看到这有些迷茫了

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

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

理解了一下，相当于**&T解引用就是&T**，就是其本身，所以实现了引用归一化（&&&&&T --> &T）？。

然后又联想到了String类型的解引用，代码如下

    let s: String = String::new();
    let _a: &str = String::deref(&s);
    let _a: &str = (&s).deref();
    let _a: &str = (s).deref();

以上代码分别利用完全限定语法以及点语法，现在只考虑点语法，String类型实现了Deref特征，即实现了fn deref(&self) -> &str，在调用deref方法时，根据方法的隐式转换规则去取其引用进而执行deref方法，

[HC-miss]

有如下代码：

use std::fmt::Display;
fn clone_loudly<T: Display>(x: &T) -> T {
    println!("Cloning {}", x);
    (x).clone()
}

以上代码编译不通过，因为x没有实现Clone特征，但是引用类型&T实现了Clone特征:

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

方法返回了Self，也就是&T，所以返回值类型不符，编译不通过。

[HC-miss]

如果*y并不相当于*(y.deref())吧
如果只是读取y的值的话两者相当，但是如果Box包含的是一个没有实现Copy的类型，例如Vec、String，对于如下代码：

    let v = Box::new(vec![10, 20, 30]);
    {
        let a = *v;
        let b = *(v.deref());
    }

变量a会得到所有权，但是b由于只是读取引用的值的数据，所以无法移动。
是不是*v有什么别的操作呢，我通过debug发现v就是一个裸指针(*mut Vec)，而不是Box<Vec<i32>

[codecoron]

三种 Deref 转换
文章中demo提到了自己实现Deref 、DerefMut的Trait，以此来了解deref的原理。因为这种解引用是自动的。

下面一个demo，比较简短见证了 &mut Box 自动转成 &mut String

fn main() {
    let mut s = Box::new(String::from("hello, "));
    display(&mut s)
}

fn display(s: &mut String) {
    s.push_str("world");
    println!("{}", s);
}

[lgln0]

开头的问题怎么理解，name是如何匹配的

let Person{name, age} = &self;

似乎是&&mut Person转化为&&Person，再解引用微&Person，最后匹配Person{name, age} = Person{&name, &age)，因此name类型是&string或者&str

[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

[SMSQO]

看中间的例子时总是想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]

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

[hewenxun]

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

[hewenxun]

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

[hewenxun]

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 不是能自动解多层引用吗？