Question

不支持隐式转换，可用 as 进行安全类型转换（safe casting）。

fn test(x: i64) {
  println!("{:?}", x);
}

fn main() {
  let x: i32 = 100;
  
  let _y = x as i64;
  let _z = x as i64 as i128;

  test(x as i64);
}

数字转换：

• 相同大小（i32 -> u32）。
• 大到小（u32 -> u8），截短（truncate）。
• 小到大（u8 -> u32），扩展（zero-extend or sign-extend）。
• 浮点数到整数，舍弃小数部分（round）。
• 整数到浮点数。
• 从 f32 到 f64，无损。
• 从 f64 到 f32，近似值。

fn main() {
  let x = 1.66;
  let y = x as i32;

  assert_eq!(y, 1);
}

引用转换

可将引用转换为指针，或改为不可变引用。

• &mut T -> &T : 安全转换。（反之不行，invalid cast）
• &mut T or &T -> ptr : 原始指针操作需要 unsafe 保证。

fn main() {
  let mut x = 100;
  let mr = &mut x;   

  // let _r = &x;
  //      ^^ immutable borrow occurs here

  // ----------------------------------------
  
  // &mut T -> &T
  let r = mr as &i32;   // 转换，非借用。
  assert_eq!(100, *r);

  // &mut T -> *const T
  let p = mr as *const i32;     
  assert_eq!(100, unsafe{ *p });

  // &mut T -> *mut T
  let mp = mr as *mut i32;    
  unsafe {
    *mp += 1;
    assert_eq!(101, x);
  }
}

自动转换

由 Deref 特征（trait）实现的自动转换。

fn main() {
  let s = String::from("abc");
  let rs: &str = &s;      // &String to &str

  println!("{:?}", rs);
}

fn main() {
  let v = vec![1, 2, 3];
  let s: &[i32] = &v;      // &Vec<T> to &[T]

  println!("{:?}", s);
}

fn main() {
  let b = Box::<i32>::new(100);
  let r: &i32 = &b;        // &Box<T> to &T

  assert_eq!(*r, 100);
}

• 非安全类型转换： std::mem::transmute 。
• 自定义类型转换： std::convert::From 。

Casting Between Types