4.通用编程概念

目录

• 一、变量与常量
• • 1.1 变量
  • 1.2 常量
• 二、遮蔽
• 三、数据类型
• • 3.1 标量类型
  • • 1. 整型
    • 2. 浮点型
    • 3. 布尔类型
    • 4.字符类型
  • 3.2 复合类型
  • • 1. 元组
    • 2. 数组
• 四、函数
• 五、语句和表达式
• 六、函数的返回值

一、变量与常量

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类型的x
    let 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 类型取决于程序运行的计算机体系结构。

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

整型溢出的问题

      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;       //f64
    let 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,z

    println!("{} {} {}", x, y, z); //访问tup2的方式1
    println!("{} {} {}", tup2.0, tup2.1, tup2.2) //访问tup2的方式1
}

2. 数组

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

fn main(){
    let a = [1, 2, 3, 4, 5]; //定义默认i32的5个元素的数组，组内元素为1~5
    let b: [i64; 5] = [1, 2, 3, 4, 5]; //定义i64型的5个元素的数组，组内元素为1~5
    let 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=7

    println!("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
}