Rust学习总结之数组，元组，结构体用法

         学过数据结构的都知道有这么一个公式，程序=数据结构+算法，好的数据结构能大大降低算法设计的复杂度，也能更好的为算法服务。了解一门新的计算机编程语言其数据结构是必须首先要学的，这有利于对该语言的理解和快速上手。本文将对Rust语言中的数组，元组，结构体的用法进行详细的介绍

目录

1，数组

2，元组

3，结构体

---

1，数组

        用过C语言的相信对数组的概念并不陌生，用过Python的看到Rust的数组形式想必十分的亲切。数组 array，将多个类型相同的元素依次组合在一起，就是一个数组。

        数组的三个原则：

• 长度固定                        ----数组的长度是固定的，初始化后长度就固定了
• 元素必须有相同的类型  ----数组的元素必须是一样的类型
• 依次线性排列                 ----数组的元素在内存中是在一起的

 举例：

fn main() {
    let s = ['f', 'e', 'i','t','z'];
}

        上面就是一个最简单的数组例子，里面包含了5个元素，在vscode中会自动在后面显示元素类型和元素的个数

当然你也可也以显示的写出来

fn main() {
    let s:[char;5] = ['f', 'e', 'i','t','z'];
}

访问数组的的某个元素和C语言中一样，通过下标来访问，下标从0开始

fn main() {
    let s:[char;5] = ['f', 'e', 'i','t','z'];
    println!("array s first element is {}",s[0]);
}

 遍历数组常见的有两种方式，一是通过数组下标去遍历，二是通过数组的可迭代属性去遍历

fn main() {
    let s:[char;5] = ['f', 'e', 'i','t','z'];
    //遍历数组s，方法一
    for index in 0..s.len(){
        println!("遍历数组:s[{}]:{}",index,s[index]);
    }
    //遍历数组s，方法二
    for element in s.iter(){
        println!("遍历数组s:{}",element);
    }
}

运行结果：

遍历数组:s[0]:f
遍历数组:s[1]:e
遍历数组:s[2]:i
遍历数组:s[3]:t
遍历数组:s[4]:z
遍历数组s:f
遍历数组s:e
遍历数组s:i
遍历数组s:t
遍历数组s:z

        上面计算数组的长度可以调用数组的len()方法

2，元组

        上面提到数组只能放入相同类型的元素，在Rust中有没有一种结构能放入不同类型的元素呢，元组就能符合这样的要求。元组的概念不是Rust独有的，在Python中也有元组，Rust元组的形式和Python很像。

Rust 语言中元组的定义语法格式如下：

let tuple_name:(data_type1,data_type2,data_type3) = (value1,value2,value3);

定义元组时也可以忽略数据类型

let tuple_name = (value1,value2,value3);

        Rust 中元组的定义很简单，就是使用一对小括号 () 把所有元素放在一起，元素之间使用逗号 , 分隔。但需要注意的是，如果显式指定了元组的数据类型，那么数据类型的个数必须和元组的个数相同

下面我们定义一个元组并打印出该元组

fn main() {
    let eg_tupple = ('f', 30, 174.5);
    println!("my info is {:?}",eg_tupple);
}

运行结果：

my info is ('f', 30, 174.5)

我们可以使用 元组名.索引数字 来访问元组中相应索引位置的元素。索引从 0 开始。 

fn main() {
    let eg_tupple = ('f', 30, 174.5);
    println!("my age is {}",eg_tupple.1);
    println!("my height is {}",eg_tupple.2);
}

运行结果：

my age is 30
my height is 174.5

3，结构体

        重头戏来了，数组和元组由于其结构的固定性，注定不能承担太复杂的数据结构设计，结构体以其灵活的结构可以承担复杂的数据结构设计，在C语言中结构体的运用就非常广泛，在Python中虽然没有结构体的概念，但是Python中的字典结构就非常类似于Rust的结构体。下面我们来详细学习一下Rust的结构体

定义一个结构体的语法格式如下

struct Name_of_structure {
   field1:data_type,
   field2:data_type,
   field3:data_type
}

定义一个结构体时：

1. 结构体名 Name_of_structure 和元素/字段名 fieldN 遵循普通变量的命名语法。
2. 结构体中中的每一个元素/字段都必须明确指定数据类型。可以是基本类型，也可以是另一个结构体。

下面我们定义一个结构体，并实例化

struct User{
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}
fn main() {
    let user1 = User{
        email: String::from("[email protected]"),
        username: String::from("ftz"),
        active: true,
        sign_in_count: 556,
    };
}

        我们定义了一个结构体User，实例化user1，实例化user1的时候并不需要严格按照结构体定义的变量顺序来初始化，需要注意的是我们初始化的时候必须要全部的成员初始化，不能部分初始化，部分不写

如果要访问结构体实例的某个元素，我们可以使用 元素访问符，也就是 点号 ( . ) 

struct User{
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}
fn main() {
    let user1 = User{
        email: String::from("[email protected]"),
        username: String::from("ftz"),
        active: true,
        sign_in_count: 556,
    };
    let my_name = user1.username;
    println!("my name is {}",my_name);
}

         结构体实例默认是 不可修改的，因为结构体实例也是一个使用 let 定义的变量，如果要修改结构体实例，就必须在创建时添加 mut 关键字，让它变成可修改的

当你想基于某个struct实例来创建一个新实例的时候，可以使用struct更新语法

#[derive(Debug)]
struct User{
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}
fn main() {
    let user1 = User{
        email: String::from("[email protected]"),
        username: String::from("ftz"),
        active: true,
        sign_in_count: 556,
    };
    let user2 = User{
        username: String::from("zte"),
        ..user1
    };
    println!("my info is {:#?}",user2);
}

 运行结果：

my info is User {
    username: "zte",
    email: "[email protected]",
    sign_in_count: 556,
    active: true,
}

 Rust结构体中还有一个tuple struct概念，元组结构体，tuple struct整体有个名，但里面的元素没有名。适用的场景是想给整个tuple起名，并让它不同于其他tuple，而且又不需要给每个元素起名。

#[derive(Debug)]

fn main() {
    struct Color(i32, i32, i32);
    struct Point(i32, i32, i32);
    let black = Color(0,0,0);
    let origin = Point(0,0,0);
}

black和origin是不同的类型，即使他们元组里面的元素一样，它们是不同的tuple struct实例

下面我们用struct写一个相对完整的Rust程序，计算长方形的面积，方便大家更容易理解结构体

#[derive(Debug)]
struct Rectangle{
    width: u32,
    length: u32,
}
fn main() {
    let rect = Rectangle{
        width: 30,
        length: 50,
    };
    println!("the area is {}",area(&rect));
    println!("the rect is {:#?}",rect);
}

//此处用引用&，就是借用rect, 在main中不丧失rect的所有权
fn area(rect: &Rectangle) ->u32{
    rect.width * rect.length
}

 运行结果：

the area is 1500
the rect is Rectangle {
    width: 30,
    length: 50,
}

好了！！！以上就是对Rust数组，元组，结构体学习总结，有不对的地方也欢迎批评指正，点个赞更好，嘻嘻嘻！！！