Rust语言开发基础（九）复杂数据类型：结构体，枚举，泛型

一、结构体
结构体是一种复合结构类型，是数个简单基础类型的集合体。
struct Point {
x: i32,
y: i32,
}
fn main() {
let origin = Point { x: 0, y: 0 }; // origin: Point
println!("The origin is at ({}, {})", origin.x, origin.y);
}

1. 使用大写字母开头并且使用驼峰命名法。
2. 使用圆点来调用结构体里的变量。
3. 结构体默认值不可变，使用mut使其可变，但是不支持结构体里面字段的可变性，即mut不能修饰里面的字段。
4. 使用..拷贝其它结构体的值。
struct Point3d {
x: i32,
y: i32,
z: i32,
}
可以拷贝自己
let mut point = Point3d { x: 0, y: 0, z: 0 };
point = Point3d { y: 1, .. point };
或者也可以拷贝其它结构体
let mut point = Point3d { x: 0, y: 0, z: 0 };
point = Point3d { y: 1, .. point };
结果是：point = Point3d { x: 0, y: 1, z: 0 };

元组结构体（衍生）
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

1. 没有字段名称。

2. 即使值与结构体相同，两者也是不相等的。
let black = Color(0, 0, 0);
let origin = Point(0, 0, 0);
即black!=origin

3. 比较适合的场景：单元素的元组结构，也称为“新类型”。
struct Inches(i32);
let length = Inches(10);
let Inches(integer_length) = length;
println!("length is {} inches", integer_length);
意思是let Inches(integer_length)给 integer_length 赋值为 10 。

类单元结构体（衍生）
1.无字段，没有任何成员变量：struct Electron;
2.用处较少，省略

二、枚举
枚举是一个代表数个可能变量的数据的类型
1.可以携带各种类型的变量
enum Message {
Quit, //类单元结构体
ChangeColor(i32, i32, i32), //元组结构体
Move { x: i32, y: i32 }, //结构体
Write(String), //方法函数
}
上述枚举类似一个网络游戏的消息

2. 可以通过两个冒号::来实现枚举里的变量的调用及其赋值
Message枚举的调用：
let x: Message = Message::Move { x: 3, y: 4 };

enum BoardGameTurn {
Move { squares: i32 },
Pass,
}
let y: BoardGameTurn = BoardGameTurn::Move { squares: 1 };

3. 典型的使用错误
let Message::ChangeColor(r, g, b) = msg; // compile-time error
直接绑定类型的操作不被支持

4. 典型应用：枚举的构造器可以当函数一样使用
这里会考虑将函数作为参数传递给其他函 数。
例如，使用迭代器，我们可以这样把一个 String 的vector转换为一个 Message::Write 的vector：
let v = vec!["Hello".to_string(), "World".to_string()];
let v1: Vec<Message> = v.into_iter().map(Message::Write).collect();

三、泛型

泛型类

案例1.标准库中的一个类型
enum Option<T> {
Some(T),
None,
}
使用：
let x: Option<i32> = Some(5);
let y: Option<f64> = Some(5.0f64);

案例2. Rust内建类型

enum Result<T, E> {
Ok(T),
Err(E),
}

泛型函数

1. 普通单泛型类约束
fn takes_anything<T>(x: T) {
// do something with x
}
<T>代表“这个函数带有一个泛型类型”，而x:T代表“x是T类型的”。

2. 多参数一泛型类型约束

fn takes_two_of_the_same_things<T>(x: T, y: T) {
// ...
}

3. 多参数多泛型类型约束
fn takes_two_things<T, U>(x: T, y: U) {
// ...
}

泛型函数结合“特性约束”时最有用

泛型结构体

struct Point<T> {
x: T,
y: T,
}
let int_origin = Point { x: 0, y: 0 };
let float_origin = Point { x: 0.0, y: 0.0 };