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

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

目录

1,数组

2,元组

3,结构体


1,数组

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

        数组的三个原则:

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

 举例:

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

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

Rust学习总结之数组,元组,结构体用法_第1张图片

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

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数组,元组,结构体学习总结,有不对的地方也欢迎批评指正,点个赞更好,嘻嘻嘻!!!

你可能感兴趣的:(Rust,rust,数组,元组,结构体)