变量和数据类型

在编程中，变量是存储数据的容器，而数据类型则定义了这些数据的形式和操作方式。理解变量和数据类型是掌握任何编程语言的基础。在本教程中，我们将深入探讨 Rust 中的变量和数据类型。

1. 变量

1.1 变量的定义

在 Rust 中，变量使用 let 关键字来定义。默认情况下，Rust 中的变量是不可变的（immutable），这意味着一旦变量被赋值，它的值就不能再改变。

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
}

在这个例子中，x 是一个不可变的变量，它的值是 5。尝试修改 x 的值会导致编译错误。

1.2 可变变量

如果你需要一个可以改变的变量，可以使用 mut 关键字。

fn main() {
    let mut y = 10;
    println!("The initial value of y is: {}", y);
    y = 20;
    println!("The new value of y is: {}", y);
}

在这个例子中，y 是一个可变变量，它的值可以从 10 变为 20。

1.3 变量遮蔽

Rust 允许你使用相同的变量名重新定义一个变量，这被称为变量遮蔽（shadowing）。

fn main() {
    let z = 30;
    println!("The value of z is: {}", z);
    let z = z + 1;
    println!("The new value of z is: {}", z);
}

在这个例子中，z 被重新定义，并且它的值从 30 变为 31。

2. 数据类型

Rust 是一种静态类型语言，这意味着每个变量在编译时都必须有一个明确的数据类型。Rust 提供了多种数据类型，包括标量类型和复合类型。

2.1 标量类型

标量类型表示单个值。Rust 有四种主要的标量类型：整数、浮点数、布尔值和字符。

2.1.1 整数类型

Rust 支持多种整数类型，包括有符号和无符号的整数。常见的整数类型有：

• i8, i16, i32, i64, i128：有符号整数
• u8, u16, u32, u64, u128：无符号整数
• isize, usize：取决于系统架构的整数类型

fn main() {
    let a: i32 = 100;
    let b: u8 = 255;
    println!("a: {}, b: {}", a, b);
}

2.1.2 浮点数类型

Rust 有两种浮点数类型：f32 和 f64。

fn main() {
    let c: f32 = 3.14;
    let d: f64 = 2.71828;
    println!("c: {}, d: {}", c, d);
}

2.1.3 布尔类型

布尔类型只有两个可能的值：true 和 false。

fn main() {
    let e: bool = true;
    let f: bool = false;
    println!("e: {}, f: {}", e, f);
}

2.1.4 字符类型

字符类型表示单个 Unicode 字符，使用单引号 ' 包围。

fn main() {
    let g: char = 'R';
    println!("g: {}", g);
}

2.2 复合类型

复合类型可以将多个值组合成一个类型。Rust 有两种基本的复合类型：元组（tuple）和数组（array）。

2.2.1 元组

元组是一个可以包含不同类型元素的集合。元组的长度是固定的，一旦定义就不能改变。

fn main() {
    let h: (i32, f64, char) = (42, 3.14, 'R');
    println!("h: {:?}", h);
}

你可以通过解构（destructuring）来访问元组中的元素：

fn main() {
    let h: (i32, f64, char) = (42, 3.14, 'R');
    let (x, y, z) = h;
    println!("x: {}, y: {}, z: {}", x, y, z);
}

2.2.2 数组

数组是一个包含相同类型元素的集合。数组的长度是固定的，一旦定义就不能改变。

fn main() {
    let i: [i32; 5] = [1, 2, 3, 4, 5];
    println!("i: {:?}", i);
}

你可以通过索引来访问数组中的元素：

fn main() {
    let i: [i32; 5] = [1, 2, 3, 4, 5];
    println!("The third element is: {}", i[2]);
}

3. 实践练习

3.1 练习1：变量和数据类型

编写一个 Rust 程序，定义以下变量并打印它们的值：

• 一个 i32 类型的变量 a，值为 100
• 一个 f64 类型的变量 b，值为 3.14159
• 一个 bool 类型的变量 c，值为 true
• 一个 char 类型的变量 d，值为 'R'
• 一个包含三个元素的元组 e，元素类型分别为 i32, f64, char
• 一个包含五个元素的数组 f，元素类型为 i32

3.2 练习2：变量遮蔽

编写一个 Rust 程序，使用变量遮蔽来改变一个变量的值。定义一个变量 x，初始值为 10，然后使用变量遮蔽将其值改为 20，最后打印 x 的值。

3.3 练习3：可变变量

编写一个 Rust 程序，定义一个可变变量 y，初始值为 5，然后将其值增加 10，最后打印 y 的值。

4. 总结

在本教程中，我们学习了 Rust 中的变量和数据类型。我们了解了如何定义不可变和可变变量，以及如何使用变量遮蔽。我们还探讨了 Rust 中的标量类型和复合类型，包括整数、浮点数、布尔值、字符、元组和数组。通过实践练习，我们巩固了这些概念。

在接下来的教程中，我们将深入探讨 Rust 中的控制流、所有权系统、借用和引用等内容。希望你能继续保持学习的热情，掌握 Rust 编程的精髓！