29.rust类型转换.rs

妖狐艹你老母 2022-11-06 11:56 309阅读 0赞

/*
    1.基本类型可以通过显示类型转换机制(as)来实现相互之间的转换。
    2.Rust通过使用trait来处理定制类型(enum、struct)之间的类型转换。
    3.通用的类型转换一般使用的trait为From和To。
    
    Rust孤儿原则:
    在声明trait和impl trait的时候，Rust规定了一个Orphan Rule(孤儿规则)：impl块要么与trait的声明在同一个的crate中，要么与类型的声明在同一个crate中。
    也就是说，不能在一个crate中，针对一个外部的类型，实现一个外部的trait。
    */
    
    fn test_1() {
        /*
        as 运算符有点像 C 中的强制类型转换，区别在于，它只能用于原始类型(i32 、i64 、f32 、
        f64 、 u8 、 u32 、 char 等类型),并且它是安全的
        */
    
        //在 Rust 中，不同的数值类型是不能进行隐式转换的
        //let b: i64 = 1i64;  会出现编译错误，提示无法进行类型转换。
        let b: i64 = 1i32 as i64;
        let c:i32 = 123.456f32 as i32;
    
        //为什么它是安全的？像这种不安全的转换编译不过
        //let b = 1i32 as char;Rust 会拒绝转换，这也避免了运行时错误。
    }
    
    fn test_2() {
        /*
        From和Into trait是成对的存在，它表示了一个类型A通过怎样的处理能变成类型B，通常我们只需要为类
        型B实现From trait的from（以类型A为参数）方法，就自动获得了由类型A的into方法转换成类型B。
        */
    
        use std::convert::From;
        //use std::convert::Into;
    
        #[derive(Debug)]
        struct Square {
            width: i32,
            height: i32,
        }
        impl From<i32> for Square {
            fn from(size: i32) -> Self {
                Square {
                    width: size,
                    height: size,
                }
            }
        }
        impl Square {
            fn area(&self) -> i32 {
                self.width * self.height
            }
        }
        /*
        通过上面的示例，我们很容看到，要将类型A转换成类型B，可以为类型B实现From trait的from(A)方法，将类型A作为参数实现转换；
        同时在实现了类型B的From trait后，类型A可以直接调用into()方法转换成类型B。总结下来可以用以下伪代码作为示意：
        let b = B::from(A);
        let b:B = A.into();
        为方便记忆，可以简化成一句：translate A to B,impl B how to from A.
        */
    
        let s = Square::from(10_i32);
        println!("s is {:?},area is {}", s, s.area());
        let a: Square = 20.into(); //这里的Square类型需要显示标注
        println!("a is {:?}", a);
    }
    
    fn test_3() {
        /*
        TryFrom与TryInto
        与From和Into类似，TryFrom和TryInto是类型之间转换的通用的trait。
        与From和Into不同的是，TryFrom和TryInto被用来处理可能出现失败的转换，因而，他们返回的是Result类型。
        */
        use std::convert::TryFrom;
        use std::convert::TryInto;
    
        #[derive(Debug, PartialEq)]
        struct DOT {
            number: u128,
        }
    
        impl TryFrom<u128> for DOT {
            type Error = ();
            fn try_from(size: u128) -> Result<DOT, Self::Error> {
                Ok(DOT {
                    number: size,
                })
            }
        }
    
        impl TryFrom<DOT> for u128 {
            type Error = ();
            fn try_from(dot: DOT) -> Result<u128, Self::Error> {
                Ok(dot.number)
            }
        }   
    
        let d1 = DOT{number:100};    
        let d2 = DOT{number:100};
        let t1 = DOT::try_from(8u128);
        let t2 = u128::try_from(d2);    
        let t3:Result<u128,_> = DOT::try_into(d1);//自己结构体是DOT,try_into把自己向某种类型转换，你不告诉我类型我怎么知道向什么方向转？所以必须声明返回类型
        let t4:Result<DOT,_>  = u128::try_into(12u128);//同上
        
        let d1 = DOT{number:100};    
        let d2 = DOT{number:100};
        let t1:Result<DOT,_> = TryFrom::<u128>::try_from(8u128);
        let t2:Result<u128,_> = TryFrom::<DOT>::try_from(d1);
        let t3 = TryInto::<u128>::try_into(d2);
        let t4 = TryInto::<DOT>::try_into(8u128);
    }
    
    fn test_4() {
        /*
        转换为字符串
        为了把一个类型转为String类型，我们只要实现traitToString就可以了。
        然而，我们并不会直接的这样做，我们应该实现traitfmt::Display，这个trait会自动提供ToString，而且会可以打印这个类型。
        */
        use std::fmt;
    
        struct Circle {
            radius: i32,
        }
    
        impl fmt::Display for Circle {
            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                write!(f, "Circle of radius {}", self.radius)
            }
        }
    
        let circle = Circle { radius: 6 };
        println!("{}", circle.to_string());
    }
    
    fn test_5() {
        /*
        解析一个字符串
        一个最常见的类型转换是把一个字符串转换为一个数字。
        实现这个功能的常用方法是使用parse方法，并且使用rust类型类型推断或者使用turbofish语法来指定类型。我们会在如下的示例代码中来使用这两个方法。
        只要为该类型实现了FromStr，就可以实现从字符串到指定类型的转换。
        标准库中的很多类型都实现了该trait。如果要在用户定义的类型的上获得该功能，只要实现FromStr就可以了。
        */
        // let parsed: i32 = "5".parse().unwarp();
        // let turbo_parsed = "10".parse::<i32>().unwarp();
        // let sum = parsed + turbo_parsed;
        // println!("Sum: {:?}", sum);
    }
    
    //解引用强制多态
    fn test_6() {
        fn print(message: &str) {
            println!("{}", message);
        }
        let message: String = "message".to_string();
        print(&message);
    
        /*
        print 的形参是 &str 类型，然而在 main 中，我传递却是一个 &String 类型的实参。明显，这两个类型不相同！！Rust 为什么会通过这样的代码呢？
        没错，这就是 Rust 的 解引用强制多态。
        首先，需要了解一个 Deref Trait 。
        #[lang = "deref"]
        pub trait Deref {
            type Target: ?Sized;
            #[must_use]
            fn deref(&self) -> &Self::Target;
        }
        deref 方法返回一个 &Target 类型的引用。
        回忆一下 Rust 中的解引用语法，当 ref 是一个引用或智能指针时，我们可以使用 *ref 的方式解引用。这是类似一个语法糖，对于 *ref 这种写法，写全应该时 *(ref.deref()) 。
        回想 Box<T> 的使用，Box<T> 实现了 Deref ，它的 deref 方法返回 &T 的引用，然后使用解引用运算符 * ，我们顺利拿到一个 T 类型的数据。也就是，你可以通过实现 Deref 以重载解引用运算符。
        Deref 和这节的内容有什么关系呢？
        当 T 实现了 Deref<Target=U> 时，对于需要 &U 的地方，你可以提供一个 &T 类型的数据，Rust会为你自动调用 deref 方法，而这个过程可以重复多次。
        比如，我自定义类型 P 实现了 Deref<Target=String> ,那么可以把 &P 类型变量传递给一个 &str 类型变量。&P -> &String -> &str ,伪代码： &P.deref().deref() 。
        回到这节开头的例子，print(&message) 相当于 print((&message).deref()) ，正好是一个 &str 类型。
        */
    }
    
    fn main() {
        test_1();
        test_2();
        test_3();
        test_4();
        test_5();
        test_6();
    }