Rust
Rust 核心基础数据类型与变量系统详解
介绍 Rust 语言的基础数据类型与变量系统。涵盖标量类型（整数、浮点数、布尔值、字符）及复合类型（元组、数组、切片、字符串）。详细讲解变量声明、可变性控制、作用域规则及 Shadowing 机制。同时阐述类型转换方法（as 关键字、From/Into Traits），并通过几何计算、成绩处理、CSV 解析三个实战案例演示应用。最后总结常见问题及解决方案，为系统级编程打下基础。
介绍 Rust 语言的基础数据类型与变量系统。涵盖标量类型（整数、浮点数、布尔值、字符）及复合类型（元组、数组、切片、字符串）。详细讲解变量声明、可变性控制、作用域规则及 Shadowing 机制。同时阐述类型转换方法（as 关键字、From/Into Traits），并通过几何计算、成绩处理、CSV 解析三个实战案例演示应用。最后总结常见问题及解决方案，为系统级编程打下基础。
💡 三大核心难点：
mut（可变性）的本质区别⚠️ 三大高频错误点：
Rust 的数据类型分为标量类型（单个值）和复合类型（多个值的组合），所有变量在编译期必须明确类型（强静态类型语言）。
Rust 提供了10 种整数类型，分为无符号整数（以 u 开头，只能表示正数和 0）和有符号整数（以 i 开头，能表示正负整数），每种类型的位数从 8 位到 128 位不等。
📊 整数类型表：
| 长度（位） | 无符号类型 | 有符号类型 | 最小值 | 最大值 |
|---|---|---|---|---|
| 8 | u8 | i8 | 0 | 255 |
| 16 | u16 | i16 | -32768 | 32767 |
| 32 | u32 | i32 | -2³¹ | 2³¹-1 |
| 64 | u64 | i64 | -2⁶³ | 2⁶³-1 |
| 128 | u128 | i128 | -2¹²⁷ | 2¹²⁷-1 |
| 平台相关 | usize | isize | 0 | 取决于 CPU 架构（x86 为 2³²，x86_64 为 2⁶⁴） |
⌨️ 整数字面量写法示例：
// 十进制（默认）
let a = 10; // i32（默认）
let b: u32 = 20; // 显式类型注解
// 十六进制（0x 开头）
let c = 0xff; // i32，255
let d: u8 = 0x1A; // 26
// 八进制（0o 开头）
let e = 0o77; // i32，63
// 二进制（0b 开头）
let f = 0b1010; // i32，10
// 字节字面量（u8，仅适用于 ASCII）
let g = b'A'; // u8，65
// 分隔符（_，增强可读性）
let h = 1_000_000; // i32，1000000
⚠️ 整数溢出问题： Rust 在Debug 模式（默认）下会检查整数溢出，若发生溢出会直接崩溃（panic!）；在 Release 模式下会默认启用'两补数环绕'（Wrapping）行为，但这是未定义行为（UB），建议显式处理溢出。
⌨️ 溢出处理方法示例：
// 使用 checked_* 方法，溢出时返回 None
let x: u8 = 255;
match x.checked_add(1) {
Some(y) => println!("255 + 1 = {}", y),
None => println!("255 + 1 发生溢出"), // 会执行这条
}
// 使用 saturating_* 方法，溢出时取最大值/最小值
let y: u8 = 255;
let z = y.saturating_add(1); // z = 255
// 使用 wrapping_* 方法，强制两补数环绕
let w: u8 = 255;
let v = w.wrapping_add(1); // v = 0
Rust 提供了两种浮点数类型：
f32：32 位单精度浮点数（IEEE-754 标准），精度约 6-7 位小数f64：64 位双精度浮点数（IEEE-754 标准），精度约 15-17 位小数（默认类型）⌨️ 浮点数字面量写法示例：
// 十进制小数
let a = 3.14; // f64（默认）
let b: f32 = 2.718; // 显式类型注解
// 科学计数法
let c = 1e5; // f64，100000.0
let d: f32 = 2.5e-3; // 0.0025
⚠️ 浮点数精度问题： 浮点数无法精确表示所有十进制小数，会导致逻辑错误。
⌨️ 精度问题示例：
let x = 0.1 + 0.2;
println!("0.1 + 0.2 = {}", x); // 输出 0.30000000000000004
println!("x == 0.3? {}", x == 0.3); // 输出 false
// 解决方法：比较差值是否小于一个极小值（epsilon）
fn float_equals(a: f64, b: f64) -> bool {
(a - b).abs() < 1e-9
}
println!("x == 0.3? {}", float_equals(x, 0.3)); // 输出 true
Rust 的布尔类型只有bool一种，值只能是true或false，占用1 字节内存（确保内存对齐）。
⌨️ 布尔类型使用示例：
let is_true = true;
let is_false: bool = false; // 布尔类型常用于条件判断
if is_true {
println!("这是真的");
} else {
println!("这是假的");
}
// 布尔类型可以转换为整数
let true_as_u8 = is_true as u8; // 1
let false_as_u8 = is_false as u8; // 0
Rust 的字符类型是char，占用4 字节内存，支持Unicode 标量值（包括中文、日文、韩文、表情符号等，范围是 U+0000 到 U+10FFFF）。
⌨️ 字符类型使用示例：
let a = 'A'; // 英文大写字母，ASCII 码 65
let b: char = '中'; // 中文，Unicode 值 U+4E2D
let c = '😀'; // 表情符号，Unicode 值 U+1F600
// 字符类型可以转换为整数
let a_as_u32 = a as u32; // 65
println!("'A'的 Unicode 值是 U+{:X}", a_as_u32); // 输出 U+41
元组是固定长度、异质数据类型的组合，长度在声明时必须明确，且后续无法修改。
⌨️ 元组声明与访问示例：
// 声明元组
let t1: (i32, f64, bool) = (10, 3.14, true);
let t2 = ("hello", 'R', 2024); // 编译器自动推断类型
// 访问元组元素
// 方法 1：索引访问（从 0 开始）
println!("t1 的第 0 个元素：{}", t1.0); // 10
println!("t1 的第 1 个元素：{}", t1.1); // 3.14
println!("t1 的第 2 个元素：{}", t1.2); // true
// 方法 2：解构赋值
let (x, y, z) = t2;
println!("x = {}, y = {}, z = {}", x, y, z); // x = hello, y = R, z = 2024
// 单元素元组（必须加逗号）
let t3 = (5,); // 类型是 (i32,)
let t4 = (5); // 这不是元组，而是整数 5
// 空元组（单元类型，值只有一个 ()）
let t5 = (); // 类型是 ()，常用于表示无返回值的函数
⌨️ 元组作为函数返回值示例：
// 计算矩形的面积和周长
fn calculate_rectangle(width: u32, height: u32) -> (u32, u32) {
let area = width * height;
let perimeter = (width + height) * 2;
(area, perimeter) // 返回元组
}
fn main() {
let (area, perimeter) = calculate_rectangle(10, 5);
println!("面积：{}，周长：{}", area, perimeter); // 面积：50，周长：30
}
数组是固定长度、同质数据类型的组合，存储在栈内存上，长度在声明时必须明确，且后续无法修改。
⌨️ 数组声明与访问示例：
// 声明数组
let a: [i32; 3] = [1, 2, 3]; // 类型注解：[元素类型; 长度]
let b = [10, 20, 30]; // 编译器自动推断类型
let c = [5; 4]; // 初始化：每个元素都是 5，长度为 4
// 访问数组元素
println!("a 的第 0 个元素：{}", a[0]); // 1
println!("a 的第 2 个元素：{}", a[2]); // 3
println!("c 的第 1 个元素：{}", c[1]); // 5
// 获取数组长度
println!("a 的长度：{}", a.len()); // 3
// 数组遍历
for element in a.iter() {
println!("{}", element); // 输出 1、2、3
}
// 可变数组
let mut d = [1, 2, 3];
d[0] = 10; // 修改第 0 个元素
println!("d 的第 0 个元素：{}", d[0]); // 10
⚠️ 数组越界访问问题： Rust 在编译期无法检查所有越界访问，但在运行期会检查，若发生越界会直接崩溃（panic!）。
⌨️ 越界访问示例：
let a = [1, 2, 3];
println!("a 的第 3 个元素：{}", a[3]); // 运行期崩溃：index out of bounds: the len is 3 but the index is 3
切片是数组或 Vec（动态数组）的动态视图，存储在栈内存上，包含两个部分：
💡 核心特性：
&[T]（不可变切片）或&mut [T]（可变切片）⌨️ 切片声明与访问示例：
// 不可变数组切片
let a = [1, 2, 3, 4, 5];
let slice1 = &a[1..3]; // 从索引 1 到索引 3（不包含 3），元素是 [2, 3]
let slice2 = &a[..2]; // 从开头到索引 2（不包含 2），元素是 [1, 2]
let slice3 = &a[3..]; // 从索引 3 到结尾，元素是 [4, 5]
let slice4 = &a[..]; // 整个数组，元素是 [1,2,3,4,5]
// 访问切片元素
println!("slice1 的第 0 个元素：{}", slice1[0]); // 2
println!("slice1 的长度：{}", slice1.len()); // 2
// 可变数组切片
let mut b = [1, 2, 3, 4, 5];
let mut_slice = &mut b[1..3];
mut_slice[0] = 20; // 修改切片的第 0 个元素，也就是原数组的第 1 个元素
println!("原数组 b：{:?}", b); // 输出 [1,20,3,4,5]
// Vec 的切片（与数组切片类似）
let mut vec = vec![10, 20, 30, 40, 50];
let vec_slice = &vec[2..4];
println!("Vec 切片：{:?}", vec_slice); // [30,40]
Rust 的字符串类型分为两种，初学者容易混淆：
&strString⌨️ 字符串类型使用示例：
// 字符串字面量（&str）
let s1: &str = "Hello, Rust!"; // 存储在静态内存上
let s2 = "这是中文"; // 编译器自动推断类型为 &str
// String 类型的创建
let s3 = String::new(); // 创建空字符串
let s4 = String::from(s1); // 从 &str 创建 String
let s5 = String::from("动态字符串"); // 直接创建
// 字符串连接
let s6 = s4 + " " + s5.as_str(); // 注意：s4 被转移所有权，s5 需要.as_str() 转换为 &str
println!("s6：{}", s6); // 输出 Hello, Rust! 动态字符串
// 不可变字符串连接（保留所有变量的所有权）
let s7 = format!("{} {} {}", s1, s5, 2024);
println!("s7：{}", s7); // 输出 Hello, Rust! 动态字符串 2024
// 字符串切片（按字节索引，注意：Rust 的字符串是 UTF-8 编码的，一个中文字符占 3 字节）
let s8 = "Rust 语言开发";
println!("s8 的第 0-3 字节：{}", &s8[0..3]); // Rust
// println!("s8 的第 4-5 字节：{}", &s8[4..6]); // 编译期崩溃：byte index 4 is not a char boundary
// 获取字符串的字符迭代器（按字符索引）
for c in s8.chars() {
println!("{}", c); // 输出 R、u、s、t、语、言、开、发
}
Rust 的变量声明必须使用let关键字，变量默认是不可变的（immutable）。
⌨️ 变量声明示例：
// 简单声明（编译器自动推断类型）
let x = 10;
let y = "hello";
// 显式类型注解
let z: u8 = 255;
let w: String = String::from("Rust");
如果需要修改一个变量，必须在声明时添加mut关键字（mutable）。
⌨️ 可变变量示例：
let mut x = 10;
x = 20;
println!("x：{}", x); // 输出 20
let mut s = String::from("hello");
s.push_str(", Rust!");
println!("s：{}", s); // 输出 hello, Rust!
变量的作用域是从声明位置到所在代码块（{}）的结束位置。
⌨️ 变量作用域示例：
fn main() {
let x = 10; // x 的作用域开始
{
let y = 20; // y 的作用域开始
println!("x + y = {}", x + y); // 30，x 可以访问，y 可以访问
} // y 的作用域结束
// println!("y = {}", y); // 编译错误：y 未声明
println!("x = {}", x); // 10，x 的作用域未结束
} // x 的作用域结束
Shadowing 是指在同一作用域或嵌套作用域内，用相同的变量名声明一个新变量，新变量会隐藏旧变量。
⌨️ Shadowing 示例：
// 同一作用域内的 Shadowing
let x = 10;
let x = x + 5; // 新变量 x 隐藏旧变量 x，类型仍然是 i32，值是 15
println!("x：{}", x); // 15
// 嵌套作用域内的 Shadowing
let y = 20;
{
let y = "hello"; // 新变量 y 隐藏旧变量 y，类型是 &str
println!("内部 y：{}", y); // hello
}
println!("外部 y：{}", y); // 20，旧变量 y 重新可见
// Shadowing 与类型转换结合
let z = "123";
let z = z.parse::<i32>().unwrap(); // 新变量 z 隐藏旧变量 z，类型是 i32，值是 123
println!("z：{}", z); // 123
💡 Shadowing vs mut：
| 特性 | Shadowing | mut |
|---|---|---|
| 变量名 | 可以相同 | 可以相同 |
| 变量类型 | 可以不同 | 必须相同 |
| 内存地址 | 可能不同 | 必须相同 |
| 作用域 | 同一或嵌套作用域 | 同一作用域 |
| 适用场景 | 需要类型转换或重新计算 | 需要修改值但类型不变 |
Rust 是强静态类型语言，几乎不支持隐式类型转换，所有类型转换必须显式声明。
as关键字是 Rust 中最常用的类型转换方法，适用于基础数据类型之间的转换。
⌨️ as 关键字转换示例：
// 整数类型之间的转换
let a: i32 = 100;
let b: u8 = a as u8; // 100
let c: i8 = 255 as i8; // -1（两补数环绕）
// 整数转浮点数
let d: i32 = 5;
let e: f64 = d as f64; // 5.0
// 浮点数转整数（截断）
let f: f64 = 3.14;
let g: i32 = f as i32; // 3
// 字符转整数
let h: char = 'A';
let i: u32 = h as u32; // 65
⚠️ as 关键字转换的限制：
From/Into Traits 是 Rust 中更安全、更通用的类型转换方法，适用于所有实现了这些 Traits 的类型。
from()into()⌨️ From/Into Traits 转换示例：
// String 和&str 之间的转换
let s1: &str = "hello";
let s2: String = String::from(s1); // 使用 From Trait
let s3: String = s1.into(); // 使用 Into Trait（自动实现）
// 整数类型之间的转换（需要实现 From Trait）
use std::convert::TryFrom;
use std::convert::TryInto;
let a: i32 = 100;
let b: Result<u8, std::num::TryFromIntError> = u8::try_from(a); // 安全转换，返回 Result
match b {
Ok(x) => println!("a 转换为 u8：{}", x),
Err(e) => println!("转换失败：{}", e),
}
let c: Result<u8, std::num::TryFromIntError> = a.try_into(); // 使用 TryInto Trait（自动实现）
// 自定义类型的转换
struct Person {
name: String,
age: u32,
}
struct PersonInfo {
name: &'static str,
age: u32,
}
impl From<PersonInfo> for Person {
fn from(info: PersonInfo) -> Self {
Person {
name: String::from(info.name),
age: info.age,
}
}
}
let info = PersonInfo { name: "张三", age: 25 };
let person: Person = info.into(); // 使用 Into Trait（自动实现）
println!("姓名：{}，年龄：{}", person.name, person.age); // 姓名：张三，年龄：25
💡 场景分析：需要编写一个函数，根据不同的几何图形（圆形、矩形、三角形）计算面积，输入参数类型不同，但返回值都是浮点数。
⌨️ 代码示例：
// 定义几何图形的枚举类型
#[derive(Debug)]
enum Shape {
Circle(f64), // 半径
Rectangle(f64, f64), // 长和宽
Triangle(f64, f64), // 底和高
}
// 计算面积的函数
impl Shape {
fn area(&self) -> f64 {
match self {
Shape::Circle(radius) => std::f64::consts::PI * radius * radius,
Shape::Rectangle(width, height) => width * height,
Shape::Triangle(base, height) => base * height / 2.0,
}
}
}
fn main() {
// 创建不同的几何图形
let circle = Shape::Circle(5.0);
let rectangle = Shape::Rectangle(10.0, 5.0);
let triangle = Shape::Triangle(6.0, 4.0);
// 计算面积
println!("圆形面积：{:.2}", circle.area()); // 78.54
println!("矩形面积：{:.2}", rectangle.area()); // 50.00
println!("三角形面积：{:.2}", triangle.area()); // 12.00
}
💡 场景分析：需要编写一个程序，读取用户输入的多个学生成绩（整数），计算平均分、最高分、最低分，并输出成绩的分布情况。
⌨️ 代码示例：
use std::io;
fn main() {
// 存储成绩的数组（最多 50 个学生）
let mut scores = [0; 50];
let mut count = 0;
println!("请输入学生成绩（输入 -1 结束）：");
loop {
let mut input = String::new();
io::stdin().read_line(&mut input).expect("读取输入失败");
let score: i32 = match input.trim().parse() {
Ok(num) => num,
Err(_) => {
println!("请输入有效的整数");
continue;
}
};
if score == -1 {
break;
}
if score < 0 || score > 100 {
println!("成绩必须在 0-100 之间");
continue;
}
if count >= 50 {
println!("最多只能输入 50 个成绩");
break;
}
scores[count] = score;
count += 1;
}
if count == 0 {
println!("没有输入成绩");
return;
}
// 计算平均分、最高分、最低分
let sum: i32 = scores[0..count].iter().sum();
let average = sum as f64 / count as f64;
let max_score = scores[0..count].iter().max().unwrap();
let min_score = scores[0..count].iter().min().unwrap();
// 统计成绩分布
let mut grade_counts = [0; 5]; // 0-59, 60-69, 70-79, 80-89, 90-100
for &score in scores[0..count].iter() {
match score {
0..=59 => grade_counts[0] += 1,
60..=69 => grade_counts[1] += 1,
70..=79 => grade_counts[2] += 1,
80..=89 => grade_counts[3] += 1,
90..=100 => grade_counts[4] += 1,
_ => (),
}
}
// 输出结果
println!("成绩统计结果：");
println!("----------------------");
println!("学生人数：{}", count);
println!("平均分：{:.2}", average);
println!("最高分：{}", max_score);
println!("最低分：{}", min_score);
println!("----------------------");
println!("成绩分布：");
println!("0-59 分：{}人", grade_counts[0]);
println!("60-69 分：{}人", grade_counts[1]);
println!("70-79 分：{}人", grade_counts[2]);
println!("80-89 分：{}人", grade_counts[3]);
println!("90-100 分：{}人", grade_counts[4]);
}
💡 场景分析：需要编写一个程序，读取 CSV 格式的产品数据（包含产品名称、价格、库存），解析并存储在数组中，然后根据价格范围筛选产品。
⌨️ 代码示例：
// 产品结构体
#[derive(Debug)]
struct Product {
name: String,
price: f64,
stock: u32,
}
// 解析 CSV 行的函数
fn parse_product_csv(line: &str) -> Option<Product> {
let fields: Vec<&str> = line.split(',').collect();
if fields.len() != 3 {
return None;
}
let name = fields[0].trim().to_string();
let price: f64 = match fields[1].trim().parse() {
Ok(num) => num,
Err(_) => return None,
};
let stock: u32 = match fields[2].trim().parse() {
Ok(num) => num,
Err(_) => return None,
};
Some(Product { name, price, stock })
}
fn main() {
// 模拟 CSV 数据
let csv_data = "苹果，5.99, 100\n香蕉，2.49, 200\n橙子，3.99, 150\n葡萄，9.99, 50\n西瓜，12.99, 30\n错误数据，abc, 10 ";
// 解析 CSV 数据
let mut products = Vec::new();
for line in csv_data.lines() {
let trimmed_line = line.trim();
if trimmed_line.is_empty() {
continue;
}
match parse_product_csv(trimmed_line) {
Some(product) => products.push(product),
None => println!("忽略无效行：{}", trimmed_line),
}
}
// 筛选价格在 5-10 元之间的产品
let filtered_products: Vec<&Product> = products
.iter()
.filter(|p| p.price >= 5.0 && p.price <= 10.0)
.collect();
// 输出结果
println!("价格在 5-10 元之间的产品：");
println!("----------------------------------");
println!("产品名称\t价格\t库存");
println!("----------------------------------");
for product in filtered_products {
println!("{}\t{:.2}\t{}", product.name, product.price, product.stock);
}
}
问题现象：在 Debug 模式下，整数溢出会导致程序崩溃（panic!）。
解决方案：
问题现象：0.1+0.2 的结果不等于 0.3，比较浮点数相等时返回 false。
解决方案：比较两个浮点数的差值是否小于一个极小值（epsilon），如 1e-9。
问题现象：访问数组的索引超过其长度时，程序崩溃。
解决方案：
⌨️ get() 方法示例：
let a = [1, 2, 3];
if let Some(element) = a.get(3) {
println!("{}", element);
} else {
println!("索引无效");
}
问题现象：函数接受的参数类型与传入的类型不一致，导致编译错误。
解决方案：
⌨️ dbg!() 宏示例：
let x = 10;
dbg!(x); // 输出 [src/main.rs:2:5] x = 10
let y = x as u8;
dbg!(y); // 输出 [src/main.rs:4:5] y = 10
✅ 掌握了 Rust 所有标量类型的定义、内存布局、范围限制与字面量写法 ✅ 熟练运用了元组、数组、切片处理复杂数据结构，理解了其固定/动态特性 ✅ 深入理解了变量的声明、可变性控制、作用域规则，以及 Shadowing（变量隐藏）机制的应用场景 ✅ 熟练掌握了 Rust 严格的类型转换方法，包括 as 关键字和 From/Into Traits ✅ 结合真实场景编写了三个实用的代码案例，解决了常见问题
下一篇文章，我们将深入学习 Rust 的函数与流程控制，包括：
通过学习这些内容，我们将能够编写更复杂、逻辑更清晰的 Rust 程序。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML 转 Markdown 互为补充。 在线工具，Markdown 转 HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML 转 Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online
将JSON字符串修饰为友好的可读格式。 在线工具，JSON美化和格式化在线工具，online