复合数据类型是由其他类型组合而成的类型。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，欢迎大家一起交流学习～～～