【Rust】快速教程——从hola,mundo到所有权

前言

学习rust的前提如下：
（1）先把Rust环境装好
（2）把VScode中关于Rust的插件装好

---

         \;\\\;\\\;

先写一个程序看看

新建一个hello.rs文件

fn main(){
    println!("hola,mundo!");
    let a=12;
    println!("{} is {}","a",a);
    let b=1;
    println!("{0}={0},{1}={1}",a,b); //如果注释这行，那么b没有被使用，就会报错！（够安全吧）
    println!("{{}},}},{{");  //只有括号
    
    let _c=-2;
    let _=-3;
}
1
2
3
4
5
6
7
8
9
10
11

在VScode中的终端中编译hello.rs生成hello.pdb和hello.exe两个文件，然后再运行hello.exe文件。如果是在windows的console窗口中，就直接输入hello就行了。

注：如果单独输入{，}会出错！！！

没有使用的变量会报错，但是加个下划线做前缀（let _b=1;），表示这个变量特殊处理，不使用也不会报错了！

         \;\\\;\\\;

Rust的基础

mut可变变量

普通定义的变量（let a=1;）默认是不可变的，所以不能再赋值（a=2;）—— 改成可变的（let mut a=1;）

fn main(){
    let mut a=1; 
    a=2; //有警告，表示在打印之前被覆盖了！
    println!("a={}",a);
}
1
2
3
4
5

上面出现warning的原因也是因为变量没有使用，在赋值和定义之间，原本的（变量，值）没有被使用！

• 把变量a都改成_a就没有警告了！

      \;\\\;

let重定义覆盖变量

fn main(){
    let a=1;
    let a=false;
    println!("a={}",a);
}
1
2
3
4
5

      \;\\\;

基本数据类型

fn main(){
    let a:f32 = 3.14159;println!("a={}",a);
    let a:f64 = 3.14159;println!("a={}",a);
    let a:bool=true;println!("a={}",a);
    let a:i8 = 12;println!("a={}",a);
    let a:u8 = 0b0000_1101;println!("a={}",a);
    let a:i16 = 12;println!("a={}",a);
    let a:u16 = 0xd;println!("a={}",a);
    let a:i32 = 1_24;println!("a={}",a);
    let a:u32 = 0xd;println!("a={}",a);
    let a:i64 = 12;println!("a={}",a);
    let a:u64 = 0xd;println!("a={}",a);
    let a:i128 = 12;println!("a={}",a);
    let a:u128 = 0xd;println!("a={}",a);
    let a:isize = 12;println!("a={}",a);
    let a:usize = 0xd;println!("a={}",a);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

      \;\\\;

复合类型（）和 [ ]

类型转换用as i64这种形式

复合类型的使用可以用 .0 .1 .2这种形式

fn main(){
    let x0=12u32;
    let x1=89;
    let x2=x0;
    
    let a:(i64,i64,i64) = (x0 as i64,x1,x2 as i64); //复合类型

    let (y0,mut y1,y2)=a;
    y1=-1;
    
    println!("y0={},y1={},y2={}",a.0,a.1,a.2);
}
1
2
3
4
5
6
7
8
9
10
11
12

      \;\\\;

数组

fn main(){
    let a:[i64;6]=[0,1,2,3,4,5];
    println!("first={},last={}",a[0],a[a.len()-1]);
}
1
2
3
4

      \;\\\;

字符串&str

Rust字符串类似C语言中的指针

这里的&str不是String，那个是结构体，变量是私有的，只能通过接口去使用它。

简单来说&str是固定长度的数组，而String是动态数组！

fn main(){
    let a: &str = "hello,word";
    let a="hola,mundo";

    let b: &str = a;
    println!("{}",b);
}
1
2
3
4
5
6
7

fn main() {
    let a:&str = "Dog";
    let b:String = "Cat".to_string();

    say(a);
    say(&b); //传递引用

    println!("a={}",a);
    println!("&a={}",&a);
    println!("b={}",b);
    println!("&b={}",&b);
}

fn say(name: &str) {
    println!("Hello, {}!", name);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

      \;\\\;

字符串String

fn main() {
    let a = String::from("i think of you a lot");

    let b = a.replace("you","the one"); //前面的替换成后面的
   
    println!("a={}",a);
    println!("b={}",b);
}
1
2
3
4
5
6
7
8

         \;\\\;\\\;

Rust的Misc

if

fn main(){
    let a=100;
    let mut b=0;

    //b钳制在0到62之间
    if a<0{
        b=0;
    }
    else if a<50{
        b+=a;
    }
    else if a<75{
        b=50 + (a-50)/2;
    }
    else{
        b=62;
    }

    let c = if b>50 { 1} else {-1};

    println!("a={},b={},c={}",a,b,c);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

      \;\\\;

循环while和loop和for

fn main(){
    let mut a=100;

    while a<0 {
        a-=1;
    }

    loop{
        let mut b=a;
        if b==100{
            break;
        }
        b+=1;
    }

    for i in -1..10 {
        a+=i;
    }

    println!("a={}",a);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

      \;\\\;

枚举与结构体

使用 #[derive()] 属性时，Rust 编译器会自动生成实现特定 traits 所需的代码，从而简化了手动编写这些代码的过程

#[derive(Debug)]
enum Person {
    Student,
    Teacher,
    Staff,
}

#[derive(Debug)]
struct Master{
    Dog:i32,
    Fish:i32,
    Cat:i32,
}

fn main() {
    let a = Person::Teacher;
    let b = Master{
        Dog:7,
        Fish:-7,
        Cat:0
    };

    println!("{:?}", a);
    println!("{:#?}",b);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

match

#[derive(Debug)]
enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn main() {
    let a = Coin::Dime;
    
    println!("{}",test(a));
}

fn test(a : Coin)-> i64{
    match a{
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

         \;\\\;\\\;

所有权

let a=1;
let b=a;
1
2

基本数据赋值时，标识符的值会被拷贝一份。

let a = String::from("hello");
let b = a;
1
2

字符串赋值时，标识符的值被拷贝，但是实际的字符串还是同一个。因为字符串多了一层，它的标识符的值只是实际字符串的地址而已！

let b = a.clone(); //这样才能真的拷贝一份
1

      \;\\\;

fn main(){
    let mut a=1;
    println!("[main]a={}",a);
    test(&mut a);
    println!("[main]a={}",a);
}
fn test(a:&mut i64){  //传入地址
    *a=2; //数据被修改了
    println!("[test]a={}",a);
}
1
2
3
4
5
6
7
8
9
10

fn main(){
    let a=String::from("hola");
    println!("[main]a={}",a);
    test(&a);
    println!("[main]a={}",a);
}
fn test(a:&String){ 
    println!("[test]a={}",a);
}
1
2
3
4
5
6
7
8
9

         \;\\\;\\\;