Rust 数据类型

我们在 Rust 中使用数据类型来确定与变量相关联的数据的类型。例如：

let alphabet: char;

在这里，char 是数据类型，它指定 alphabet 变量只能存储字符数据。

Rust 中的数据类型

Rust 中有四种主要的数据类型，也称为标量类型

• 整数
• 浮点数
• 布尔型
• 字符

1. 整数类型

在 Rust 中，我们使用整数数据类型来存储整数。例如：

let number: i32 = 200;

在这里，我们创建了一个类型为 i32（整数）的 number 变量，并存储了值 200。

整数类型 i32 有两个组成部分：

• i - 指定有符号整数类型（可以存储正值或负值）
• 32 - 数据类型的大小（在内存中占用 32 位空间）

Rust 中的有符号整数类型

fn main() {
    // Signed integer type 
    let x: i32 = -200;
    let y: i32 = 200;

    println!("x = {}", x);
    println!("y = {}", y);
}

输出

x = -200
y = 200

在这里，我们定义了两个整数 x 和 y，它们的值分别为 -200 和 200，并将它们打印到屏幕上。

无符号整数类型

我们还可以创建只能存储正整数值的变量。例如：

fn main() {
    // Unsigned integer type
    let x: u32 = 300;

    println!("x = {}", x);
}

输出

x = 300

在这里，u32 指定 x 变量只能存储正值。u 指定无符号整数类型。

如果我们尝试将负数存储到 u32 类型变量中，我们会收到一个错误。例如：

fn main() {
    let x: u32 = -200;

    println!("x = {}", x);
}

错误

error[E0600]: cannot apply unary operator `-` to type `u32`
 --> main.rs:2:18
  |
2 |   let x: u32 = -200;
  |                ^^^^ cannot apply unary operator `-`
  |
  = note: unsigned values cannot be negated

Rust 中整数数据类型的类别

根据数据的大小，我们可以将有符号和无符号整数类型进一步分为不同类别

2. Rust 浮点数类型

浮点数类型用于存储小数（带小数点的数字）。在 Rust 中，浮点数数据类型可分为：

• f32
• f64

在这里，f 字符表示浮点数，32 和 64 表示位数。

让我们看一个例子：

let x: f32 = 3.1;

在这里，f32 是浮点值的类型声明。在这种情况下，x 被赋值为浮点值 3.1。

示例：浮点数数据类型

fn main() {
    // f32 floating point type
    let x: f32 = 3.1;

    // f64 floating point type
    let y: f64 = 45.0000031;

    println!("x = {}", x);
    println!("y = {}", y);
}

输出

x = 3.1
y = 45.0000031

注意： f32 是单精度浮点类型，而 f64 是双精度类型。使用双精度时，f64 可以存储更大十进制范围的数据，并且被认为更精确。

3. Rust 布尔类型

在 Rust 中，布尔数据类型可以有两个可能的值：true 或 false。例如：

// boolean value true
let flag1: bool = true;

// boolean value false
let flag2: bool = false;

在这里，我们使用了 bool 关键字来表示 Rust 中的布尔类型。

示例：布尔类型

fn main() {
    // boolean type
    let flag1: bool = true;
    let flag2: bool = false;

    println!("flag1 = {}", flag1);
    println!("flag2 = {}", flag2);
}

输出

flag1 = true
flag2 = false

注意： 布尔值经常在条件语句中使用，例如 if/else 表达式。

4. Rust 字符类型

Rust 中的字符数据类型用于存储单个字符。例如：

fn main() {
    // char type
    let character: char = 'z';

    println!("character = {}", character);
}

输出

character = z

在这里，char 表示字符类型变量，我们使用单引号来表示一个字符。

我们还可以使用字符类型存储特殊字符，如 $、@、& 等。例如：

fn main() {
    // char type
    let character: char = 'z';
    let special_character: char = '$';

    println!("character = {}", character);
    println!("special_character = {}", special_character);
}

输出

character = z
special_character = $

let numeric_character: char = '5';

Rust 中的类型推断

到目前为止，我们在变量声明时都提到了数据类型。但是，在 Rust 中，我们可以创建变量而不提及数据类型。例如：

let x = 51;

在这种情况下，Rust 通过查看变量 x 的值自动识别数据类型，并将其与变量关联。这个过程称为类型推断。

让我们看一个例子，

fn main() {
    let x = 51;

    println!("x = {}", x);
}

输出

x = 51

在这里，您可以看到我们没有提及 x 变量的数据类型。这是因为 Rust 将根据值 51 自动将 i32 设置为类型（整数变量的默认类型）。