# 变量绑定

## 简单的例子

 1 2 3 4  //如果不使用会有警告 let noisy_unused_variable = 2u32; //前面添加了下划线就不会有警告 let _noisy_unused_variable = 2u32; 

## Mutability

 1  let mut mutable_binding = 1; 

 1 2 3 4 5 6 7 8  fn main() { let a = 3; { let a = 4; println!("{}", a); } println!("{}", a); } 

## cast(强制转换)

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48  // Suppress all warnings from casts which overflow. #![allow(overflowing_literals)] fn main() { let decimal = 65.4321_f32; // Error! No implicit conversion let integer: u8 = decimal; // FIXME ^ Comment out this line // Explicit conversion let integer = decimal as u8; let character = integer as char; println!("Casting: {} -> {} -> {}", decimal, integer, character); // when casting any value to an unsigned type, T, // std::T::MAX + 1 is added or subtracted until the value // fits into the new type // 1000 already fits in a u16 println!("1000 as a u16 is: {}", 1000 as u16); // 1000 - 256 - 256 - 256 = 232 // Under the hood, the first 8 least significant bits (LSB) are kept, // while the rest towards the most significant bit (MSB) get truncated. println!("1000 as a u8 is : {}", 1000 as u8); // -1 + 256 = 255 println!(" -1 as a u8 is : {}", (-1i8) as u8); // For positive numbers, this is the same as the modulus println!("1000 mod 256 is : {}", 1000 % 256); // When casting to a signed type, the (bitwise) result is the same as // first casting to the corresponding unsigned type. If the most significant // bit of that value is 1, then the value is negative. // Unless it already fits, of course. println!(" 128 as a i16 is: {}", 128 as i16); // 128 as u8 -> 128, whose two's complement in eight bits is: println!(" 128 as a i8 is : {}", 128 as i8); // repeating the example above // 1000 as u8 -> 232 println!("1000 as a u8 is : {}", 1000 as u8); // and the two's complement of 232 is -24 println!(" 232 as a i8 is : {}", 232 as i8); } 

## 基本变量大小

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17  fn main() { // Suffixed literals, their types are known at initialization let x = 1u8; let y = 2u32; let z = 3f32; // Unsuffixed literal, their types depend on how they are used let i = 1; let f = 1.0; // size_of_val returns the size of a variable in bytes println!("size of x in bytes: {}", std::mem::size_of_val(&x)); println!("size of y in bytes: {}", std::mem::size_of_val(&y)); println!("size of z in bytes: {}", std::mem::size_of_val(&z)); println!("size of i in bytes: {}", std::mem::size_of_val(&i)); println!("size of f in bytes: {}", std::mem::size_of_val(&f)); } 

## alies(变量重新命名)

 1  type Inch = u64;