Rust的基础数据类型、变量系统、类型转换以及实战应用

// 十进制（默认）
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

// 使用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

// 十进制小数
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

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

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

let a = [1, 2, 3];
println!("a的第3个元素：{}", a[3]);  // 运行期崩溃：index out of bounds: the len is 3 but the index is 3

// 不可变数组切片
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]

// 字符串字面量（&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、语、言、开、发
}

// 简单声明（编译器自动推断类型）
let x = 10;
let y = "hello";

// 显式类型注解
let z: u8 = 255;
let w: String = String::from("Rust");

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
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

// 整数类型之间的转换
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

// 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]);
}

// 产品结构体
#[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
        香蕉, 2.49, 200
        橙子, 3.99, 150
        葡萄, 9.99, 50
        西瓜, 12.99, 30
        错误数据, 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);
    }
}

let a = [1, 2, 3];
if let Some(element) = a.get(3) {
    println!("{}", element);
} else {
    println!("索引无效");
}

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