4.通用编程概念-CSDN博客

本文链接：https://blog.csdn.net/wzj_sxpi/article/details/139514559

一、变量与常量

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 常量

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

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

长度	有符号类型	无符号类型
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;       //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
}

七、控制流

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);  //353
    if 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);  //2

    let 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 1
    for item in (1..4).rev(){
        println!(" item = {} ", item);
    }
}