Rust学习记录--C3 Rust通用编程概念

C3 Rust通用编程概念

变量与可变性
- 变量
- 常量
- - 常量constant
  - [隐藏 shadowing](#隐藏 shadowing)
数据类型
函数
注释
控制流
- [if else表达式](#if else表达式)
- 循环
- - loop循环
  - while循环
  - [for 循环遍历集合](#for 循环遍历集合)

变量与可变性

变量

使用let 关键字声明变量
默认情况下，变量是不可变的

rust 复制代码

let x = 1;
// 错误，x不可以再赋值
x=2;

在声明的变量前加mut，变量可变

rust 复制代码

let mut x = 1;
// 正确
x=2;

常量

常量constant

常量在绑定值后是不可变的
常量与不可变的变量的区别：
- 不可以使用mut，常量永远不可变
- 声明常量使用const关键字
- 类型必须被标注
- 可以申明在任何作用域
命名规范：Rust中常量使用权大写字幕，每个单词间使用下划线分开。

rust 复制代码

const MAX_POINTS : u32 = 100;

隐藏 shadowing

可以使用相同的名字申明新的变量

rust 复制代码

fn main(){
   let x = 5;
   // 最新的x将之前的x隐藏了，在之后的使用中只会使用最新的这个x
   let x = x+1;
}

shadow和与变量标记为mut是不一样的
- shadow需要使用let关键字
- 使用let申明的同名新变量的类型可以与之前的不同
  rust 复制代码
```
fn main(){
   // 类型： &str
   let x = '    ';
   // 类型： usize
   let x = x.len();
}
```

数据类型

标量类型

一个标量类型代表一个单个的值
Rust中有4个主要的标量类型
- 整数类型
- 浮点类型
- 布尔类型
- 字符类型

1.1 整数类型

没有小数部分
例如u32就是无符号的证书类型，占据32位的空间
无符号整数类型以 u 开头
有符号整数类型以 i 开头
Rust整数类型列表如图：
- 每种都粉i和u，以及固定位数
- 有符号的范围：-（2^n - 1）到 2 ^(n-1) -1
- 无符号的范围：0到 2 ^(n) -1
isize和usize类型
- 位数是由程序运行的计算机架构决定
- 使用isize和usize的主要场景是对某种集合进行索引操作

1.2 整数字面值

添加下划线是为了增强可读性

除了byte外，所有的数值字面值都允许使用类型后缀
- 例如 57u8
rust的整数默认类型是i32

1.3 整数溢出

例如： u8的范围是0-255，如果把一个u8的变量的值设置为256
- debug模式下编译 -> 程序在运行时就会panic
- release模式下 -> 不会panic，但是会执行"环绕"操作
  - 256变成0， 257变成1

2.1 浮点类型

rust中有两种基础的浮点类型（含有小数部分）
- f32， 32位，单精度
- f64， 64位，双精度

f64是默认类型

rust 复制代码

fn main(){
   let x =2.0;  // f64
   
   let y: f32 = 3.0; // f32
}

2.2 数值操作

例子

rust 复制代码

	fn main(){
		let sum= 5+10; // i32
		
		let diff = 95.5-4.3; // f64
		
		let pro = 4*30; // i32
		let quo = 56.7/32.2 // f64
		let rem = 54%5;  //i32
	}

3.1 布尔类型

布尔类型有两个值：true和false
一个字节大小

4.1 字符类型

char 表示单个字符
字符的字面值使用单引号
占用4个字节
是Unicode的标量值，可以表示比ASCLL多得多的字符内容：拼音/中日韩文等
- U+0000到U+D7FF
- U+E000到U+10FFFF

复合类型

复合类型可以将多个值放在一个类型里
提供两种基础的复合类型：元组（Tuple）和数组

元组（Tuple）

可以将多个类型的多个值放在一个类型中
长度是固定的，一旦声明就无法改变
创建Tuple
- 在小括号里将值用逗号分开
- 每个位置都对应一个类型，各元素的类型不必相同。
- 例子：
  rust 复制代码
```
	fn main(){
		let tup : (i32, f64, u8) = (500, 6.4, 1);
	}
```

获取Tuple的元素值

使用模式匹配的来解构一个Tuple来获取元素的值

例子

rust 复制代码

	fn main(){
		let tup : (i32, f64, u8) = (500, 6.4, 1);
		let (x,y,z) = tup;
		// x = 500, y = 6.4, z = 1
	}

访问Tuple的元素

使用点标记法，后接元素的索引号

例子

rust 复制代码

	fn main(){
		let tup : (i32, f64, u8) = (500, 6.4, 1);
		println!("{}, {}, {}", tup.0, tup.1, tup.2);
	}

数组

数组也可以将多个值放到同一类型中
但是数组中每个元素的类型必须相同
长度是固定的
数组的用处
- 如果想将数据存放在stack（栈）上而不是heap（堆）上，或者想保证固定数量的元素，这时使用数组更好
- 数组没有Vector灵活
  - Vector和数组类似，但是它由标准库提供
  - Vector的长度可以改变
声明数组
- 在中括号里，各值用逗号分开
rust 复制代码
```
let months = ["Jan", "Feb"];
```
- 特殊说明：数组的每个元素都相同，中括号中指定
- [初始值;数组的长度]
rust 复制代码
```
let a = [3;5];
// 相当于 
let a = [3,3,3,3,3];
```
数组的类型
- 形式：[类型; 长度]
- 例子
rust 复制代码
```
let a: [i32; 5] = [1,2,3,4,5];
```
访问数组元素
- 数组是在stack上分配的单个的块的内存
- 使用索引访问数组元素
rust 复制代码
```
let months = ["Jan", "Feb"];
let first = months[0];
let second = months[1];
```
- 如果访问的索引超过了数组范围
  - 编译会通过（不一定，有时候会做简单的检查）
  - 运行会报错（runtime 时会panic）

函数

声明函数

使用fn关键字
针对函数和变量的命名，遵循snake name，即使用全小写，单词和单词间使用"_"连接

rust 复制代码

fn main(){
	another_function();
}
fn another_function(){
	println!("Another function!");
}

函数参数

parameters 定义函数时使用的参数
arguments 调用函数时传入的函数参数
函数签名中必须申明每个参数的类型

rust 复制代码

fn main(){
	another_function(5);//arguments 
}
fn another_function(x:i32){//parameters 
	println!("the value of x is {}", x);
}

语句和表达式

函数体由一系列语句组成
有；就表示是一个语句。语句没有返回值，但是表达式有返回值
表达式会计算产生一个值

rust 复制代码

fn main(){
	let x = 1;
	// 可以这样写，并且y=4
	let y = {
		let x = 1;
		x+3
	}
}

函数的返回值

在->符号后面声明函数返回值的类型，但是不可以为返回值命名
在rust中返回值就是函数体里面最后一个表达式的值。
若想提前返回，需要使用return关键字，并指定一个值

rust 复制代码

fn five() -> i32{
	5
}
fn main(){
	let x = five();
	println!("the value is {}",x);
}

rust 复制代码

fn plus_five(x:i32) -> i32{
	x+5
}
fn main(){
	let x = plus_five(6);
	// 输出11
	println!("the value is {}",x);
}

注释

//
/* */

控制流

if else表达式

根据条件执行不同的分支（arm）
条件必须是bool类型
可选，if else

使用else if 处理多重条件，如果使用了多于一个else if，最好使用match来重构

rust 复制代码

fn main(){
	let number = 3;
	if number < 5 {
		println!("the number is < 5");
	} else {
		println!("the number is >= 5");
	}
}

循环

rust提供了三种循环：loop, while, for

loop循环

loop关键字告诉rust反复执行一块代码，直到喊停为止

rust 复制代码

fn main() {
    let mut number = 0;
    let result = loop{
        number += 1;
        if number == 10 {
        		// 可以在break后面接上语句
            break number*2;
        }
    };
    println!("The result is {}", result);
}

while循环

每次执行循环体之前都判断一次条件

rust 复制代码

fn main() {
    let mut number = 3;
    while number != 0 {
        println!("The number value is {}", number);
        number -=1;
    }
}

for 循环遍历集合

for 循环

rust 复制代码

fn main() {
    let a = [12,1,3,45];
    /// element 类型是 i32
    for element in a {
        println!("the value is {}", element);
    }
}

rust 复制代码

fn main() {
    let a = [12,1,3,45];
    /// element 类型是 &i32
    for element in a.iter() {
        println!("the value is {}", element);
    }
}

Range
- 标准库提供
- 指定一个开始数字，一个结束数字，Range可以生成 ** [开始数字，结束数字) **
- rev可以反转Range
rust 复制代码
```
fn main() {
// 将1，2，3 反转输出
for number in (1..4).rev() {
    println!("the value is {}", number);
}
}
```

2026/1/5