rust类型转换的实现

fn main() {
    cast();
}

// as 进行的显示类型强制转换
fn cast() {
    let n: u8 = 123;
    let m: i32 = n as i32;      // 将u8强制转换为i32类型

    println!("u8({})转i32({})", n, m);

    let a = 12345;         // 整型字面值常量是i32类型
    let b: i8 = a as i8;        // 能容纳更大数值的类型i32转容纳范围较小的i8，存在数据溢出的风险。

    println!("i32({})转i8({})", a, b);

    let c = '我';          // char类型
    let d = c as u32;

    println!("char({})转u32({})", c, d);       

    let f = 100u8;      
    let h = f as char;      // 只有u8才能转char（相当于只支持ASCII码的值和字符转换）

    println!("u8({})转char({})", f, h);

    let f = 123.123;    
    let q = f as i32;
    println!("f64({})转i32({})", f, q);


    let mut num = [1, 2, 3];
    let mut y = num.as_mut_ptr();       // 可变的指针类型
    let mut p = y as usize;                // 把指针转为usize类型
    p += 4;                                       // 指针步进一步（i32类型占4字节，因此加4即可）
    y = p as *mut i32;                            // 将 usize转为指针
    
    unsafe {                                        
        println!("{}", *y);                       // 在unsafe模块中操作指针
    }
}

let s = String::from("qwert");
println!("s={s}");

#[derive(Debug)]
#[allow(unused)]
struct Number {
    value: i32,
}

impl From<i32> for Number {
    fn from(item: i32) -> Self {
        Number { value: item }
    }
}

let num = Number::from(30);
println!("My number is {:?}", num);

// 需要指明转换到的类型是Number
let a: Number = 1.into();
println!("My number is {:?}", a);

pub fn catsing(){
    let b = 123;
    let a: u8 = b.try_into().unwrap();          // try_into
    println!("{a}");

    let b:i32 = 12345;                // 有一点非常奇怪，那就是必须显示声明b的类型，否则编译器无法推断e的类型，导致错误。
    let _a: u8 = match b.try_into() {           // try_into
        Ok(v) => v,
        Err(e) => {
            println!("{:?}", e.to_string());
            0
        }
    };
}

#[derive(Debug, PartialEq)]
struct EvenNumber(i32);

impl TryFrom<i32> for EvenNumber {
    type Error = ();
    fn try_from(value: i32) -> Result<Self, Self::Error> {
        if value % 2 == 0 {
            Ok(EvenNumber(value))
        } else {
            Err(())
        }
    }
}

// TryFrom
assert_eq!(EvenNumber::try_from(8), Ok(EvenNumber(8)));
assert_eq!(EvenNumber::try_from(5), Err(()));

// TryInto
let result: Result<EvenNumber, ()> = 8i32.try_into();
assert_eq!(result, Ok(EvenNumber(8)));
let result: Result<EvenNumber, ()> = 5i32.try_into();
assert_eq!(result, Err(()));

pub fn format_string() {
    use std::fmt;

    struct Circle {
        radius: i32
    }

    impl fmt::Display for Circle {      // 为 Circle 实现 Display trait
        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());     // to_string是由Display trait实现的。
}

pub fn to_stirng() {
    struct Circle {
        radius: i32
    }

    impl ToString for Circle {
        fn to_string(&self) -> String {
            format!("Circle of radius {:?}", self.radius)
        }
    }

    let circle = Circle { radius: 6 };
    println!("{}", circle.to_string());
}

pub fn string_to_number(){
    let num = "12345";
    let num = num.parse::<i32>().unwrap();      // turbo fish写法
    println!("{}", num);

    let num = "12345";
    let num: u64 = num.parse().unwrap();            // 显示声明类型写法
    println!("{}", num);
}

fn do_stuff<T: Clone>(value: &T) {
    let cloned = value.clone();
}

fn do_stuff<T>(value: &T) {
    let cloned = value.clone();
}

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

fn clone_containers<T>(foo: &Container<i32>, bar: &Container<T>) {
    let foo_cloned = foo.clone();
    let bar_cloned = bar.clone();
}

impl<T> Clone for Container<T> where T: Clone {
    fn clone(&self) -> Self {
        Self(Arc::clone(&self.0))
    }
}

impl<T> Clone for Container<T> {
    fn clone(&self) -> Self {
        Self(Arc::clone(&self.0))
    }
}