技术

[ Rust笔记 二] 基础-基本类型

bool

1
2
3
4
5
6
7
8
9
10
11
12
13
14
  fn main() {
      let x = true;
      let y: bool = !x; // 取反运算
      let z = x && y;    // 逻辑与，带短路功能
      println!("{}", z);
      let z = x || y;    // 逻辑或，带短路功能
      println!("{}", z);
      let z = x & y;     // 按位与，不带短路功能
      println!("{}", z);
      let z = x | y;     // 按位或，不带短路功能
      println!("{}", z);
let z = x ^ y;     // 按位异或，不带短路功能
      println!("{}", z);
  }

char

1
2
3
4
5
6
7
8
9
10
11
12
13
   unicode
 都是4个字节
    let love = '❤';       // 可以直接嵌入任何unicode字符  
转义符
 let c1 = '\n';         // 换行符
    let c2 = '\x7f';       // 8 bit字符变量
    let c3 = '\u{7FFF}';   // unicode字符

   都是1个字节
  let x :u8 = 1;
     let y :u8 = b'A';
     let s :&[u8;5] = b"hello";
     let r :&[u8;14] = br#"hello \n world"#;

整数类型

i8 u8, i16 u16 … i128, u128, isize, usize 

1
2
3
4
5
6
7
8
9
let var1 : i32 = 32;      // 十进制表示
   let var2 : i32 = 0xFF;    // 以0x开头代表十六进制表示
   let var3 : i32 = 0o55;    // 以0o开头代表八进制表示
   let var4 : i32 = 0b1001;  // 以0b开头代表二进制表示
let var6 = 123usize;       // i6变量是usize类型
   let var7 = 0x_ff_u8;       // i7变量是u8类型
   let var8 = 32;             // 不写类型，默认为 i32 类型

let var5 = 0x_1234_ABCD;  // 使用下划线分割数字，不影响语义，但是极大地提升了阅读体验。

（pointer size）isize和usize占用字节数和32位或者64位系统有关系

浮点类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
   let f1 = 123.0f64;         // type f64
   let f2 = 0.1f64;           // type f64
   let f3 = 0.1f32;           // type f32
   let f4 = 12E+99_f64;      // type f64 科学计数法
   let f5 : f64 = 2.;         // type f64 


enum FpCategory {
       Nan,
       Infinite,
       Zero,
       Subnormal,
       Normal,
   }

指针类型

Box 指向类型T的，具有所有权的指针，有权释放内存

&T 指向类型T的借用指针，也称为引用，无权释放内存，无权写数据

&mut T 指向类型T的mut型借用指针， 无权释放指针，有权写数据

*const T 指向类型T的只读裸指针，没有生命周期信息，无权写数据

*mut T 指向类型T的可读写裸指针，没有生命周期信息，有权写数据

智能指针

当做指针使用的类型
Rc 指向类型T的引用计数指针，共享所有权，线程不安全

Arc 指向类型T的原子型引用计数指针，共享所有权，线程安全

Cow<’a, T> Clone-on-write，写时复制指针。可能是借用指针，也可能是具有所有权的指针

类型转换

    fn main() {
        let var1 : i8 = 41;
        let var2 : i16 = var1; //编译报错，i8类型的变量无法向i16类型的变量赋值 
    }
    
    fn main() {
        let var1 : i8 = 41;
        let var2 : i16 = var1 as i16;
    }
    
    fn main() {
        let i = 42;
        // 先转为 ＊const i32，再转为 ＊mut i32
        let p = &i as ＊const i32 as ＊mut i32;
        println!("{:p}", p);
    }

e as u 转换

Integer or Float -> Integer or Float

c-like enum -> Integer

bool or char -> Integer

u8 -> char

*T -> *V where V: Sized *

*T where T: Sized -> Numeric type

Integer type -> *V where V: Sized

&[T; n] -> *const T

Function pointer -> *V where V: Sized

Function pointer -> Integer

更复杂的类型转换，使用标准款的From Into等trait