Rust方法自动解引用测试，总结和补充

rust 复制代码
// 定义一个结构体MyBox，包含一个原始指针
struct MyBox<T>(T);

// 方法调用 . 操作，对方法的self 进行加& &mut * 还有 无大小转换
trait MyTrait {
    fn test0(mut self, x: &i32) where Self: Sized {
        println!("test0 :{}", x);
    }
    fn test1(self, x: &i32) where Self: Sized {
        println!("test1: {}", x);
    }
    fn test2(&self, x: &i32) where Self: Sized {
        println!("test2: {}", x);
    }
    fn test3(&mut self, x: &i32) where Self: Sized {
        println!("test3: {}", x);
    }
}

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }

    fn test(self: Arc<Self>) {
        println!("test type self");
    }
}

impl<T> MyTrait for MyBox<T> {}

use std::ops::{Deref, DerefMut};
use std::sync::Arc;

impl<T> Deref for MyBox<T> {
    type Target = T;
    fn deref(&self) -> &Self::Target {
        println!("deref run.");
        &self.0
    }
}

impl<T> DerefMut for MyBox<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        println!("deref mut run .");
        &mut self.0
    }
}

fn f0(b: MyBox<[i32; 2]>) {
    println!("succ f0.")
}

fn f1(b: &MyBox<[i32; 2]>) {
    println!("succ f1.")
}

fn f2(b: &mut MyBox<[i32; 2]>) {
    println!("succ f2.")
}

fn f3(b: [i32; 2]) {
    println!("succ f3.")
}

fn f4(b: &[i32; 2]) {
    println!("succ f4.")
}

fn f5(b: &mut [i32; 2]) {
    println!("succ f5.")
}

//无法写出 大小在编译未知
// // // fn f6(b: [i32]){
// //    println!("succ")
// }
fn f7(b: &[i32]) {
    println!("succ f7.")
}

fn f8(b: &mut [i32]) {
    println!("succ f8.")
}

trait ArrTrait {
    fn arr_f0(mut self) where Self: Sized {
        println!("test arr_f0.");
    }
    fn arr_f1(self) where Self: Sized {
        println!("test arr_f1.");
    }
    fn arr_f2(&mut self) where Self: Sized {
        println!("test arr_f2.");
    }
    fn arr_f3(&self) where Self: Sized {
        println!("test arr_f3.");
    }
}

trait UnsizeArrTrait {

    // 该处方法无法使用。因为[i32] 大小未知 无法通过编译

    // fn u_arr_f0(mut self: Self){
    //     println!("u_arr_f0");
    // }
    // fn u_arr_f1(self){
    //     println!("u_arr_f1");
    // }
    fn u_arr_f2(&mut self) {
        println!("u_arr_f2");
    }
    fn u_arr_f3(&self) {
        println!("u_arr_f3");
    }
}

impl ArrTrait for [i32; 2] {}

impl UnsizeArrTrait for [i32] {}

#[test]
fn t() {
    let  my_box = MyBox([3; 2]);
    // my_box.test();
    // 方法测试 自动添加&,* 减少工作量  mut 不属于类型一部分，只是修饰
    // my_box.test0(&3);  隐式转换.deref deref_mut &str
    MyTrait::test2(&my_box,&4);
    // my_box.test1(&3);
    // my_box.test2(&4); //自动给添加 &

    // my_box.test3(&3); //自动添加 &

    // (&my_box).test0(&3); // 自动加* 调用self
    // (&my_box).test1(&3); // 自动加 *
    // &my_box.test2(&3); //自动 归一化 一直到 只有一个 & .然后test2的&self ，然后直接调用。如果是
    // (&&&&&&&&&&&my_box).test3(&3); //归一化 变成&my_box 然后直接调用方法
// -------------------------------------------------------------------------------
//     my_box.arr_f0();// 调用了my_box的deref ,然后进行了添加* 调用了arr_f0方法,
//     ArrTrait::arr_f0(*my_box)
    // 感觉&[i32;2]能调用arr_f0是因为该类型能copy，如果没有copy应该报错？？？

    // my_box.arr_f1();//和arr_f0同理

    // my_box.arr_f2();// 感觉mut 有传递性,arr_f2的第一个要mut,my_box也要mut 否则报错，
    // 调用了derefMut ,然后直接调用arr_f2方法

    // 这里rust 先调用了 my_box的deref 方法 返回了 里面的引用。类型是&[i32;2],然后刚刚好调用了arr_f0方法
    // my_box.arr_f3();

    // ------------------------------------------------------------------------

    // my_box.u_arr_f2();// 进行了my_box先调用 derefMut 得到&mut [i32;2] 然后进行了无大小类型转换得到 &[i32]
    // [i32;2] &[i32;2] *[i32;2]
    // [i32]
    // my_box.u_arr_f3();//与上同理

    // --------------------------------------------------------------------------------

    // f0(my_box);
    // f1(&my_box);// 需要手动加& ,rust不会自动添加
    // f2(&mut my_box);//rust 不会自动加&mut ,需要手动
    // f3(*my_box);//rust 不自动加*， 这里*的作用调用deref方法
    // f4(&my_box);// rust 对函数不自动加&，导致deref方法调用不了，手动加，隐式类型转换 调用deref方法
    // f5(&mut my_box); //rust不自动加& 而且这个函数需要mut , 如果是&my_box也不成功，
    // 因为不可变不可以调用可变的参数,这里调用了my_box的derefMut返回了可变&mut[i32;2] 函数参数匹配成功

    // f6(a); 无法使用 编译大小未知
    // f7(&my_box);//rust不自动添加&，导致deref不能调用，手动添加&,rust会隐式转换调用deref方法，返回&[i32;2]
    // 然后继续无大小类型转换 &[i32;2] 到&[i32] 函数参数匹配成功，调用函数成功
    // f8(&mut my_box); // rust不自动添加& ，就算添加，只能调用deref ，不能调用derefMut ,所以手动添加&mut ,
    //rust然后进行隐式类型转换，调用了derefMut方法，得到&mut [i32;2]类型。发现函数参数依旧不匹配成功。
    // 进行了无大小类型转换 &mut[i32;2] 得到&mut [i32] ，函数参数匹配成功，调用函数成功
}
不太好说,b站有讲解：Rust方法自动解引用补充和总结（4）_哔哩哔哩_bilibili