Rust: 基础类型补充

在上一篇中，我们介绍了 Rust 基础类型的相关内容，限于篇幅，有些内容没有覆盖到，今天就来做个补充。

一、数字类型字面量

在声明数字类型字面量时，Rust 提供了 类型后缀 的表示方法，只需要在数字后面加上对应的类型即可，另外，Rust 也允许在数字中加入 下划线 符号，可以用来间隔值和类型，也可以用来表示千分位，这个特性大大增强了程序的可读性。

下面我们来演示一下：

// 引入标准库mem模块
use std::mem;

fn main() {
    // 带后缀的字面量
    let a = 1u8;
    let b = 2u32;
    let c = 3i64;
    // 下划线间隔值和类型
    let d = 4_f32;
    // 下划线表示千分位
    let e = 5_000.000_1;
    
    // 求出占用的字节数
    let a_bytes = mem::size_of_val(&a);
    let b_bytes = mem::size_of_val(&b);
    let c_bytes = mem::size_of_val(&c);
    let d_bytes = mem::size_of_val(&d);
    let e_bytes = mem::size_of_val(&e);
    
    println!("a: {} bytes", a_bytes);
    println!("b: {} bytes", b_bytes);
    println!("c: {} bytes", c_bytes);
    println!("d: {} bytes", d_bytes);
    println!("e: {} bytes", e_bytes);
}

可以看到在上面代码中，我们引入了标准库的 mem 模块，利用该模块的 size_of_val() 方法，能够获取到每个数据类型在内存中占用的字节数。

运行代码，打印结果如下：

a: 1 bytes
b: 4 bytes
c: 8 bytes
d: 4 bytes
e: 8 bytes

二、类型别名

Rust 允许我们为类型定义一个别名，在后续的代码中都可以使用这个别名：

// 类型别名强制大驼峰式命名
type Int = i32;
type Long = i64;
type Double = f64;
type Array = [i32; 5];

fn main() {
    // 使用类型别名
    let a: Int = 1;
    let b: Long = 2;
    let c: Double = 3.0;

    println!("{} {} {}", a, b, c);

    // 使用类型别名
    let ary: Array = [1, 2, 3, 4, 5];
    
    println!("{:?}", ary);
}

正如代码注释所示，Rust 强制别名使用大驼峰式风格，即首字母大写。如果我们不习惯这样的风格，则须为别名加上一个属性说明：

// 每个别名都须加上该属性
#[allow(non_camel_case_types)]
type int = i32;

#[allow(non_camel_case_types)]
type long = i64;

fn main() {
    let a: int = 1;
    let b: long = 2;

    println!("{} {}", a, b);
}

三、类型转换

Rust 规定，类型之间须使用 as 关键字进行显式转换。不过，数字和字符串之间互转略有不同，我们且看下面介绍。

1. 布尔类型转数字

布尔类型可以转换为任意的数字类型，结果将会是 0 或 1。但反之却不行，Rust 不允许数字类型向布尔类型转换。

下面是布尔类型转数字的过程：

fn main() {
    let number = false as u8;
    
    // 打印结果 0
    println!("{:?}", number);
    
    let number = true as i32;
    
    // 打印结果 1
    println!("{:?}", number);
}

2. 数字之间互转

前面我们介绍过，数字分为很多种不同的类型，它们之间是可以相互转换的：

fn main() {
    // 默认f64类型浮点数
    let decimal = 65.0;
    
    // 转为u8类型
    let integer = decimal as u8;
    
    // 打印结果 65
    println!("{:?}", integer);
    
    // 转为f32浮点数
    let decimal = integer as f32;
    
    // 打印结果 65.0
    println!("{:?}", decimal);
}

特别要注意的是，如果在转换时，数字超出了目标类型的表示范围，则会出现溢出现象（如果以 debug 模式编译，超出范围时则会引起一个 panic 异常，这一点有所不同）：

fn main() {
    // 超出u8范围的i32数字
    let origin = 256;
    
    // 将会出现溢出
    let result = origin as u8;
    
    // 打印结果 0
    println!("{}", result);
}

3. 数字和字符之间互转

每个字符都有与之对应的数字，所以字符可以转为数字。反过来，数字也可以转为字符，但要注意的是，Rust 规定只有 u8 数字类型可以转为 char 类型。

数字和字符之间的转换代码如下：

fn main() {
    // ASCII字符
    let character = 'a';
    
    // 转为u8类型数字
    let number = character as u8;
    
    // 打印结果 97
    println!("{}", number);
    
    // 中文字符
    let character = '中';
    
    // char转为i32
    let number = character as i32;
    
    // 打印结果 20013
    println!("{}", number);
    
    // 只有u8类型可以转为char类型
    let number = 65u8;
    
    // u8数字转为字符
    let character = number as char;
    
    // 打印结果 'A'
    println!("{:?}", character);
}

4. 数字与字符串之间互转

数字与字符串之间的转换，使用频率非常高，下面我们通过两段代码，来演示一下转换的过程：

数字转字符串：

fn main() {
    let number = 5;
    
    // i32转为String
    let string = number.to_string();
    
    // 打印结果 "5"
    println!("{:?}", string);
}

字符串转数字：

fn main() {
    // &str类型
    let s = "3";

    // parse()时指定目标类型
    let n = s.parse::<i32>().unwrap();
    
    // 打印结果 3
    println!("{:?}", n);
    
    // String类型
    let s = String::from("5");
    
    // 声明变量时 指定目标类型
    let n: i32 = s.parse().unwrap();
    
    // 打印结果 5
    println!("{:?}", n);
}

以上就是类型相关的补充内容了，如果仍有未涉及到的细节，我们后续再做介绍。