4.通用编程概念

一、变量与常量

1.1 变量

      在Rust中默认的变量是不可变的，如果修改其值会导致错误。

fn main(){let x = 3;x = 5;  //error[E0384]: cannot assign twice to immutable variable `x`
}

定义变量时添加mut关键字就能解决以上问题，例如let mut x = 3

1.2 常量

1. 常量必须使用const定义，且类型必须被标注。
2. 常量可以在任何作用域内进行声明，包括全局作用域。
3. 常量只可以绑定到常量表达式
4. 常量使用全大写字母，每个单词之间用下划线分隔
5. 数字可以用_分隔，以增加可读性

const MAX_POINTS:u32  100_000;

二、遮蔽

在Rust中，可以定义不同类型/相同类型的相同变量而不会报错，例如

fn main(){let x = 3;let x = x + 5;  //同为i32类型的xlet x = String::from("Hello");  //将x设置为String类型println!("{}", x);
}

三、数据类型

      Rust是一门静态类型语言，在编译期内就必须知道变量的类型，因此将一个字符型的整数转换成真正的整数型时，就必须显式的定义类型。

fn main(){let x  = "42".parse().expect("Not a number"); //let x:u32  = "42".parse().expect("Not a number"); 这是正确的println!("{}", x);
}

通过下面的报错信息可以很明显的知道应该如何修改源码

3.1 标量类型

      Rust有四种基本的标量类型：整型、浮点型、布尔型以及字符型

1. 整型

      下表展示的Rust语言中的整型，后面的数字代表了所示用的位数，isize 和 usize 类型取决于程序运行的计算机体系结构。

长度	有符号类型	无符号类型
8 位	i8	u8
16 位	i16	u16
32 位	i32	u32
64 位	i64	u64
128位	i128	u128
arch	isize	usize

也可以按照下表中所示的任意形式来表示整型的字面量

数字字面量	示例
十进制	98_222
十六进制	0xff
八进制	0o77
二进制	0b1111_0000
字节 (仅限于 u8)	b’A’

整型溢出的问题

      u8可以存放0~255的值，如果存放256则会发生整型溢出，在调试模式（debug）下编译，Rust会检查溢出，在发布模式（release）下构建时，Rust对于溢出的处理时采用取余的方式循环。比如在 u8 的情况下，256 变成 0，257 变成 1。
      要显式处理溢出的可能性，可以使用标准库针对原始数字类型提供的以下一系列方法：

• 使用 wrapping_* 方法在所有模式下进行循环，例如 wrapping_add
• 如果使用 checked_* 方法时发生溢出，则返回 None 值
• 使用overflowing_*方法返回该值和一个指示是否存在溢出的布尔值
• 使用 saturating_* 方法使值达到最小值或最大值

2. 浮点型

      在 Rust 中浮点型数字也有两种基本是 f32 和 f64，它们的大小分别为 32 位和 64 位。默认浮点类型是 f64，浮点型都是有符号的。

fn main(){let x = 83.1;       //f64let y:f32 = 83.1;   //f32
}

3. 布尔类型

      Rust 中的布尔类型有两个可能的值：true 和 false。布尔值的大小为 1 个字节。Rust 中的布尔类型可以使用 bool进行显式的声明。

fn main() {let t = true;let f: bool = false; // 显式声明为布尔型
}

4.字符类型

      字符类型字面量用单引号引起来，Rust 的字符类型大小为 4 个字节，表示的是一个 Unicode 标量值，这意味着它可以表示的远远不止是 ASCII。标音字母，中文/日文/韩文的文字，emoji，还有零宽空格(zero width space)在 Rust 中都是合法的字符类型。

fn main() {let c = 'z';let z = 'ℤ';let heart_eyed_cat = '😻';
}

3.2 复合类型

      Rust有两种复合类型：元组（tuple）和数组（array）。

1. 元组

      将多种类型的多个值组合到一个复合类型中的一种基本方式，元组的长度是固定的。

fn main(){let tup = (500, 30.1, "China");  //默认的类型创建元组let tup2:(i64, f32, bool) = (35, 34.1, true);  //显式创建元组let (x, y, z) = tup2; //将tup2中的三个值分别赋给x,y,zprintln!("{} {} {}", x, y, z); //访问tup2的方式1println!("{} {} {}", tup2.0, tup2.1, tup2.2) //访问tup2的方式1
}

2. 数组

数组的每个元素的元素类型必须相同，且数据的长度固定。

fn main(){let a = [1, 2, 3, 4, 5]; //定义默认i32的5个元素的数组，组内元素为1~5let b: [i64; 5] = [1, 2, 3, 4, 5]; //定义i64型的5个元素的数组，组内元素为1~5let c = [3; 5];   //长度为5，元组全为3，即相当于[3, 3, 3, 3, 3]for item in c{println!("item = {}", item) //循环输出c内的元素}println!("a[0] = {}", a[0]);   //单个访问
}

四、函数

Rust的函数以fn关键字开头，函数和变量名中所有字母都是小写并使用下划线分隔单词，函数参数必须指明类型。

fn another_function(x: i32, source: &str){println!("x = {}, source = {}", x, source);
}fn main(){another_function(32, "China");
}

五、语句和表达式

• 函数的函数体由一系列语句组成，也可以表达式结尾。
• 语句是执行一些操作但不返回值的指令。表达式（expression）计算并产生一个值。

fn main(){// let x = (let y = 6); //语句不返回值，因此bool得不到初始值let x = {let  y = 6;y + 1    //不能加分号结尾，加分号后就成了语句};  //{}整体是表达式，返回值是y+1=7println!("x = {}", x);
}

六、函数的返回值

• rust并不对返回值命令，以->声明返回值的类型。
• rust中的函数返回值等于最后一个表达式的值。
• 使用return x可以提前返回

fn get_return_value(x: i32) -> i32 {if x < 0{return -1;}x
}fn main() {let x = get_return_value(-1);let y = get_return_value(10);println!("{}, {}", x,y);  //-1, 10
}

七、控制流

7.1 if……else

fn main() {let x = 353;if x < 30 {   //必须是bool值，否则会报”expected `bool`, found xxx“的错误println!("less");}//用if直接赋值，无法写成三目运算let x = if x > 1024 { 1024 } else { x };println!("x = {}", x);  //353if x % 4 == 0 {println!("number is divisible by 4");} else if x % 3 == 0 {println!("number is divisible by 3");} else if x % 2 == 0 {println!("number is divisible by 2");} else {println!("number is not divisible by 4, 3, or 2");}
}

7.2 loop

• loop相当于while(1)死循环
• 仍然支持C/C++中的continue，break关键字。
• 可以用break 返回值跳出循环。

fn main() {let mut x = 0;loop{if x > 10{break;}println!("x = {}", x);x += 1;}let mut y = 0;let total = {loop{if y > 10{break y * y;}y += 1;}};println!("total = {}", total);  //121
}

7.3 while和for

fn main() {let mut number = 3;//while循环while number > 2 {number -= 1;}println!("result = {}",number);  //2let a = [10, 20, 30, 40, 50];//循环输出(每一个值都赋值给item，然后打印)for item in a{println!(" item = {} ", item);}println!("************");//循环输出(item指向a中的要输出的部分(没有了拷贝的过程))for item in a.iter(){println!(" item = {} ", item);}println!("************");//循环计数//取的值是1,2,3，通过rev()进行反转，就变成了3 2 1for item in (1..4).rev(){println!(" item = {} ", item);}
}