// 十進制（默認）
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

// 字節(jié)字面量（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 發(fā)生溢出"),  // 會執(zhí)行這條
}

// 使用saturating_*方法，溢出時取最大值/最小值
let y: u8 = 255;
let z = y.saturating_add(1);  // z = 255

// 使用wrapping_*方法，強制兩補數(shù)環(huán)繞
let w: u8 = 255;
let v = w.wrapping_add(1);    // v = 0

// 十進制小數(shù)
let a = 3.14;         // f64（默認）
let b: f32 = 2.718;   // 顯式類型注解

// 科學計數(shù)法
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!("這是假的");
}

// 布爾類型可以轉換為整數(shù)
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

// 字符類型可以轉換為整數(shù)
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);   // 這不是元組，而是整數(shù)5

// 空元組（單元類型，值只有一個()）
let t5 = ();    // 類型是()，常用于表示無返回值的函數(shù)

// 計算矩形的面積和周長
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
}

// 聲明數(shù)組
let a: [i32; 3] = [1, 2, 3];  // 類型注解：[元素類型; 長度]
let b = [10, 20, 30];         // 編譯器自動推斷類型
let c = [5; 4];               // 初始化：每個元素都是5，長度為4

// 訪問數(shù)組元素
println!("a的第0個元素：{}", a[0]);  // 1
println!("a的第2個元素：{}", a[2]);  // 3
println!("c的第1個元素：{}", c[1]);  // 5

// 獲取數(shù)組長度
println!("a的長度：{}", a.len());  // 3

// 數(shù)組遍歷
for element in a.iter() {
    println!("{}", element);  // 輸出1、2、3
}

// 可變數(shù)組
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

// 不可變數(shù)組切片
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[..];    // 整個數(shù)組，元素是[1,2,3,4,5]

// 訪問切片元素
println!("slice1的第0個元素：{}", slice1[0]);  // 2
println!("slice1的長度：{}", slice1.len());    // 2

// 可變數(shù)組切片
let mut b = [1, 2, 3, 4, 5];
let mut_slice = &mut b[1..3];
mut_slice[0] = 20;  // 修改切片的第0個元素，也就是原數(shù)組的第1個元素
println!("原數(shù)組b：{:?}", b);  // 輸出[1,20,3,4,5]

// Vec的切片（與數(shù)組切片類似）
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!";  // 存儲在靜態(tài)內存上
let s2 = "這是中文";             // 編譯器自動推斷類型為&str

// String類型的創(chuàng)建
let s3 = String::new();           // 創(chuàng)建空字符串
let s4 = String::from(s1);        // 從&str創(chuàng)建String
let s5 = String::from("動態(tài)字符串");  // 直接創(chuàng)建

// 字符串連接
let s6 = s4 + " " + s5.as_str();  // 注意：s4被轉移所有權，s5需要.as_str()轉換為&str
println!("s6：{}", s6);  // 輸出Hello, Rust! 動態(tài)字符串

// 不可變字符串連接（保留所有變量的所有權）
let s7 = format!("{} {} {}", s1, s5, 2024);
println!("s7：{}", s7);  // 輸出Hello, Rust! 動態(tài)字符串 2024

// 字符串切片（按字節(jié)索引，注意：Rust的字符串是UTF-8編碼的，一個中文字符占3字節(jié)）
let s8 = "Rust語言開發(fā)";
println!("s8的第0-3字節(jié)：{}", &s8[0..3]);  // Rust
// println!("s8的第4-5字節(jié)：{}", &s8[4..6]);  // 編譯期崩潰：byte index 4 is not a char boundary

// 獲取字符串的字符迭代器（按字符索引）
for c in s8.chars() {
    println!("{}", c);  // 輸出R、u、s、t、語、言、開、發(fā)
}

// 簡單聲明（編譯器自動推斷類型）
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

// 整數(shù)類型之間的轉換
let a: i32 = 100;
let b: u8 = a as u8;  // 100
let c: i8 = 255 as i8;  // -1（兩補數(shù)環(huán)繞）

// 整數(shù)轉浮點數(shù)
let d: i32 = 5;
let e: f64 = d as f64;  // 5.0

// 浮點數(shù)轉整數(shù)（截斷）
let f: f64 = 3.14;
let g: i32 = f as i32;  // 3

// 字符轉整數(shù)
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（自動實現(xiàn)）

// 整數(shù)類型之間的轉換（需要實現(xiàn)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（自動實現(xiàn)）

// 自定義類型的轉換
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（自動實現(xiàn)）
println!("姓名：{}，年齡：{}", person.name, person.age);  // 姓名：張三，年齡：25

// 定義幾何圖形的枚舉類型
#[derive(Debug)]
enum Shape {
    Circle(f64),          // 半徑
    Rectangle(f64, f64),  // 長和寬
    Triangle(f64, f64),   // 底和高
}

// 計算面積的函數(shù)
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() {
    // 創(chuàng)建不同的幾何圖形
    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() {
    // 存儲成績的數(shù)組（最多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!("請輸入有效的整數(shù)");
                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();

    // 統(tǒng)計成績分布
    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!("成績統(tǒng)計結果：");
    println!("----------------------");
    println!("學生人數(shù)：{}", 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行的函數(shù)
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數(shù)據(jù)
    let csv_data = "
        蘋果, 5.99, 100
        香蕉, 2.49, 200
        橙子, 3.99, 150
        葡萄, 9.99, 50
        西瓜, 12.99, 30
        錯誤數(shù)據(jù), abc, 10
    ";

    // 解析CSV數(shù)據(jù)
    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