Rust学习之旅——基本数据结构类型

结构体

一个 struct 就是一些字段的集合。

字段是一个与数据类型相关联的数据值。它的值可以是基本类型或者是结构体类型。

它的定义就像是给编译器的蓝图，告诉编译器如何在内容中布局彼此相邻的字段。

struct SeaCreature {
	// String 是个结构体
	animal_type: String,
	name: String,
	arms: i32,
	legs: i32,
	weapon: String,
}

方法调用

与函数（function）不同，方法（method）是与特定数据类型关联的函数。

静态方法-属于某个类型，调用时使用 :: 运算符
动态方法-属于某个类型的实例，调用时使用 . 运算符

fn main() {
	// 使用静态方法来创建一个String实例
	let s = String::from("Hello world!");
	// 使用实例来调用动态方法
	println!("{} is {} characters long.", s, s.len());
}

内存

Rust 程序有3个存放数据的内存区域：

• 数据内存 - 对于固定大小和静态（即在整个程序生命周期中都存在）的数据。比如上一例子中的文本（例如“Hello world”），该文字的字节只能读取，因为它们位于该区域中。编译器对于这类数据做了很多优化，由于位置已知且固定，因此通常认为编译器使用起来非常快。
• 栈内存 - 对于在函数中声明为变量的数据。在函数调用期间，内存的位置不会改变，因为编译器可以优化代码，所以栈数据使用起来也比较快。
• 堆内存 - 对于在运行时创建的数据。此区域中的数据可以添加、移动、删除、调整大小等。因为它的动态特性，通常认为它使用起来比较慢，但是它允许更多创造性的内存使用。当数据添加到该区域时，我们称其为分配。从本区域中删除数据我们称之为释放。

在内存中创建数据

当我们在代码中实例化一个结构体时，我们的程序会在内存中并排创建相关的字段数据。
当我们通过制定所有字段值的方式来实例化时：
结构体 { … };
结构体字段可以通过 . 运算符来获取。

struct SeaCreature {
	animal_type: String,
	name: String,
	arms: i32,
	legs: i32,
	weapon: String,
}

fn main() {
	// SeaCreature 的数据在栈上
	let ferris = SeaCreature {
		// String 结构体也在栈上
		// 但也存放了一个数据在栈上
		animal_type: String::from("螃蟹"),
		name: String::from("Ferris"),
		arms: 2,
		legs: 4,
		weapon: String::from("大钳子"),
	};
	
	let sarah = SeaCreature {
		animal_type: String::from("章鱼"),
		name: String::from("Sarah"),
		arms: 8,
		legs: 0,
		weapon: String::from("无"),
	};
	println!(
	"{} 是只 {}。 它有 {} 只胳膊 {} 只腿。还有一个{}。",
	ferris.name, ferris.animal_type, ferris.arms, ferris.legs, ferris.weapon
	);
	println!(
	"{} 是只 {}。 它有 {} 只胳膊 {} 只腿。它没有杀伤性武器~",
	sarah.name, sarah.animal_type, sarah.arms, sarah.legs
	);
}

这个例子中的内存详情：

• 引号内的文本数据是只读数据（“例如ferris”），它位于数据内存区。
• 函数调用 String::from 创建一个结构体 String , 该结构体与SeaCreature的字段并排放置在栈中。字符串容器通过如下步骤表示可更改的文本：
  • 在堆上创建可修改文本的内存。
  • 将堆中存储对象的内存位置的引用存储在 String 结构体中。
• 最后，我们的两个朋友 Ferris 和 Sarah 是有在程序中总是固定的位置的数据结构，所以它们被放在栈上

类元组结构体

简洁起见，可以创建像元组一样被使用的结构体。

struct Location(i32, i32);

fn main() {
	// 这仍然是一个在栈上的结构体
	let loc = Location(42, 32);
	println!("{}, {}", loc.0, loc.1);
}

类单元结构体

结构体也可以没有任何字段。

就像第一章中提到的， 一个unit是一个空元组()的别称。这就是为什么，此类结构体被称为类单元。

这种类型的结构体很少用到。

struct Marker;

fn main() {
	let _m = Marker;
}

枚举

枚举允许使用 enum 关键字创建一个新类型，该类型的值可以包括几个带标记的元素。

match 有助于确保对多有可能的枚举值进行彻底的处理，使其成为确保高质量代码的强大工具。

#![allow(dead_code)]  // this line prevents compiler warnings

enum Species {
	Crab,
	Octopus,
	Fish,
	Clam
}

struct SeaCreature {
	species: Species,
	name: String,
	arms: i32,
	legs: i32,
	weapon: String,
}

fn main() {
	let ferris = SeaCreature {
		species: Species::Crab,
		name: String::from("Ferris"),
		arms: 2,
		legs: 4,
		weapon: String::from("claw"),
	};
	match ferris.species {
		Species::Crab => println!("{} is a crab.", ferris.name),
		Species::Octopus => println!("{} is a Octopus", ferris.name),
		Species::Fish => println!("{} is a fish", ferris.name),
		Species::Clam => println!("{} is a clam", ferris.name),
	}
}

带数据的枚举

enum 的元素可以有一个或者多个数据类型，从而使其表现得像C语言中的联合。
当使用 match 对另一个 enum 进行模式匹配时，可以将变量名称绑定到每个数据值。

enum 的内存细节：

• 枚举数据的内存大小等于它最大元素的大小。此举是为了让所有可能的值都能存入相同的内存空间。
• 除了每个元素数据类型（如果有）之外，每个元素还有个数字值，用于表示他是哪个标签。

其他细节

• Rust的 enum 也被成为标签联合（tagged-union）
• 把类型组合成一种新类型，着就是人们所说的Rust具有代数类型的含义。

#![allow(dead_code)]

enum Species { Crab, Octopus, Fish, Clam }
enum PoisonType { Acidic, Painful, Lethal }
enum Size { Big, Small }
enum Weapon {
    Claw(i32, Size),
    Poison(PoisonType),
    None
}

struct SeaCreature {
	species: Species,
	name: String,
	arms: i32,
	legs: i32,
	weapon: Weapon,
}

fn main() {
	// SeaCreature's data is on stack
	let ferris = SeaCreature {
		// String struct is also on stack
		// but holds a reference to data on heap
		species: Species::Crab,
		name: String::from("Ferris"),
		arms: 2,
		legs: 4,
		weapon: Weapon::Claw(2, Size::Small)
	};

	match ferris.species {
		Species::Crab => {
			match ferris.weapon {
				Weapon::Claw(num_claws, size) => {
				let size_description = match size {
					Size::Big => "big",
					Size::Small => "small",
				};
				println!("ferris is a crab with {} {} claws", num_claws, size_description)
                },
                _ => println!("ferris is a crab with some other weapon")
				}
			}
		},
		_ => println!("ferris is some other animal"),
	}
}