Rust系统编程之基础语法

1.变量

1.1 特性

a.不可变性

在rust中，变量默认是不可变的，除非指定mut属性。

let a = 1;
a = 2;	// wrong

let mut a = 1;
a = 2;	// right

b.变量隐藏

let a = 1;
{
	let a = 2;
	println!("{}", a);
}
println!("{}", a);

======>
2
1

1.1 类型

a.基本类型

类型	写法
整型	u8 i8 u 16 i16 u32 i32 u64 i64 u128 i128 iszie usize
浮点	f32 f64
布尔	bool
字符	char 4个字节unicode

b.复合类型

• 元组

  元组是一个将多个其他类型的值组合进一个复合类型的主要方式，元组长度固定。

  let x: (i32, f64, u8) = (500, 6.4, 1);
  // 解构方式获取元素
  let (a, b, c) = x;
  // 索引方式获取元素
  let five_hundred = x.0;
  let six_point_four = x.1;
  let one = x.2;

  空元组叫做单元，表示空值或空的返回类型。

  ()

• 定长数组

  长度在声明时确定，后面不可再增大缩小。

  // 初始化一个含有5个i32类型的数组
  let a: [i32; 5] = [1, 2, 3, 4, 5];
  // 初始化一个5个3的数组
  let a = [3; 5];

  数组越界访问会导致panic。

2.函数

函数的参数必须指定类型，不可以自动推导。

函数如果不指定return关键字，默认返回最后一个表达式的值。

带参数带多个返回值（元组）的函数：

fn test_fun(arg_1: u32, arg_2: u32) -> (u32, u32) {
    (arg_1+ arg_2, 3)			// 这里不带分号表示是一个表达式
}

fn main( ){
    let (x, y) = test_fun(3, 5);
    println!("{}, {}", x, y);
}

3.控制流

3.1 分支控制

多分支结构

let number = 6;
if number % 4 == 0 {
    println!("number is divisible by 4");
} else if number % 3 == 0 {
    println!("number is divisible by 3");
} else if number % 2 == 0 {
    println!("number is divisible by 2");
} else {
    println!("number is not divisible by 4, 3, or 2");
}

在rust中if被视为表达式，可以用于赋值：

let condition = true;
let number = if condition { 5 } else { 6 };

3.2 循环结构

a.loop

无限循环，直到执行到break。

loop {
    println!("again!");
}

在rust中loop循环被视为表达式，可以使用break返回值：

let result = loop {
    counter += 1;
    if counter == 10 {
        break counter * 2;
    }
};

rust可以为循环设置标签，break语句可以选择返回到哪个被标签的循环之外。

let mut count = 0;
'counting_up: loop {
    println!("count = {count}");
    let mut remaining = 10;
    loop {
        if remaining == 9 {
            break;			    // 这个控制最内层循环
        }
        if count == 2 {
            break 'counting_up;	// 这个控制最外层循环
        }
        remaining -= 1;
    }

    count += 1;
}

b.while

let mut number = 3;
while number != 0 {
	println!("{number}!");
	number -= 1;
}

c.范围for

let a = [10, 20, 30, 40, 50];
for element in a {
    println!("the value is: {element}");
}

3.3 match结构

和C语言的 switch 用法类似，所有可能的值必须都要被覆盖。

let number = 13;
match number {
    // 匹配单个值
    1 => println!("One!"),
    // 匹配多个值
    2 | 3 | 5 | 7 | 11 => println!("This is a prime"),
    // 匹配一个闭区间范围
    13..=19 => println!("A teen"),
    // 处理其他情况
    _ => println!("Ain't special"),
}

match也是一个表达式，可以用于赋值操作：

let flag = true;
let res = match flag {
    false => 0,
    true => 1,
};