rust编程学习(二)：复合数据类型

复合数据类型是由其他类型组合而成的类型。Rust的复合数据类型有元组、数组、结构体、枚举等，通过一些简单的例子帮助大家快速了解Rust复合类型。

1 元组类型

元组类型是由一个或多个类型的元素组合成的复合类型，使用小括号"()"把所有元素放在一起。元素之间使用逗号"，"分隔。
元组中的每个元素都有各自的类型，且这些元素的类型可以不同。
元组的长度固定，一旦定义就不能再增长或缩短。

下面代码展示元组的一些使用方式：索引方式、元组解构、嵌套元组。元组解构其实就是对应元组中每个元素单独起一个名称进行取值。

复制代码

fn main() {
    let tup:(i32, f32, bool) = (1, 3.14, true); //显式声明元组类型
    println!("索引: {} {} {}", tup.0, tup.1, tup.2); //用点进行索引访问

    let (x, y, z) = tup;  // 元组解构,将对应位置的元素分别赋值给变量x, y, z
    println!("元组解构: x:{} y:{} z:{}", x, y, z);

    let con_tup = (1, 2.1, (false, 3.24)); //嵌套元组
    println!("嵌套元组: {} {} ({}, {})", con_tup.0, con_tup.1, con_tup.2.0, con_tup.2.1);

    let (x, y, (z, w)) = con_tup; //嵌套元组解构
    println!("嵌套元组解构: x:{} y:{} z:{} w:{}", x, y, z, w);
}

输出信息：

2.数组类型

数组类型是由相同类型的元素组合成的复合类型，我们可以使用[T; n]表示，T代表元素类型，n代表长度即元素个数。

隐式声明时，Rust编译器会自动推导变量类型。

数组有如下3种声明和初始化方式：

fn main(){
//1.显式声明：i32类型的数组, 长度为10；进行初始化为1-10
let arr:[i32; 10] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
//rust中 println!宏的参数: {:?} 可以打印debug的复合类型数据，比如数组、元组、结构体等
println!("数组: {:?}", arr); //打印数组
复制代码
```
  //2.隐式声明：i32类型的数组, 长度为10；进行初始化为1-10
  let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  println!("数组: {:?}", arr);

  //3.省略数组类型，为所有元素使用相同的值进行初始化。10个元素值都是1
  let arr = [1; 10];
  println!("数组: {:?}", arr);
```
}

输出信息：

3. 结构体类型

结构体类型是一个自定义数据类型，通过struct关键字加自定义命名，可以把多个类型组合在一起成为新的类型。和C/C++类似，采用struct关键字进行定义。
对于结构体打印内部各个元素，我们也可以使用println!("{:?}", xxx); 进行快速简便的打印，但是要在定义结构体前面加上#[derive(Default)]进行标识。

对于结构体声明时候，我们像省略参数，使用 #[derive(Default)]进行修饰，便可以在结构体初始化时候使用..Default::default()进行默认初始化。

fn main() {
#[derive(Default)] //使用derive宏，可以省略结构体的初始化值，使用默认值
#[derive(Debug)] //使用derive宏，可以通过println!("{:?}", p1);打印结构体数据
struct Person { //定义结构体
name: String,
age: i32,
height: f32,
weight: f32,
};

复制代码

  let p1 = Person {  //初始化结构体
      name: "张三".to_string(),
      age: 18,
      height: 1.75,
      weight: 80.0,
  };
  println!("{:?}", p1);

  let p2 = Person { //可以将p1的部分值用于p2进行初始化
      name: "李四".to_string(),
      ..p1 //结构体解构，使用p1的name, age, height, weight进行初始化
  };
  println!("{:?}", p2);

  let p3 = Person { //默认初始化
      name: "王五".to_string(),
      ..Default::default()
  };
  println!("{:?}", p3);

  //索引单个元素
  println!("索引 name={} age={} height={} weight={}", p3.age,p3.name,p3.height,p3.weight);

  //嵌套结构体
  #[derive(Debug)]
  struct Staff{
      person:Person,
      salary:i32,
      department:String,
  };

  let mut s1 = Staff{ //初始化结构体 定义可变变量s1
      person: p1, //把前面定义的p1赋值给person
      salary:10000,
      department:"研发部".to_string(),
  };

  //加薪😊
  s1.salary += 1000;
  println!("{:?}", s1);

}

输出信息:

4. 枚举类型

枚举类型是一个自定义数据类型，通过enum关键字加自定义命名来定义，内部包含多个枚举值，使用"枚举名::枚举值"访问枚举值。
区别于C/C++单一类型枚举的定义方式，Rust中的枚举类型支持多种复合类型，功能十分强大，用途广泛。

下面这个例子：定义一个包含多种数据类型的枚举，然后将枚举值存入一个数组，遍历数组，最后使用match进行枚举类型匹配，match类似于C/C++中switch，但是功能要强大很多。

fn main(){
struct CMYK {
c: i32,
m: i32,
y: i32,
k: i32,
}
enum Color {
Red,
Green,
Blue,
RGB(i32, i32, i32), //元组结构体
HSV { hue: i32, sat: i32, val: i32 }, //隐式结构体
CMYK(CMYK), //显式结构体
}

复制代码

  //定义一个数组，数组元素为Color枚举类型
  let colors:[Color; 6] = 
  [ Color::Red, 
    Color::Green,
    Color::Blue, 
    Color::RGB(255, 255, 255), 
    Color::HSV { hue: 0, sat: 0, val: 0 }, 
    Color::CMYK(CMYK { c: 0, m: 0, y: 0, k: 0 })
  ];
  
  //遍历数组
  for c in colors {
      match c { //匹配枚举类型
          Color::Red => println!("红色"),
          Color::Green => println!("绿色"),
          Color::Blue => println!("蓝色"),
          //定义变量x y z, 然后进行取值访问
          Color::RGB(x, y, z) => println!("RGB({}, {}, {})", x, y, z),
          //定义hue, sat, val进行结构体取值访问
          Color::HSV { hue, sat, val} => println!("HSV({}, {}, {})", hue, sat, val), 
          //定义cmyk结构体变量，进行取值访问
          Color::CMYK(cmyk) => println!("CMYK({}, {}, {}, {})", cmyk.c, cmyk.m, cmyk.y, cmyk.k),
      }
  }

}

输出信息：

5 小结

Rust语言中的复合数据类型主要是元组、数组、结构体、枚举4种，本篇文章通过一些小的demo帮助帮助大家学习理解复合元素类型，以便快速上手。

我是小C，欢迎大家一起交流学习～～～