复合类型_Rust常用的复合数据类型

一、数组

1.数组创建

一段连续空间中，存储了同类型的数据。

fn main() {
    let mut arr1 = [0, 1, 2, 3 ,4 ,5];
    let mut arr2 = [1 ; 6]; //创建大小为6，元素都是1的数组
    arr1 = arr2;    //arr和arr2是同大小和同数据类型，在Rust中是同一类型，因此可以相互赋值
    println!("arr1[0]: {}", arr1[0]);
    println!("arr2[0]: {}", arr2[0]);   //复习一下：因为拷贝时是复制语义，因此arr2还在
}

运行结果：

arr1[0]: 1
arr2[0]: 1

为啥这个数组是复制语义，如果还不明白这个问题，需要回上一期看一下哈。

2.一些数组的操作

fn main() {
    let mut arr1 = [0, 1, 2, 3 ,4 ,5];
    let mut arr2 = [1 ; 6]; //创建大小为6，元素都是1的数组
    println!("{:?}", arr1 < arr2);
}

运行结果：

true

上面是数组的比较。

fn main() {
    let mut arr1 = [0, 1, 2, 3 ,4 ,5];
    for i in &arr1 {
        println!("{}", i);
    }
}

运行结果：

0
1
2
3
4
5

数组的遍历。

3.多维数组

fn main() {
    let arr = [[0, 0], [0, 1], [1, 0], [1, 1]];
    for i in &arr {
        println!("{:?}", i);
    }
}

运行结果：

[0, 0]
[0, 1]
[1, 0]
[1, 1]

二、字符串

这里只讲一个程序：

fn main() {
    let mut str1 = String::from("Rust");  //String类型
    push_str1(&mut str1);
    println!("{}", str1);
    let mut str2 = "Rust";  //&str类型，因此并没有所有权
    push_str2(&mut str2);
    println!("{}", str2);
}

fn push_str1(str : &mut String) {
    str.push_str("NB!");
}

fn push_str2(str : &mut str) {
    str.push_str("NB!");
}

编译出错：

error[E0599]: no method named `push_str` found for type `&mut str` in the current scope
  --> srcmain.rs:15:9
   |
15 |     str.push_str("NB!");
   |         ^^^^^^^^ method not found in `&mut str`

就是说&mut str类型没有push_str方法。

String是字符串类型，可变长度。

&str类型只是借用，就算是&mut str，也只是对一块字符串的借用。没有管理空间的权利。

fn main() {
    let mut str1 = String::from("Rust");  //String类型
    push_str1(&mut str1);
    println!("{}", str1);
    let mut str2 = "Rust";  //&str类型，因此并没有所有权
//    push_str2(&mut str2);
    println!("{}", str2);
}

fn push_str1(str : &mut String) {
    str.push_str(" NB!");
}

//fn push_str2(str : &mut str) {
//    str.push_str("NB!");
//}

还有一点，Rust的字符串并不是char数组。char是unicode编码，String是utf-8编码。

三、struct

和c++不太一样，有点像json？

1.结构体定义及初始化

struct Point {
    x: i32,
    y: i32
}

逗号隔开。

struct Point {
    x: i32,
    y: i32
}

fn main() {
    let p1 = Point{ x: 2, y: 2};
    println!("{}, {}", p1.x, p1.y);
}

运行结果：

2,2

Rust还支持以下操作：

struct Point {
    x: i32,
    y: i32
}

fn default() -> Point {
    Point { x:0, y:0 }
}

fn main() {
    let p1 = Point{ x: 2, y: 2};
    let p2 = Point{..default()};
    let p3 = Point{ x:1,..default() };
    let p4 = Point{ y:2,..default() };
    println!("p1 at: ({}, {})", p1.x, p1.y);
    println!("p2 at: ({}, {})", p2.x, p2.y);
    println!("p3 at: ({}, {})", p3.x, p3.y);
    println!("p4 at: ({}, {})", p4.x, p4.y);
}

运行结果：

p1 at: (2, 2)
p2 at: (0, 0)
p3 at: (1, 0)
p4 at: (0, 2)

非常滴方便！

结构体方法

struct Circle {
    radius : f32
}

impl Circle {
    fn get_radius(&self) -> f32 {
        self.radius
    }

    fn show() {
        println!("I am a Circle!");
    }

    fn area(&self) -> f32 {
        3.14 * self.radius * self.radius
    }
}

fn main() {
    let circle = Circle { radius : 2.0 };
    println!("the radius: {}", circle.get_radius());
    println!("the area: {}", circle.area());
    Circle::show(); //类似于静态方法吧。这里只能用类名进行调用
}

运行结果：

the radius: 2
the area: 12.56
I am a Circle!

四、enum

1.枚举的定义和使用

枚举，其中数据之间的关系是“或”的关系。

两种定义方式：

#[derive(Debug)]
enum Os_type {
    Android,
    Apple
}

struct Phone {
    Os : Os_type,
    Brand : String
}

enum Phone2 {
    Android_phone(String),
    Ios_phone(String)
}

enum Num {
    Int(u32),
    Float(f32)
}   //可以是不同的数据类型

fn main() {
    let p1 = Phone { Os : Os_type::Android, Brand : String::from("MI10") }; //类似于C语言的定义方式
    let p2 = Phone { Os : Os_type::Apple, Brand : String::from("MI10") };
    let p3 = Phone2::Android_phone(String::from("HuaWei")); //Rust推荐的定义方式
}

那么我们怎么使用enum,如何定义枚举方法呢，下面一个例子做简单说明

//枚举方法及match
impl Num {
    fn showNumber(&self) {
        match *self {
            Num::Int(val) => println!("Int: {}", val),
            Num::Float(val) => println!("Float: {}", val)
        }
    }
}

fn main() {
    let num1 = Num::Int(20);
    let num2 = Num::Float(3.14);
    num1.showNumber();
    num2.showNumber();
}

运行结果：

Int: 20
Float: 3.14

五、vector

可变长数组：

常见操作示例如下：

fn main() {
    let v1 : Vec<i32> = Vec::new();    //没有意义。
    //第一种创建方式
    let mut v1 : Vec<i32> = Vec::new();
    v1.push(1);
    v1.push(2);
    v1.push(3);
    v1.push(4);
    //利用宏vec！创建
    let mut v2 = vec!(1, 2, 3, 4);

    //数据访问
    println!("v1[2]: {}", v1[2]);
    //但是不推荐上述方式
    //推荐以下方式
    match v1.get(2) {
        Some(value) => println!("v1[2]: {}", value),
        None => println!("index error")
    }

    //不可变遍历
    for i in &v2 {
        print!("{} ", i);
    }
    println!();
    //可变遍历
    for i in &mut v2 {
        *i += 2;
        print!("{} ", i);
    }
}

运行结果：

v1[2]: 3
v1[2]: 3
1 2 3 4 
3 4 5 6

欢迎关注微信公众号：Rust编程之路