Rust 基本数据类型

Rust 是一个静态的严格数据类型的语言，每个数值都有唯一的数据类型。

Rust 语言在赋值时并不强制要求指定变量的数据类型，Rust 编译器可以根据分配给它的值自动推断变量的数据类型。

Rust 语言基本数据类型包括布尔型、字符型、整数型 和 浮点型。

1. 声明和定义变量

Rust 语言使用 let 关键字来声明和定义一个变量。

1）Rust 语言中声明变量的语法

let variable_name = value;

2) Rust 语言中声明变量的范例

fn main() {
    let company_string = "TutorialsPoint";  // string 字符串类型
    let rating_float = 4.5;                 // float 类型
    let is_growing_boolean = true;          // boolean 类型
    let icon_char = '♥';                    //unicode character 类型

    println!("company name is:{}",company_string);
    println!("company rating on 5 is:{}",rating_float);
    println!("company is growing :{}",is_growing_boolean);
    println!("company icon is:{}",icon_char);
}

运行结果：

company name is:TutorialsPoint
company rating on 5 is:4.5
company is growing :true
company icon is:♥

2. 布尔型

Rust 使用 bool 表示布尔数据类型，布尔型共有两个值 true 和 false。

Rust 声明布尔型变量的范例：

fn main() {
    let t = true;
    let f: bool = false;

    println!("t is {} and f is {}", t, f);
}

运行结果：

t is true and f is false

3. 字符型

字符是指单个字符或字，是字符串的基本组成部分。Rust 使用 char 表示字符数据类型，代表单个 Unicode 字符，大小为 4 个字节。

Unicode 值的范围从 U+0000 到 U+D7FF 和 U+E000 到 U+10FFFF（包括两端）。

由于中文编码有两种（GBK 和 UTF-8），所以代码中使用中文字符串有可能导致乱码的出现，这是因为源程序与命令行的文字编码不一致，所以在 Rust 中字符串和字符都必须使用 UTF-8 编码，否则编译器会报错。

Rust 声明字符型变量的范例：

fn main() {
    let special_character = '@'; 
    let alphabet:char = 'A';
    
    println!("special_character is {}", special_character);
    println!("alphabet is {}", alphabet);
}

运行结果：

special_character is @
alphabet is A

4. 整数型

整数型简称整型，指没有小数点的数字，比如 0，1，-1，-2，9999999 等，而 0.0 、1.0 和 -1.11 等都不是整数。

整型按照存储长度和有无符号分为以下几类：

整型有一种特殊类型 arch，它是由 CPU 架构决定的大小的整型类型，在 x86 机器上为 32 位，在 x64 机器上为 64 位。

整数的表述方法有以下几种：

Rust 声明整型变量的范例：

fn main() {
    // 默认 i32 
    let result = 10;   

    // 无符号 32 位整形
    let age:u32 = 20;   

    // 下划线可以省略，分割是为了增强可读性
    let bignum:i64 = 98_5688;

    // 由系统架构决定 32 位 或者 64 位有符号整形
    let mark:isize = 10;

    println!("result is {}", result);
    println!("age is {}", age);
    println!("bignum is {}", bignum);
    println!("mark is {}", mark);
}

运行结果：

result is 10
age is 20
bignum is 985688
mark is 10

以上案例说明：

• 不显示声明整数类型，默认数据类型为 i32。
• 整数中间可以用下划线连接，可以忽略，目的是增强可读性，就像科学记数法中的逗号。
• isize 和 usize 由当前系统的架构决定长度。

5. 浮点数型

浮点型就是带有小数点的数字。Rust 区分整型和浮点型的唯一指标就是有没有小数点。

Rust 中的整型和浮点型是严格区分的，不能相互转换。也就是说，我们不能将 0.0 赋值给任意一个整型，也不能将 0 赋值给任意一个浮点型。

按照存储大小，我们把浮点型划分为 f32 和 f64。其中 f64 是默认的浮点类型。

• f32 又称为 单精度浮点型。
• f64 又称为 双精度浮点型，它是 Rust 默认的浮点类型。

Rust 声明整型变量的范例：

fn main() {
    // 默认是 f64 
    let result = 10.00;        
      
    // 单精度浮点型 
    let interest:f32 = 8.35;

    // 双精度浮点型
    let cost:f64 = 15000.600; 

    println!("result is {}", result);
    println!("interest is {}", interest);
    println!("cost is {}", cost);
}

运行结果：

result is 10
interest is 8.35
cost is 15000.6

6. 不允许类型自动转换

Rust 中的数字类型与 C/C++ 中不同的是 Rust 语言不允许类型自动转换。

例如，把一个 整型 赋值给一个 浮点型 是会报错的。

不允许类型自动转换的范例:

fn main() {
   let interest:f32 = 8;   // integer assigned to float variable
   println!("interest is {}",interest);
}

编译上面的代码，会抛出 mismatched types error 错误。

error[E0308]: mismatched types
   --> main.rs:2:22
   |
 2 | let interest:f32=8;
   |    ^ expected f32, found integral variable
   |
   = note: expected type `f32`
      found type `{integer}`
error: aborting due to previous error(s)

7. 数字可读性分隔符 _

为了方便阅读超大的数字，Rust 语言允许使用一个 虚拟的分隔符 也就是 下划线（ _ ） 来对数字进行可读性分隔符。

比如为了提高 50000 的可读性，我们可以写成 50_000 。

Rust 语言会在编译时移除数字可读性分隔符 _。

分隔符 _ 范例：

我们写几个例子来演示下 数字分隔符，从结果中可以看出，分隔符对数字没有造成任何影响。

fn main() {
   let float_with_separator = 11_000.555_001;
   println!("float value {}",float_with_separator);

   let int_with_separator = 50_000;
   println!("int value {}",int_with_separator);
}

编译运行上面的代码，输出结果如下：

float value 11000.555001
int value 50000