跳到主要内容

Rust 数据类型

提示
  1. 基本数据类型：Rust 有四种主要的标量数据类型：整数型、浮点型、布尔型和字符型。
  2. 整数和浮点类型：整数型（i32, u32, etc.）用于存储整数，有无符号版本；浮点型（f32, f64）用于存储小数。
  3. 字符和类型推断：字符型用单引号表示一个字符；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() {
    // 有符号整数类型
    let x: i32 = -200;
    let y: i32 = 200;

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

输出：

x = -200
y = 200

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

无符号整数型​

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

fn main() {
    // 无符号整数类型
    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 中整数数据类型的分类​

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

大小有符号无符号
8 位i8u8
16 位i16u16
32 位i32u32
64 位i64u64
128 位i128u128

2. Rust 浮点型​

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

  • f32
  • f64

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

让我们看一个例子，

let x: f32 = 3.1;

这里，f32 是浮点值的类型声明。在这个例子中，x 被赋值为浮点数 3.1。

示例：浮点数据类型​

fn main() {
    // f32 浮点类型
    let x: f32 = 3.1;

    // f64 浮点类型
    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。例如，

// 布尔值 true
let flag1: bool = true;

// 布尔值 false
let flag2: bool = false;

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

示例：布尔类型​

fn main() {
    // 布尔类型
    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() {
    // 字符类型
    let character: char = 'z';

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

输出：

character = z

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

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

fn main() {
    // 字符类型
    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';

这里，'5' 不是整数，它是一个字符，因为我们把它放在了单引号里。

Rust 中的类型推断​

到目前为止，我们在声明变量时都提到了数据类型。然而，在 Rust 中，我们可以在不声明数据类型的情况下创建变量。例如，

let x = 51;

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

让我们看一个例子，

fn main() {
    let x = 51;

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

输出：

x = 51

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

最后于 更新