登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 资源区 › 代码 ›rust学习十五.3、智能指针相关的Deref和Drop特质 ...

rust学习十五.3、智能指针相关的Deref和Drop特质

硫辨姥 前天 15:18
 
一、前言

智能指针为什么称为智能指针？ 大概因为它所包含的额外功能。
这些额外的功能使得编码或者运行时让指针看起来更有效、并体现某些“智”的特征，所以，我猜测这应该是rust发明人这么称呼此类对象为智能的原因。
 
据前面有关章节所述，我们知道智能指针多基于结构体（struct)扩展实现。
我们知道，struct大体上相当于OOP的Class Object（类对象）。struct可以有自身方法，也可以实现特质。
所以，智能指针的所谓”智“（如果称为”魔力“之类也可以），多数来源于这些特质。 如果为了便于理解，也可以把这些特质称为插件，插件越多，一个武器的功能就越强大。
好比多功能道具，可以装上很多头，实现乱七八糟的功能。
 
这些特质中，有两个需要重点介绍：Deref,Drop
 
无论是Box还是其它智能指针，都面临2个问题：如何访问指针指向的数据，如何释放指针所指向的数据。
访问数据涉及到编码的方便性，释放指针涉及到内存安全问题。
编码方便性要求rust提供一些更友好的书写方式，以便工程师能够更容易编写相对容易阅读的代码。要知道rust本身的语法已经够丑陋了，不能让指针把语法变得更加丑陋。
二、概念准备

引用(Reference -- ref)
指针本身就是引用。 前面有关文章中提到 &var，这个&就是构建一个指针，用于引用var的值。
解除引用（DeReference -Defef)
顾名思义，就是解除对xxx的引用。
但这实际有两个歧义：
1.不间接引用，而是直接用
2.不再引用，也无法用
结合有关书籍上下文和rust的意思，应该理解为：不采用引用的方式，而是直接使用xxx值
rust中使用 * 表示解除引用。
丢掉/清理(Drop/clean- Drop）
和引用行为有关的另外一个概念。当引用完成后，解除对这些资源的控制，就称为丢掉。
三、Deref --解除引用

书籍中关于Deref的作用概括：方式实现 Deref trait 的智能指针可以被当作常规引用来对待，可以编写操作引用的代码并用于智能指针
3.1Deref的Box实现

#[lang = "deref"]#[doc(alias = "*")]#[doc(alias = "&*")]#[stable(feature = "rust1", since = "1.0.0")]#[rustc_diagnostic_item = "Deref"]pub trait Deref {    /// The resulting type after dereferencing.    #[stable(feature = "rust1", since = "1.0.0")]    #[rustc_diagnostic_item = "deref_target"]    #[lang = "deref_target"]    type Target: ?Sized;
    /// Dereferences the value.    #[must_use]    #[stable(feature = "rust1", since = "1.0.0")]    #[rustc_diagnostic_item = "deref_method"]    fn deref(&self) -> &Self::Target;}//-------------------------------------------------------#[stable(feature = "rust1", since = "1.0.0")]
  1. impl<T: ?Sized, A: Allocator> Deref for Box<T, A> {
  2.     type Target = T;
  4.     fn deref(&self) -> &T {
  5.         &**self
  6.     }
  7. }
复制代码
type Target: ?Sized;  -- >表示目标是一个不固定大小的类型
Box的deref的返回是 &**self。
特别需要注意的是：deref函数的实现是比较怪异。
我们要理解：&**self是如何变成 &T的

  • 首先&self是指向Box的一个引用
  • *self,解除引用，直接得到Box。*self实际是*(&self)。
  • *(*self)=*(Box),Box本身包含一个指针，所以得到T
  • &(**self)=&(*(*(&Self)))=&(*Box)=&(T)
最终deref让我们得到Box指针的实际数据的引用。
--
注意：由于rust的一个约定，阅读对象方法体需要特别注意
rust对象方法通常形如 fn  xxxx(&self){}。
这存在一个默认的对自身的引用，而不是自身。但是我们又在方法体中写self.而这个self其实是&self。
 
3.2编译器对Deref的支持

很多时候，某个对象（struct,enum等）实现某个特质的时候，我们通过对象实例去调用特质方法来使用特质。
当Rust的做法是通过编译器的努力，让工程师可以不直接调用deref就能够执行deref，从而编写更加简单的代码，并实现deref的主要目的：智能指针可以被当作常规引用来对待
许多语言的编译器都类似的行为，越是新的语言，越是新版本的编译器，体现越明显。例如java对匿名函数的支持，对郎打表达式的支持。
那么做的原因，即使为了减轻工程师的负担：便利地得到某种功能，而不需要使用复杂的操作
 
更具体一点就是：工程师可以不要再写*号，在多个场景中，rustc编译器会尝试替工程师调用deref。
根据书上描述的规则如下：

  • 当 T: Deref 时从 &T 到 &U。
  • 当 T: DerefMut 时从 &mut T 到 &mut U。
  • 当 T: Deref 时从 &mut T 到 &U。
需要我们理解的是第3条：根据借用规则，如果有一个可变引用，其必须是这些数据的唯一引用（否则程序将无法编译）;将不可变引用转换为可变引用则需要初始的不可变引用是数据唯一的不可变引用，而借用规则无法保证这一点。
因此，Rust 无法假设将不可变引用转换为可变引用是可能的。
然而不能理解也不重要，总之这是一个规定.
 
示例：
  2. use std::ops::Deref;
  4. fn hello_ref_string(name: &str) {
  5.     println!("Hello, {name}!");
  6. }
  8. fn main() {
  9.     //1.0 Box的隐式转换  -- &Box转为 &String,不需要写复杂的 &(*Box)
  10.     let eng=String::from("英国佬");
  11.     let eng_box=Box::new(eng);
  12.     hello_ref_string(&eng_box);  // 隐式转换，把 &Box转为 &String。 通过这种引用可以省掉 * 符号
  14.     //2.0 如果愿意，也可以使用*符号显式转换。
  16.     let german=String::from("德国佬");
  17.     let german_box=Box::new(german);
  18.     hello_ref_string(&*german_box);  // 这相当于*解除引用后得到T，再&T得到&T
  20.     //3.0  也可以显示调用deref方法
  22.     let french=String::from("法国佬");
  23.     let french_box=Box::new(french);
  24.     hello_ref_string(french_box.deref());  // 显式调用Deref方法，得到&T
  25. }
复制代码
 rustc的隐式转换，就是为了避免我们写 frech_box.deref()。工程师可以直接写 &frech_box就达到隐式调用deref的效果。
 
四、Drop

4.1、概述

如书所言，Drop大概是rust最重要的一个特质，它负责在离开作用域后，为对象自动释放相关资源（文件，网络，内存...）。
然而Drop的妙处有不少：

  • 可以为rust的任意类型实现Drop
  • rust通过编译器的方式，会为对象插入离开特定作用域的代码-- 即调用对象的Drop实现 
  • 如果有多个对象需要释放，那么rust编译器会自动决定需要释放的顺序（通常是创建对象时间的逆序，但不明确是否绝对)
  • Drop 无法被禁止，也无需禁止，因为它的初衷就是为了自动清理
  • Drop 也不能显示调用,但可以使用std::mem::drop()函数来提前释放资源. 这个函数其实就是主要调用Drop特质
  • 所有权系统确保引用总是有效的，也会确保 drop 只会在值不再被使用时被调用一次
通过这个机制，rust避免了工程师插入手动释放资源代码问题：麻烦、可能会忘记、可能释放顺序存在错误等等。
这些规则都挺好理解。
据本人所知，rust的自有智能指针（String，Vec,Box,Rc,Ref,RefMut)都实现了Drop，但为什么enum没有实现？
此问题，暂时不考虑了。
现添一个例子（模仿书本），演示Drop的调用机制，和手动调用drop函数：
  1. #[derive(Debug)]
  2. struct Student {
  3.     name: String,
  4.     age: u32,
  5. }
  6. impl Drop for Student {
  7.     fn drop(&mut self) {
  8.         println!("释放{}({}岁)的资源",self.name,self.age);
  9.     }
  10. }
  11. fn test_drop() {
  12.     let mut mao = Student {
  13.         name: String::from("高温i"),
  14.         age: 20,
  15.     };
  16.     mao.age = 21;
  17. }
  18. fn main() {
  19.     test_drop();
  20.     let lu = Student {
  21.         name: String::from("卢俊义"),
  22.         age: 40,
  23.     };
  24.     println!("{:#?}", lu);
  25.     std::mem::drop(lu);  //手动释放。如果不释放，那么程序退出的时候也会被自动调用一次。
  26.                          //drop 函数主要作用就是调用Drop特质，所以这里手动释放也行。
  27.     println!("main 结束");
  28. }
复制代码
执行结果：
1.png

从执行结果可以验证几个结论：

  • drop是自动调用的
  • 离开任意作用域都可能触发drop，就看变量的作用范围。有的作用于某个方法、函数，有的作用于主函数
  • 手动调用drop(),也会自动Drop特质方法
 
最后，看看Box的Drop实现:
  1. #[stable(feature = "rust1", since = "1.0.0")]
  2. unsafe impl<#[may_dangle] T: ?Sized, A: Allocator> Drop for Box<T, A> {
  3.     #[inline]
  4.     fn drop(&mut self) {
  5.         // the T in the Box is dropped by the compiler before the destructor is run
  7.         let ptr = self.0;
  9.         unsafe {
  10.             let layout = Layout::for_value_raw(ptr.as_ptr());
  11.             if layout.size() != 0 {
  12.                 self.1.deallocate(From::from(ptr.cast()), layout);
  13.             }
  14.         }
  15.     }
  16. }
复制代码
 
Box的其中一个成员（内存分配器)可以执行资源释放--具体而言就是堆内存释放。
 
4.2、其它智能指针的Deref示例
  1. use std::cell::{RefCell,Cell};
  2. use std::borrow::BorrowMut;
  3. use std::rc::Rc;
  4. use std::cell::{Ref, RefMut};
  6. struct Family {
  7.     father: String,
  8.     mother: String,
  9.     children: Vec<String>,
  10.     addr: String,
  11.     phone: String,
  12.     year_income: u32,
  13. }
  15. fn main() {
  16.     //1.0 测试Box指针。优点：直接使用，不要显式Deref.传参的时候&T，实际起到&（*T）的作用。
  17.     test_box();
  19.     //2.0 测试RefCell指针。优点：内部可变，需要使用borrow_mut(),borrow,take等。 但不能直接使用
  20.     test_refcell();
  22.     //3.0 测试Cell指针。优点：内部可变，但不安全，需要使用get_mut()，get!。 但不能直接使用
  23.     test_cell();
  25.     //4.0 测试Rc指针。优点：共享所有权，但不安全，需要使用clone!。 能直接使用
  26.     test_rc();
  28. }
  30. fn test_box() {
  31.     println!("测试Box指针------------------------------");
  32.     let book_store = Box::new(vec!["三海经".to_string(), "论语".to_string(), "史记".to_string()]);
  33.     println!("使用book_store[0]访问 {}", book_store[0]);
  34.     let shj = book_store[0].clone() + " 作者：未知";
  35.     println!("{}", shj);
  36. }
  38. fn test_refcell() {
  39.     println!("测试RefCell指针------------------------------");
  40.     let family = RefCell::new(Family {
  41.         father: "张三".to_string(),
  42.         mother: "李四".to_string(),
  43.         children: vec!["小明".to_string(), "小红".to_string()],
  44.         addr: "北京朝阳区".to_string(),
  45.         phone: "123456".to_string(),
  46.         year_income: 360000,
  47.     });
  49.     let borrow_family = family.borrow();
  50.     println!("家庭地址：{},家庭年收入:{}", borrow_family.addr, borrow_family.year_income);
  51. }
  53. fn test_cell(){
  54.     println!("测试Cell指针------------------------------");
  55.     let mut cell = Cell::new(10);
  56.     println!("cell.get()={}", cell.get());
  57.     cell.borrow_mut().set(20);
  58.     let qty=cell.get_mut();
  59.     *qty+=1;
  60.     println!("cell.get()={}", cell.get());
  61. }
  63. fn test_rc(){
  64.     println!("测试Rc指针------------------------------");
  65.     let rc = Rc::new(Family {
  66.         father: "李白".to_string(),
  67.         mother: "许氏".to_string(),
  68.         children: vec!["伯禽".to_string(), "颇黎".to_string()],
  69.         addr: "安陆".to_string(),
  70.         phone: "".to_string(),
  71.         year_income: 4556666,
  72.     });
  73.     println!("丈夫:{},妻子:{},   家庭地址：{},家庭年收入:{}",
  74.        rc.father, rc.mother,
  75.        rc.addr, rc.year_income);
  76. }
  78. fn  test_ref(){
  79.     //测试RefMut,Ref特质。
  80.     // RefMut,Ref特质是和Cell，RefCell配合使用的,所以不再写代码了！
  81. }
复制代码
 
注意，Cell，RefCell本身并不实现Deref。
总之，实现了Deref，那么还是比较好用的！
 
五、小结

当学习了Deref和Drop两个特质之后，对于智能指针的“智能”更有体会了。
以下是个人的一些初步体会：

  • rust通过实现Deref和Drop大大方便了对数据的引用和对资源的释放，换言之，以往在类似c++那用的事情变得相对简单了
  • rust通过适当的性能牺牲达到相对的内存安全以及相对高的性能，某种程度上是可以接受的。
  • 如果在特定的应用中，对于特定功能的性能比较执着，那么也可以考虑继续采用硬件代码/c/c++之类的语言编写
  • 智能指针的存在，是否意味着，在面向具体业务的编码中，大部分类型应该采用智能指针？
 
小结：

  • 通过实现Deref，智能指针可以被当作常规引用来对待
  • 通过实现Drop，可以解决智能指针资源的释放问题（前提是代码写对了)
  • Deref的deref()可以手动调用，而Drop的drop()是不允许手动调用的
 

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
硫辨姥
前天 15:18

0

粉丝关注

9

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫