rust 基础02

发表于 | 分类于

所有权

规则

  • Rust 中的每个值都有一个变量，称为其所有者。
  • 一次只能有一个所有者。
  • 当所有者不在程序运行范围时，该值将被删除。

移动和克隆

移动

  • 对于基础类型的数据，移动就是进行复制
    1
    2
    3
    4
    5
    6
    fn main() {
        let x = 5;
        let y = x;

        println!("{},{}",x,y); // x,y都有效
    }
  • 需要在堆上分配内存的数据类型
    1
    2
    3
    4
    5
    6
    fn main() {
        let x = String::from("hello world");
        let y = x;

        println!("{},{}",x,y); // x作废了,只有y有效 borrow of moved value: `x`
    }
  • 解决第二种情况的方法是使用克隆
    1
    2
    3
    4
    5
    6
    7
    fn main() {
        let x = String::from("hello world");
        let xx = x.clone();
        let y = x;

        println!("{},{}",xx,y);
    }

    在函数中的使用

    作为参数

    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
    26
    fn main() {
        let x = String::from("hello world");
        show_str(x); // x移动到了函数里面，所以x的作用域在往下就失效了

        println!("{}",x); // x失效了

        let m = 10;
        show_int(m); // m也是移动到了函数中，但是基础类型的变量的分配是在栈里面，这里的移动本质上是复制，所以m在下面的作用域中还是有效了
        println!("{}",m);

        let str = String::from("gphper");
        show(&str); // 使用引用的方式可以保证，函数外面的变量不会失效
        println!("{}",str);
    }

    fn show_str(str:String){
        println!("{}",str);
    }

    fn show_int(i:i32) {
        println!("{}",i);
    }

    fn show(str:&String){
        println!("{}",*str);
    }

切片

1
2
3
4
5
6
7
8
fn main() {
    let s = String::from("broadcast");

    let s1 = &s[1..2];
    let s2 = &s[3..4];

    println!("{}+{}",s1,s2);
}

结构体

Struct

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
fn main() {
    struct Student{
        username:String,
        sex:String,
        score:u32
    }

    let mut s = Student{
        username:String::from("gphper"),
        sex:String::from("男"),
        score:100
    };

    s.score = 200;

    println!("{},{},{}",s.username,s.sex,s.score);
}

结构体打印调试的方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
fn main() {

    #[derive(Debug)]
    struct Student{
        username:String,
        sex:String,
        score:u32
    }

    let mut s = Student{
        username:String::from("gphper"),
        sex:String::from("男"),
        score:100
    };

    s.score = 100;

    println!("{:#?}",s);
    println!("{},{},{}",s.username,s.sex,s.score);
}

Tuple Struct

  • 为元组类型添加一个名称标识
    1
    2
    3
    4
    5
    6
    7
    fn main() {
        struct Student(String,String,u32);

        let s = Student(String::from("gphper"),String::from("男"),200);

        println!("{},{},{}",s.0,s.1,s.2);
    }

    结构体的方法和关联函数

    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
    26
    27
    #[derive(Debug)]
    struct Rectangle {
        width: u32,
        height: u32,
    }

    impl Rectangle {
        
        // 方法
        fn area(&self) -> u32{
            self.width * self.height
        }

        // 关联函数
        fn square(size:u32) -> Rectangle{
            Rectangle { width: size, height: size }
        }
    }

    fn main() {
        let r = Rectangle{width:20,height:30};
        let area = r.area();
        println!("{}",area);

        let square = Rectangle::square(20);
        println!("{:#?}",square);
    }