fn main() {
    cast();
}

// as 進行的顯示類型強制轉(zhuǎn)換
fn cast() {
    let n: u8 = 123;
    let m: i32 = n as i32;      // 將u8強制轉(zhuǎn)換為i32類型

    println!("u8({})轉(zhuǎn)i32({})", n, m);

    let a = 12345;         // 整型字面值常量是i32類型
    let b: i8 = a as i8;        // 能容納更大數(shù)值的類型i32轉(zhuǎn)容納范圍較小的i8，存在數(shù)據(jù)溢出的風險。

    println!("i32({})轉(zhuǎn)i8({})", a, b);

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

    println!("char({})轉(zhuǎn)u32({})", c, d);       

    let f = 100u8;      
    let h = f as char;      // 只有u8才能轉(zhuǎn)char（相當于只支持ASCII碼的值和字符轉(zhuǎn)換）

    println!("u8({})轉(zhuǎn)char({})", f, h);

    let f = 123.123;    
    let q = f as i32;
    println!("f64({})轉(zhuǎn)i32({})", f, q);


    let mut num = [1, 2, 3];
    let mut y = num.as_mut_ptr();       // 可變的指針類型
    let mut p = y as usize;                // 把指針轉(zhuǎn)為usize類型
    p += 4;                                       // 指針步進一步（i32類型占4字節(jié)，因此加4即可）
    y = p as *mut i32;                            // 將 usize轉(zhuǎn)為指針
    
    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);

// 需要指明轉(zhuǎn)換到的類型是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的類型，導(dǎo)致錯誤。
    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 實現(xiàn) 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實現(xiàn)的。
}

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