通用编程概念

大家好，我是一位正在学习rust的小菜鸟，我想把自己学习的过程分享出来，谢谢大家。

变量的可变性与不可变性

在rust中变量和其他语言的略有不同，比如在C语言中定义一个变量可以对其进行修改赋值等操作，但是在rust中变量如果不使用“mut”关键字是不能够被二次赋值和修改的

fn main() {
    let a = 1;
    a = 2;//其中这个变量a是不可以被修改的

    let mut b = 1;//加入mut关键字修饰就可以被修改
    b=2;
    println!("a = {}", a);//println!是rust中的输出{}是相当于C语言的%d之类的
    println!("b = {}", b);
}

但是这并不是常量rust中的常量是由const关键字声明的。

const PI = 3.14; //常量的声明

隐藏

通过下面的例子可以清楚的知道隐藏不仅可以让a二次赋值还可以改变其变量类型

fn main() {
    let a =1;
    let a =3;
    let a = a+1;
    let a = String::from("hello");
}

数据类型

整型

imagepng

每一个变体都可以是有符号或无符号的，并有一个明确的大小。有符号 和 无符号 代表数字能否为负值，换句话说，这个数字是否有可能是负数（有符号数），或者永远为正而不需要符号（无符号数）。

imagepng

整型溢出

这段话直接抄袭的文档

比方说有一个 u8 ，它可以存放从零到 255 的值。那么当你将其修改为 256 时会发生什么呢？这被称为 “整型溢出”（“integer overflow” ），这会导致以下两种行为之一的发生。当在 debug 模式编译时，Rust 检查这类问题并使程序 panic，这个术语被 Rust 用来表明程序因错误而退出。第九章 [“panic! 与不可恢复的错误”]部分会详细介绍 panic。

在 release 构建中，Rust 不检测溢出，相反会进行一种被称为二进制补码包装（two’s complement wrapping）的操作。简而言之，值 256 变成 0，值 257 变成 1，依此类推。依赖整型溢出被认为是一种错误，即便可能出现这种行为。如果你确实需要这种行为，标准库中有一个类型显式提供此功能，Wrapping。为了显式地处理溢出的可能性，你可以使用标准库在原生数值类型上提供的以下方法:

所有模式下都可以使用 wrapping_* 方法进行包装，如 wrapping_add
如果 check_* 方法出现溢出，则返回 None值
用 overflowing_* 方法返回值和一个布尔值，表示是否出现溢出
用 saturating_* 方法在值的最小值或最大值处进行饱和处理

浮点型

Rust 的浮点数类型是 f32 和 f64，分别占 32 位和 64 位。

fn main() {
    let x = 2.0; // f64

    let y: f32 = 3.0; // f32
}

rust中的运算和其他语言一样

fn main() {
    // 加法
    let sum = 5 + 10;
    // 减法
    let difference = 95.5 - 4.3;
    // 乘法
    let product = 4 * 30;
    // 除法
    let quotient = 56.7 / 32.2;
    let floored = 2 / 3; // 结果为 0
    // 取余
    let remainder = 43 % 5;
}

布尔

fn main() {
    let t = true;

    let f: bool = false; // 显式指定类型注解
}

复合类型

元组类型

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}
//可以利用将其替换，这叫做解构
fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {}", y);
}
//当然你也可以使用点号直接访问
fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0;

    let six_point_four = x.1;

    let one = x.2;
}

数组类型

最基础的用法

fn main() {
    let a = [1, 2, 3, 4, 5];
}

当然可以显示的标注数据类型

#![allow(unused)]
fn main() {
let a: [i32; 5] = [1, 2, 3, 4, 5];
}

访问数组元素和其他的语言一样并没有差距

fn main() {
    let a = [1, 2, 3, 4, 5];

    let first = a[0];
    let second = a[1];
}

函数

关于上面最简单的基本介绍已经完成了，接下来就进入函数环节

在rust中函数其实和其他语言差距不大，定义的关键字是fn

fn main() {
    another_function(5);
}
//很简单传入一个参数
fn another_function(x: i32) {
    println!("The value of x is: {}", x);
}

语句和表达式

语句不会返回值，表达式可以

这样可以玩一个很酷的操作

fn main() {
    let y = {
        let x = 3;
        x + 1 //这里应为作为返回值所以不能写";"
    };

    println!("The value of y is: {}", y);
}

同理函数返回值也可以使用不加“；”来实现

fn five() -> i32 {
    5
}

fn main() {
    let x = five();

    println!("The value of x is: {}", x);
}

注释

// 最普通的注释，剩下的后面使用发布的时候讲解

控制流

if 表达式

fn main() {
    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");
    }
}
//在let中使用if，但是必须保证几种返回情况的数值类型相同
fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };

    println!("The value of number is: {}", number);
}

循环

loop无线循环当然可以使用break退出同理也可以使用break返回值

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("The result is {}", result);
}

while循环基本上很少用，而且rust中不适用while(true)这种，可以使用loop直接代替

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{}!", number);

        number -= 1;
    }

    println!("LIFTOFF!!!");
}

for遍历集合

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a {
        println!("the value is: {}", element);
    }
    for i in a.iter() {
        println!("the value is: {}", i);//这两个输出的一样
    }
}

fn main() {//这个可以是数据反转
    for number in (1..4).rev() {
        println!("{}!", number);
    }
    println!("LIFTOFF!!!");
}

Rust学习（一）