乐趣区

关于rust:Compound-Data-Type-of-Rust

jiezi

概 述

良久没有更新 rust 相干的内容了，更新一波 Rust 的内容，本篇讲介绍一下 Rust 中的复合数据类型。

Composite Type

复合数据类型 是一种数据类型，它能够原始的根本数据类型和其它的复合类型所形成，形成一个复合类型的动作，又称作组合。

本文讲介绍一下在 Rust 中有 tuple、array、struct、enum 几个复合类型。

tuple

tuple即 元组 ，元组类型是由多个不同类型的元素组成的复合类型，通过() 小括号把元素组织在一起成一个新的数据类型。元组的长度在定义的时候就曾经是固定的了，不能批改，如果指定了元素的数据类型，那么你的元素就要对号入座！！！否则编译器会教训你！

例子：

fn main() {
    // 指定数据类型
    let tup_type:(i8,i32,bool) = (21,-1024,true);
    // 解构元素
    let (one,two,three) = tup_type;
    // 二维的元组
    let tup_2d:(f64,(i8,i32,bool)) = (3.1415927,(one,two,three));
    println!("tup_2d = {:?}",tup_2d);
    // 索引
    println!("π = {:?}",tup_2d.0);
}

元组的拜访形式有好几种，通过下标去拜访，也能够应用解构赋值给新的变量去拜访，然而不反对迭代器去拜访。

for v in tup_2d.1.iter() {println!("{}",v)
}
   Compiling playground v0.0.1 (/playground)
error[E0599]: no method named `iter` found for tuple `(i8, i32, bool)` in the current scope
  --> src/main.rs:10:23
   |
10 |     for v in tup_type.iter() {|                       ^^^^ method not found in `(i8, i32, bool)`

error: aborting due to previous error

For more information about this error, try `rustc --explain E0599`.
error: could not compile `playground`

To learn more, run the command again with --verbose.

元组 的每个元素的类型能够不同，因而您无奈对其进行迭代。元组甚至不能保障以与类型定义雷同的顺序存储数据，因而即便您本人为它们实现Iterator，它们也不适宜进行无效的迭代。

然而如果元素是反对实现了 Iterator 就能够通过 .iter() 进行迭代拜访。

    let mut arrays:[usize;5] = [0;5];
    
    for i in 0..5 {arrays[i] = i+1;
    }
    
    println!("{:?}",arrays);
    
    let tup_arr:(&str,[usize;5]) = ("tup_arr",arrays);
    
    println!("{:?}",tup_arr);
    
    for v in tup_arr.1.iter() {println!("{}",v)
    }

例如上的元素是一个 array，Rust 中的数组和其余语言一样，一组类型雷同的元素组成的复合类型，数组在底层存储是一块间断的内存空间。

array

Rust中的数组申明是 [T;n] 进行的，T是元素类型，n是这组元素有多少个坑位，创立的时候能够去掉类型和大小，程序会主动推断进去。

    // 数组
    let arr:[f32;3] = [1.0,2.2,3.33];
    
    println!("{:?}",arr);
    
    // 类型主动推导
    let arr_infer = ["Hello",",","World!"];
    
    let mut str = String::new();
    // 迭代器
    for v in arr_infer.iter() {str.push_str(v);
    }
    
    println!("str = {}",str);

点击查看元组代码案例

enum

枚举类型，如果你之前从事过 Java 相干的开发应该不生疏，在 Rust 外面也有 枚举 类型，枚举类型是一个自定义数据类型，通过 enum 关键字来申明，body外面能够蕴含多个自定义的枚举值，枚举能够用来限度某个值或者类型范畴。

    #[derive(Debug)]
    enum Gender {
        Boy,
        Girl,
    }

下面就定义一了个类型名字为 Gender 的枚举，Boy和 Girl 是枚举可供使用的值，#[derive(Debug)]正文是让 Gender 主动实现 Debug tarit 前面文章将深刻。

struct

构造体能够把一些自定义的数据类型通过已有的类型组装成一个新的自定义数据类型，通过 struct 关键字就能够创立一个构造体，构造体字段格局 name:type，name 是构造体字段名，type是字段的类型，默认是不可变的。

fn main() {

    // 枚举当初取值范畴
    #[derive(Debug)]
    enum Gender {
        Boy,
        Girl,
    }
    
    // 定义一个构造体
    #[derive(Debug)]
    struct Programmer<'skill> {
        name: String,
        skill: [&'skill str; 3],
        sex: Gender,
    }
    
    // 创立一个实例
    let engineer = Programmer {name: String::from("Jaco Ding"), // String 类型内容可变
        skill: ["Java","Go","Rust"], // 一个长度为 3 的字符串面量类型的数组
        sex:Gender::Boy, // 通过枚举限度参数类型
    };
    
    println!("engineer = {:?}",engineer);
}

有了自定义的类型了也就是 struct 就能够通过自定义的类型来解决一些非凡的需要了，例如上面的代码定义了一个元素类型为 Programmer 长度为 2 的数组。

    let Doris = Programmer {name: String::from("Doris"),
        skill: ["Vue","TypeScript","JavaScript"],
        sex:Gender::Girl,
    };
    
    let Jaco = Programmer {name: String::from("Jaco"),
        skill: ["Java","Go","Rust"],
        sex:Gender::Boy,
    };
    
    let employees:[Programmer;2] = [Doris,Jaco];
    
    for e in employees.iter() {println!("{:?}",e)
    }

构造体 Programmer 上的 <'skill> 解决skill 数组的生命周期问题 undeclared lifetime，所有权问题，所有权是Rust 语言外围的知识点，这些在前面文章中缓缓更新。

小结

Rust中的构造体还有两种非凡构造：元组构造体 、 单构造体 ，枚举也有 带有参数 的枚举。。。本文就学习总结了一下常见复合类型的应用，未深刻。

退出移动版