// 主函数，程序入口点
fn main() {
// 1. 变量与数据类型
println!("\n=== 变量与数据类型 ===");
// 不可变变量（默认）
let x = 5;
println!("x 的值: {}", x);
// 可变变量
let mut y = 10;
println!("y 的初始值: {}", y);
y = 20;
println!("y 修改后的值: {}", y);
// 显式类型标注
let z: f64 = 3.14159;
println!("z 的值: {}", z);
// 布尔类型
let is_rust_fun: bool = true;
println!("Rust 有趣吗? {}", is_rust_fun);
// 字符类型（Unicode）
let heart: char = '❤';
println!("爱心符号: {}", heart);
// 2. 复合类型
println!("\n=== 复合类型 ===");
// 元组
let tuple: (i32, &str, f64) = (42, "答案", 3.14);
println!("元组第一个元素: {}", tuple.0);
println!("元组第二个元素: {}", tuple.1);
// 解构元组
let (a, b, c) = tuple;
println!("解构后 - a: {}, b: {}, c: {}", a, b, c);
// 数组（固定大小,类型相同）
let numbers: [i32; 5] = [1, 2, 3, 4, 5];
println!("数组第三个元素: {}", numbers[2]);
println!("数组长度: {}", numbers.len());
// 3. 控制流
println!("\n=== 控制流 ===");
// if 表达式
let age = 18;
if age >= 18 {
println!("已成年");
} else if age >= 13 {
println!("青少年");
} else {
println!("儿童");
}
// 循环
let mut count = 0;
loop {
count += 1;
if count == 3 {
println!("循环执行了 3 次，退出循环");
break;
}
}
// while 循环
let mut n = 5;
while n > 0 {
println!("倒计时: {}", n);
n -= 1;
}
// for 循环
println!("数组元素:");
for num in numbers.iter() {
println!("{}", num);
}
// 范围循环
println!("1 到 5:");
for i in 1..=5 {
println!("{}", i);
}
// 4. 函数
println!("\n=== 函数 ===");
let sum = add(3, 5);
println!("3 + 5 = {}", sum);
let (product, difference) = multiply_and_subtract(4, 2);
println!("4 × 2 = {}, 4 - 2 = {}", product, difference);
// 5. 所有权与借用
println!("\n=== 所有权与借用 ===");
let s1 = String::from("Rust");
let s2 = take_ownership(s1);
// println!("s1: {}", s1); // 错误：s1 已经失去所有权
let s3 = String::from("编程");
let len = calculate_length(&s3);
println!("'{}' 的长度是: {}", s3, len); // s3 仍然有效
let mut s4 = String::from("可变");
change_string(&mut s4);
println!("修改后的字符串: {}", s4);
// 6. 结构体
println!("\n=== 结构体 ===");
let mut person = Person {
name: String::from("张三"),
age: 30,
is_student: false,
};
println!("姓名: {}", person.name);
println!("年龄: {}", person.age);
person.age = 31;
println!("更新后的年龄: {}", person.age);
let employee = Employee::new(String::from("李四"), 35, String::from("工程师"));
employee.print_info();
// 7. 枚举与模式匹配
println!("\n=== 枚举与模式匹配 ===");
let some_number = Option::Some(5);
let some_string = Option::Some(String::from("Hello"));
let none_value: Option<i32> = Option::None;
print_option(some_number);
print_option(some_string);
print_option(none_value);
let shape = Shape::Circle(5.0);
println!("形状面积: {}", shape.area());
// 8. 错误处理
println!("\n=== 错误处理 ===");
match divide(10, 2) {
Ok(result) => println!("10 ÷ 2 = {}", result),
Err(e) => println!("错误: {}", e),
}
match divide(5, 0) {
Ok(result) => println!("5 ÷ 0 = {}", result),
Err(e) => println!("错误: {}", e),
}
// 使用 ? 运算符简化错误处理
let result = safe_division(8, 4);
println!("使用 ? 运算符: {:?}", result);
}
// 简单加法函数
fn add(a: i32, b: i32) -> i32 {
a + b // Rust 函数最后一行表达式的结果会自动返回，无需 return 关键字
}
// 返回多个值的函数
fn multiply_and_subtract(a: i32, b: i32) -> (i32, i32) {
(a * b, a - b)
}
// 展示所有权转移
fn take_ownership(s: String) -> String {
println!("接收的字符串: {}", s);
s // 返回字符串，将所有权转移回调用者
}
// 展示不可变借用
fn calculate_length(s: &String) -> usize {
s.len()
}
// 展示可变借用
fn change_string(s: &mut String) {
s.push_str(" 字符串");
}
// 定义结构体
struct Person {
name: String,
age: u32,
is_student: bool,
}
// 结构体示例 2
struct Employee {
name: String,
age: u32,
position: String,
}
// 为结构体实现方法
impl Employee {
// 关联函数（类似静态方法）
fn new(name: String, age: u32, position: String) -> Self {
Employee {
name,
age,
position,
}
}
// 实例方法
fn print_info(&self) {
println!("员工信息 - 姓名: {}, 年龄: {}, 职位: {}", self.name, self.age, self.position);
}
}
// 定义枚举
enum Shape {
Circle(f64), // 圆，存储半径
Rectangle(f64, f64), // 矩形，存储宽和高
Square(f64), // 正方形，存储边长
}
// 为枚举实现方法
impl Shape {
fn area(&self) -> f64 {
match self {
Shape::Circle(radius) => 3.14159 * radius * radius,
Shape::Rectangle(width, height) => width * height,
Shape::Square(side) => side * side,
}
}
}
// 模式匹配示例
fn print_option<T: std::fmt::Display>(option: Option<T>) {
match option {
Some(value) => println!("有值: {}", value),
None => println!("无值"),
}
}
// 错误处理示例：定义错误类型
#[derive(Debug)]
enum DivisionError {
DivisionByZero,
}
// 为错误类型实现 Display trait
impl std::fmt::Display for DivisionError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
DivisionError::DivisionByZero => write!(f, "除数不能为零"),
}
}
}
// 除法函数，可能返回错误
fn divide(a: i32, b: i32) -> Result<i32, DivisionError> {
if b == 0 {
Err(DivisionError::DivisionByZero)
} else {
Ok(a / b)
}
}
// 使用 ? 运算符的函数
fn safe_division(a: i32, b: i32) -> Result<i32, DivisionError> {
let result = divide(a, b)?; // 如果有错误，直接返回错误
Ok(result)
}
Rust 主要数据类型分类说明
-
标量类型（单个值）：
- 整数类型：带符号（i8, i16, i32, i64, i128）和无符号（u8, u16, u32, u64, u128），以及平台相关的 isize 和 usize
- 浮点类型：f32（32 位）和 f64（64 位，默认）
- 布尔类型：bool，只能是 true 或 false
- 字符类型：char，表示单个 Unicode 字符（4 字节）
-
复合类型（组合多个值）：
- 元组（Tuple）：固定大小，可包含不同类型的值
- 数组（Array）：固定大小，所有元素类型相同
- 切片（Slice）：引用数组或字符串的一部分，长度可变
-
字符串类型：
- &str：字符串切片，不可变，通常用于引用字符串字面量
- String：可增长、可修改的字符串对象
-
特殊类型：
- Option ：表示值可能存在（Some (T)）或不存在（None）
- Result<T, E> ：表示操作可能成功（Ok (T)）或失败（Err (E)）
