看看Rust是个什么鬼(1)

写在前面的内心OS

也不知道为什么会有这种东西。。。老老实实写C不行么，非要搞一门新语言。。。
一把岁数了还要学点新东西。。。等我65岁退休了在搞新东西不行嘛。。。

C1

安装rust，看着办吧

//Hello，word
fn main() {
		//println！有一个！，有！的不是函数，是宏
		println!("Guess the number!");
	}

# 编译单个文件
rustc main.c
# 项目管理工具
cargo new hellow
cargo build # 默认编译debug
cargo build --release

C2

猜数字

use std::io;
// 参考书上用旧一点的版本，新版本gen_range报错了
use rand::Rng;
use std::cmp::Ordering;

fn main() {
    println!("guest number");
    
    // gen_range--[)
    let secret_number = rand::thread_rng().gen_range(1, 101);
    println!("Generate num is {}", secret_number);

    loop {
        /*
            Rust中，变量默认是不可变的
            let a = 5;      a不可变
            let mut b = 5;  b可变
        */
        let mut guess_num = String::new();
        println!("Please input your number...");

        //expect("Failed to read line") 像是一个自带返回值检查的处理，去掉会warn
        io::stdin().read_line(&mut guess_num).expect("Failed to read line");

        // 强转string -> u32
        //let guess: u32 = guess_num.trim().parse().expect("Error input a num");
        let guess: u32 = match guess_num.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,

        };

        println!("The num your in put is {}", guess);
        //println!("{}{}-{}", guess, guess, guess);
        match guess.cmp(&secret_number) {
            Ordering::Less=>println!("Less"),
            Ordering::Greater=>println!("Big"),
            Ordering::Equal=> {
                println!("Done");
                break;
            }
        }
    }
}

C3

常量，变量，隐藏

fn main() {
    // 常量, const声明一个常量，需要显示的标注类型
    const MAX_POINTS: u32 = 100000;
    let mut val_a = MAX_POINTS;
    //val_a = 6;

    // 变量默认不可二次赋值(mut)
    let val_b = 5;
    //val_b = 6;

    // 隐藏，后一个同名变量可以隐藏前一个,隐藏是通过let创建了新的变量
    let val_c = val_b + 1;
    let val_c = val_b * 2;
    // val_c = val_a;
    let mut val_c = val_b * 3;
    val_c = val_a;
    let val_c = (MAX_POINTS - 1);
    println!("{}---{}---{}", val_a, val_b, val_c);
}

变量

// 数据类型
// 标量：单个值类型，包括整数，浮点，布尔，字符

fn main() {
    let guess: u32 = "42".parse().expect("Not a number");
    println!("{}", guess);

/*
    整数
    8bit        i8      u8
    16bit       i16     u16
    32bit       i32     u32
    64bit       i64     u64
    arch        isize   usize      [架构默认大小]

    整数溢出，debug版本会panic，release会直接"环绕"例如u8的256会变为0
*/
    let a: u64 = 100;
/*
    浮点
    f32
    f64
*/
    //let b: f64 = 100;
    let b: f64 = 100.0;
    let c: f64 = 100.25;
    let d: f32 = 100.25;
    //let result = a - c; //编译报错
    //let result = d - c; //编译报错
    let result = b - c;
    println!("{}---{}---{}---{}", a, b, c, result);

    let t_true = true;
    let f_false: bool = false;
    println!("{}---{}", t_true, f_false);

    let m_m = 'm';
    let z_z = "Z";
    println!("{}---{}", m_m, z_z);
}

// 数据类型
// 复合：元组，数组

fn main() {
/*
    元组，多个类型集合
*/
    let tup: (i32, f64, u8) = (500, 6.4, 1);
    //println!("{}", tup);
    println!("{}", tup.1);

/*
    数组，单一类型的集合
*/

    let a = [1, 2, 3,  4, 5];
    let b = ["aa", "bb", "cc", "dd", "ee"];
    println!("{}", a[0]);
    println!("{}", b[4]);
    // 元素为i32的5个长度的数组
    let c: [i32; 5] = [2, 3, 4, 5, 6];
    // 元素全为3的5个长度的数组
    let d = [3; 5];
    println!("{}---{}", c[1], d[4]);
}

函数

// 函数

fn test_func_0() {
    println!("This is test_func_0");
}

fn main() {
    test_func_1();
    test_func_0();
    //test_func_param(10, 2.1);
    test_func_param(10.3, 66);
}

fn test_func_1() {
    println!("This is test_func_1");
}

fn test_func_param(x: f64, y: i32) {
    println!("This is test_func_param---{}", x);
    println!("This is test_func_param---{}", y);
}

表达式和语句

// 表达式：需要计算出值，因此函数，宏是表达式
// 有返回值的是表达式，没有的是语句
/*
语句：let a = 1;
表达式: 1
*/

fn main() {
    let a = 5;
    let b = {
        let a = 2;
        a + 1
    };
    println!("{}---{}", a, b);

    let mut c = five1();
    println!("{}", c);
    c = five2();
    println!("{}", c);
    //c = five3();
    //println!("{}", c);
}

// 5 直接做表达式，不加;
fn five1() -> i32 {
    5
}

// return
fn five2() -> i32 {
    return 6;
}

//fn five3() -> f32 {
//    return 6.6;
//}

分支

// 控制流

fn main() {
    let a = 8;
    let b = 5;

    if a < 5 {
        println!("a < {}", b);
    } else if a > 5 {
        println!("a > {}", b);
    } else {
        println!("a = {}", b);
    }

    // 条件只能是bool，rust不会自动转换
//    if a {
//        println!("a = {}", a);
//    }

    let condition = true;
    let num = if condition {
        5
        //"5" 需要分支的两个类型一致，以前一个分支为主
    } else {
        6
    };
    println!("num = {}", num);

    let mut number_loop = 5;
    while number_loop != 0 {
        println!("number_while---{}", number_loop);
        //number_loop--;    //似乎没有--，可能也没有++,编译就报错了
        number_loop -= 1;
    }

    let for_array = [11, 22, 33, 44, 55];
    for alement in for_array.iter() {
        println!("alement---{}", alement);
    }
    for alement in for_array.iter().rev() {
        println!("alement---{}", alement);
    }

    for alement in (1..10) {
        println!("alement---{}", alement);
    }
}

写到这里，基本的语句什么的就结束了，本来准备一篇写完的
不过。。。后面好像都是概念了，后面再写一个篇吧