文章目录
- [第6章 结构体与方法](#第6章 结构体与方法)
-
- [6.1 定义和实例化结构体](#6.1 定义和实例化结构体)
-
- [6.1.1 基本结构体定义](#6.1.1 基本结构体定义)
- [6.1.2 元组结构体](#6.1.2 元组结构体)
- [6.1.3 结构体高级特性](#6.1.3 结构体高级特性)
- [6.2 方法语法](#6.2 方法语法)
-
- [6.2.1 基本方法定义](#6.2.1 基本方法定义)
- [6.2.2 高级方法特性](#6.2.2 高级方法特性)
- [6.3 关联函数](#6.3 关联函数)
-
- [6.3.1 关联函数基础](#6.3.1 关联函数基础)
- [6.3.2 高级关联函数模式](#6.3.2 高级关联函数模式)
- [6.4 元组结构体进阶](#6.4 元组结构体进阶)
-
- [6.4.1 元组结构体的高级用法](#6.4.1 元组结构体的高级用法)
第6章 结构体与方法
6.1 定义和实例化结构体
6.1.1 基本结构体定义
结构体是Rust中创建自定义数据类型的主要方式，让我们从基础开始深入理解结构体的定义和使用。
rust
fn basic_struct_definition() {
println!("=== 基本结构体定义 ===");
// 1. 定义简单的结构体
#[derive(Debug)]
struct User {
username: String,
email: String,
sign_in_count: u64,
active: bool,
}
// 2. 实例化结构体
let user1 = User {
email: String::from("someone@example.com"),
username: String::from("someusername123"),
active: true,
sign_in_count: 1,
};
println!("用户1: {:?}", user1);
// 3. 访问结构体字段
println!("用户名: {}", user1.username);
println!("邮箱: {}", user1.email);
println!("活跃状态: {}", user1.active);
println!("登录次数: {}", user1.sign_in_count);
// 4. 修改结构体字段（需要mut）
let mut user2 = User {
email: String::from("another@example.com"),
username: String::from("anotheruser"),
active: true,
sign_in_count: 0,
};
user2.sign_in_count = 1;
user2.active = false;
println!("修改后的用户2: {:?}", user2);
// 5. 字段初始化简写
let email = String::from("shorthand@example.com");
let username = String::from("shorthanduser");
let user3 = User {
email, // 字段名与变量名相同时可以省略
username, // 同上
active: true,
sign_in_count: 1,
};
println!("简写语法用户: {:?}", user3);
// 6. 结构体更新语法
let user4 = User {
email: String::from("update@example.com"),
username: String::from("updateuser"),
..user3 // 使用user3的其他字段
};
println!("更新语法用户: {:?}", user4);
}
fn struct_instantiation_patterns() {
println!("\n=== 结构体实例化模式 ===");
// 1. 函数式实例化
fn create_user(email: String, username: String) -> User {
User {
email,
username,
active: true,
sign_in_count: 1,
}
}
let user = create_user(
String::from("functional@example.com"),
String::from("functionaluser"),
);
println!("函数式创建: {:?}", user);
// 2. 构建器模式
let user = UserBuilder::new()
.email("builder@example.com")
.username("builderuser")
.build();
println!("构建器模式: {:?}", user);
// 3. 默认值实例化
#[derive(Debug, Default)]
struct Config {
timeout: u32,
retries: u32,
debug_mode: bool,
}
let config = Config::default();
println!("默认配置: {:?}", config);
let custom_config = Config {
timeout: 30,
..Config::default()
};
println!("自定义配置: {:?}", custom_config);
}
// 构建器模式实现
struct UserBuilder {
email: Option<String>,
username: Option<String>,
active: Option<bool>,
sign_in_count: Option<u64>,
}
impl UserBuilder {
fn new() -> Self {
UserBuilder {
email: None,
username: None,
active: None,
sign_in_count: None,
}
}
fn email(mut self, email: &str) -> Self {
self.email = Some(email.to_string());
self
}
fn username(mut self, username: &str) -> Self {
self.username = Some(username.to_string());
self
}
fn active(mut self, active: bool) -> Self {
self.active = Some(active);
self
}
fn sign_in_count(mut self, count: u64) -> Self {
self.sign_in_count = Some(count);
self
}
fn build(self) -> User {
User {
email: self.email.unwrap_or_else(|| "default@example.com".to_string()),
username: self.username.unwrap_or_else(|| "defaultuser".to_string()),
active: self.active.unwrap_or(true),
sign_in_count: self.sign_in_count.unwrap_or(1),
}
}
}
fn advanced_struct_features() {
println!("\n=== 高级结构体特性 ===");
// 1. 结构体与所有权
ownership_in_structs();
// 2. 结构体内存布局
struct_memory_layout();
// 3. 结构体模式匹配
struct_pattern_matching();
}
fn ownership_in_structs() {
println!("\n=== 结构体与所有权 ===");
// 结构体可以包含拥有所有权的数据
#[derive(Debug)]
struct Article {
title: String, // 拥有所有权
content: String, // 拥有所有权
views: u32, // 拷贝语义
}
let article = Article {
title: String::from("Rust所有权详解"),
content: String::from("这是关于Rust所有权的详细内容..."),
views: 1000,
};
println!("文章: {:?}", article);
// 移动结构体实例
let moved_article = article;
// println!("{:?}", article); // 错误！article已被移动
// 结构体字段的所有权
let title = moved_article.title; // 移动title字段的所有权
// println!("{}", moved_article.title); // 错误！title已被移动
println!("标题: {}", title);
println!("内容: {}", moved_article.content); // 这个字段仍然可用
println!("浏览量: {}", moved_article.views); // 这个字段仍然可用
// 包含引用的结构体需要生命周期注解
struct ArticleView<'a> {
title: &'a str,
preview: &'a str,
}
let full_article = String::from("这是一篇完整的文章内容...");
let article_view = ArticleView {
title: "文章标题",
preview: &full_article[0..10],
};
println!("文章视图: {} - {}", article_view.title, article_view.preview);
}
fn struct_memory_layout() {
println!("\n=== 结构体内存布局 ===");
use std::mem;
// 1. 基本结构体大小
#[derive(Debug)]
struct SimpleStruct {
a: i32,
b: i32,
c: i32,
}
let simple = SimpleStruct { a: 1, b: 2, c: 3 };
println!("简单结构体大小: {} 字节", mem::size_of_val(&simple));
println!("字段a大小: {} 字节", mem::size_of_val(&simple.a));
println!("字段b大小: {} 字节", mem::size_of_val(&simple.b));
println!("字段c大小: {} 字节", mem::size_of_val(&simple.c));
// 2. 内存对齐
#[repr(C)]
struct AlignedStruct {
a: u8, // 1字节
b: u32, // 4字节
c: u16, // 2字节
}
let aligned = AlignedStruct { a: 1, b: 2, c: 3 };
println!("对齐结构体大小: {} 字节", mem::size_of_val(&aligned));
println!("u8对齐: {} 字节", mem::align_of::<u8>());
println!("u32对齐: {} 字节", mem::align_of::<u32>());
println!("u16对齐: {} 字节", mem::align_of::<u16>());
// 3. 打包结构体
#[repr(packed)]
struct PackedStruct {
a: u8,
b: u32,
c: u16,
}
let packed = PackedStruct { a: 1, b: 2, c: 3 };
println!("打包结构体大小: {} 字节", mem::size_of_val(&packed));
// 4. 零大小类型优化
struct ZeroSized;
#[derive(Debug)]
struct WithZST {
data: i32,
_marker: ZeroSized,
}
let with_zst = WithZST { data: 42, _marker: ZeroSized };
println!("包含ZST的结构体大小: {} 字节", mem::size_of_val(&with_zst));
}
fn struct_pattern_matching() {
println!("\n=== 结构体模式匹配 ===");
#[derive(Debug)]
struct Point {
x: i32,
y: i32,
}
#[derive(Debug)]
struct Rectangle {
top_left: Point,
bottom_right: Point,
}
let rect = Rectangle {
top_left: Point { x: 0, y: 10 },
bottom_right: Point { x: 20, y: 0 },
};
// 1. 基本结构体模式匹配
match rect.top_left {
Point { x: 0, y } => println!("点在Y轴上，y = {}", y),
Point { x, y: 0 } => println!("点在X轴上，x = {}", x),
Point { x, y } => println!("点在 ({}, {})", x, y),
}
// 2. 嵌套结构体模式匹配
match rect {
Rectangle {
top_left: Point { x: x1, y: y1 },
bottom_right: Point { x: x2, y: y2 }
} if x1 < x2 && y1 > y2 => {
println!("有效矩形: ({}, {}) 到 ({}, {})", x1, y1, x2, y2);
},
_ => println!("无效矩形"),
}
// 3. 使用 .. 忽略字段
match rect.top_left {
Point { x, .. } => println!("点的x坐标: {}", x),
}
// 4. 绑定变量
match rect {
Rectangle {
top_left: point @ Point { x: 0, .. },
..
} => {
println!("顶部在Y轴上的点: {:?}", point);
},
_ => println!("其他情况"),
}
// 5. if let 简洁语法
if let Rectangle {
top_left: Point { x: 0, y },
bottom_right: Point { x: bx, y: by }
} = rect {
println!("矩形从Y轴开始: y1={}, 右下角=({}, {})", y, bx, by);
}
}6.1.2 元组结构体
元组结构体结合了元组和结构体的特性，适用于需要命名整个元组但不需要命名字段的情况。
rust
fn tuple_structs() {
println!("=== 元组结构体 ===");
// 1. 基本元组结构体
struct Color(u8, u8, u8);
struct Point(i32, i32, i32);
let black = Color(0, 0, 0);
let white = Color(255, 255, 255);
let origin = Point(0, 0, 0);
println!("黑色: ({}, {}, {})", black.0, black.1, black.2);
println!("白色: ({}, {}, {})", white.0, white.1, white.2);
println!("原点: ({}, {}, {})", origin.0, origin.1, origin.2);
// 2. 元组结构体解构
let Color(r, g, b) = black;
println!("解构颜色: R={}, G={}, B={}", r, g, b);
// 3. 元组结构体模式匹配
match origin {
Point(0, 0, 0) => println!("这是原点"),
Point(x, 0, 0) => println!("在X轴上: {}", x),
Point(0, y, 0) => println!("在Y轴上: {}", y),
Point(0, 0, z) => println!("在Z轴上: {}", z),
Point(x, y, z) => println!("在空间点: ({}, {}, {})", x, y, z),
}
// 4. 新类型模式（Newtype Pattern）
newtype_pattern();
// 5. 单元结构体
unit_structs();
}
fn newtype_pattern() {
println!("\n=== 新类型模式 ===");
// 新类型模式：用元组结构体包装现有类型以提供类型安全和抽象
// 基础类型
type UserId = u32;
type ProductId = u32;
// 新类型包装
struct UserIdWrapper(UserId);
struct ProductIdWrapper(ProductId);
impl UserIdWrapper {
fn new(id: u32) -> Self {
UserIdWrapper(id)
}
fn value(&self) -> u32 {
self.0
}
}
impl ProductIdWrapper {
fn new(id: u32) -> Self {
ProductIdWrapper(id)
}
fn value(&self) -> u32 {
self.0
}
}
// 使用新类型提供类型安全
fn get_user_name(user_id: UserIdWrapper) -> String {
format!("用户{}", user_id.value())
}
fn get_product_name(product_id: ProductIdWrapper) -> String {
format!("产品{}", product_id.value())
}
let user_id = UserIdWrapper::new(123);
let product_id = ProductIdWrapper::new(456);
println!("用户名: {}", get_user_name(user_id));
println!("产品名: {}", get_product_name(product_id));
// 下面的代码会导致编译错误，提供了类型安全
// get_user_name(product_id); // 错误！期望UserIdWrapper，得到ProductIdWrapper
// 更复杂的新类型示例
struct Email(String);
impl Email {
fn new(email: &str) -> Result<Self, String> {
if email.contains('@') {
Ok(Email(email.to_string()))
} else {
Err("无效的电子邮件地址".to_string())
}
}
fn value(&self) -> &str {
&self.0
}
}
let email = Email::new("user@example.com").unwrap();
println!("电子邮件: {}", email.value());
}
fn unit_structs() {
println!("\n=== 单元结构体 ===");
// 单元结构体：没有任何字段的结构体
// 1. 基本单元结构体
struct Marker;
struct Nothing;
let marker = Marker;
let nothing = Nothing;
println!("单元结构体大小: {} 字节", std::mem::size_of_val(&marker));
// 2. 单元结构体实现 trait
impl Marker {
fn mark(&self) {
println!("标记位置");
}
}
marker.mark();
// 3. 单元结构体在泛型中的应用
struct Wrapper<T> {
value: T,
_marker: Marker,
}
let wrapped = Wrapper {
value: 42,
_marker: Marker,
};
println!("包装的值: {}", wrapped.value);
// 4. 单元结构体作为类型标记
struct Kilometers;
struct Miles;
struct Distance<T> {
value: f64,
_unit: std::marker::PhantomData<T>,
}
impl Distance<Kilometers> {
fn to_miles(&self) -> Distance<Miles> {
Distance {
value: self.value * 0.621371,
_unit: std::marker::PhantomData,
}
}
}
impl Distance<Miles> {
fn to_kilometers(&self) -> Distance<Kilometers> {
Distance {
value: self.value * 1.60934,
_unit: std::marker::PhantomData,
}
}
}
let distance_km = Distance::<Kilometers> {
value: 100.0,
_unit: std::marker::PhantomData,
};
let distance_miles = distance_km.to_miles();
println!("100公里 = {:.2} 英里", distance_miles.value);
let back_to_km = distance_miles.to_kilometers();
println("{:.2} 英里 = {:.2} 公里", distance_miles.value, back_to_km.value);
}6.1.3 结构体高级特性
探索结构体的一些高级特性和使用模式。
rust
fn advanced_struct_techniques() {
println!("=== 结构体高级特性 ===");
// 1. 泛型结构体
generic_structs();
// 2. 结构体与trait约束
structs_with_trait_bounds();
// 3. 结构体继承模拟
struct_inheritance_simulation();
// 4. 结构体与模式
structural_patterns();
}
fn generic_structs() {
println!("\n=== 泛型结构体 ===");
// 1. 基本泛型结构体
struct Pair<T> {
first: T,
second: T,
}
let int_pair = Pair { first: 1, second: 2 };
let string_pair = Pair { first: "hello", second: "world" };
println!("整数对: {}, {}", int_pair.first, int_pair.second);
println!("字符串对: {}, {}", string_pair.first, string_pair.second);
// 2. 多个类型参数的泛型结构体
struct Either<L, R> {
left: Option<L>,
right: Option<R>,
}
let left_value = Either::<i32, &str> {
left: Some(42),
right: None,
};
let right_value = Either::<i32, &str> {
left: None,
right: Some("hello"),
};
// 3. 泛型结构体方法实现
impl<T> Pair<T> {
fn new(first: T, second: T) -> Self {
Pair { first, second }
}
fn into_tuple(self) -> (T, T) {
(self.first, self.second)
}
}
let pair = Pair::new(10, 20);
let tuple = pair.into_tuple();
println!("转换为元组: {:?}", tuple);
// 4. 特定类型的实现
impl Pair<f64> {
fn distance_from_origin(&self) -> f64 {
(self.first.powi(2) + self.second.powi(2)).sqrt()
}
}
let float_pair = Pair::new(3.0, 4.0);
println!("到原点的距离: {}", float_pair.distance_from_origin());
// 5. 关联类型与泛型
trait Container {
type Item;
fn get_item(&self) -> &Self::Item;
}
struct BoxContainer<T> {
item: T,
}
impl<T> Container for BoxContainer<T> {
type Item = T;
fn get_item(&self) -> &Self::Item {
&self.item
}
}
let container = BoxContainer { item: 42 };
println!("容器中的项: {}", container.get_item());
}
fn structs_with_trait_bounds() {
println!("\n=== 带trait约束的结构体 ===");
use std::fmt::Display;
use std::cmp::PartialOrd;
// 1. 带trait约束的泛型结构体
struct DisplayablePair<T: Display> {
first: T,
second: T,
}
impl<T: Display> DisplayablePair<T> {
fn display(&self) {
println!("({}, {})", self.first, self.second);
}
}
let display_pair = DisplayablePair { first: 1, second: 2 };
display_pair.display();
// 2. 多个trait约束
struct ComparablePair<T: PartialOrd + Display> {
first: T,
second: T,
}
impl<T: PartialOrd + Display> ComparablePair<T> {
fn max(&self) -> &T {
if self.first > self.second {
&self.first
} else {
&self.second
}
}
fn min(&self) -> &T {
if self.first < self.second {
&self.first
} else {
&self.second
}
}
}
let comp_pair = ComparablePair { first: 10, second: 20 };
println!("最大值: {}, 最小值: {}", comp_pair.max(), comp_pair.min());
// 3. where子句简化复杂约束
struct ComplexPair<T, U>
where
T: Display + Clone,
U: Display + PartialEq,
{
left: T,
right: U,
}
impl<T, U> ComplexPair<T, U>
where
T: Display + Clone,
U: Display + PartialEq,
{
fn new(left: T, right: U) -> Self {
ComplexPair { left, right }
}
fn display_both(&self) {
println!("左: {}, 右: {}", self.left, self.right);
}
}
let complex = ComplexPair::new(42, "hello");
complex.display_both();
// 4. 默认泛型类型参数
struct AddablePair<T = i32> {
first: T,
second: T,
}
// 使用默认类型参数
let default_pair = AddablePair { first: 1, second: 2 };
// 指定类型参数
let float_pair = AddablePair::<f64> { first: 1.5, second: 2.5 };
}
fn struct_inheritance_simulation() {
println!("\n=== 结构体继承模拟 ===");
// Rust没有传统继承，但可以使用组合和trait模拟类似功能
// 1. 基础结构体
struct Animal {
name: String,
age: u32,
}
impl Animal {
fn new(name: &str, age: u32) -> Self {
Animal {
name: name.to_string(),
age,
}
}
fn speak(&self) {
println!("{} 发出声音", self.name);
}
fn info(&self) {
println!("名字: {}, 年龄: {}", self.name, self.age);
}
}
// 2. 使用组合模拟继承
struct Dog {
animal: Animal, // 组合而不是继承
breed: String,
}
impl Dog {
fn new(name: &str, age: u32, breed: &str) -> Self {
Dog {
animal: Animal::new(name, age),
breed: breed.to_string(),
}
}
// 委托方法
fn speak(&self) {
println!("{} 汪汪叫!", self.animal.name);
}
fn info(&self) {
self.animal.info();
println!("品种: {}", self.breed);
}
// 特有方法
fn fetch(&self) {
println!("{} 在接球!", self.animal.name);
}
}
// 3. 使用trait共享行为
trait Pet {
fn name(&self) -> &str;
fn age(&self) -> u32;
fn speak(&self);
// 默认实现
fn info(&self) {
println!("宠物: {}, 年龄: {}", self.name(), self.age());
}
}
impl Pet for Animal {
fn name(&self) -> &str {
&self.name
}
fn age(&self) -> u32 {
self.age
}
fn speak(&self) {
println!("{} 发出声音", self.name);
}
}
impl Pet for Dog {
fn name(&self) -> &str {
&self.animal.name
}
fn age(&self) -> u32 {
self.animal.age
}
fn speak(&self) {
println!("{} 汪汪叫!", self.animal.name);
}
fn info(&self) {
println!("狗狗: {}, 年龄: {}, 品种: {}",
self.name(), self.age(), self.breed);
}
}
let animal = Animal::new("动物", 3);
let dog = Dog::new("旺财", 2, "金毛");
// 使用trait对象实现多态
let pets: Vec<&dyn Pet> = vec![&animal, &dog];
for pet in pets {
pet.info();
pet.speak();
println!("---");
}
}
fn structural_patterns() {
println!("\n=== 结构体设计模式 ===");
// 1. 建造者模式
builder_pattern();
// 2. 类型状态模式
typestate_pattern();
// 3. 新类型模式进阶
advanced_newtype_pattern();
}
fn builder_pattern() {
println!("\n=== 建造者模式 ===");
#[derive(Debug)]
struct HttpRequest {
method: String,
url: String,
headers: Vec<(String, String)>,
body: Option<String>,
}
struct HttpRequestBuilder {
method: Option<String>,
url: Option<String>,
headers: Vec<(String, String)>,
body: Option<String>,
}
impl HttpRequestBuilder {
fn new() -> Self {
HttpRequestBuilder {
method: None,
url: None,
headers: Vec::new(),
body: None,
}
}
fn method(mut self, method: &str) -> Self {
self.method = Some(method.to_string());
self
}
fn url(mut self, url: &str) -> Self {
self.url = Some(url.to_string());
self
}
fn header(mut self, key: &str, value: &str) -> Self {
self.headers.push((key.to_string(), value.to_string()));
self
}
fn body(mut self, body: &str) -> Self {
self.body = Some(body.to_string());
self
}
fn build(self) -> Result<HttpRequest, String> {
let method = self.method.ok_or("方法必须设置")?;
let url = self.url.ok_or("URL必须设置")?;
Ok(HttpRequest {
method,
url,
headers: self.headers,
body: self.body,
})
}
}
let request = HttpRequestBuilder::new()
.method("GET")
.url("https://api.example.com/data")
.header("Content-Type", "application/json")
.header("Authorization", "Bearer token")
.build()
.unwrap();
println!("HTTP请求: {:?}", request);
}
fn typestate_pattern() {
println!("\n=== 类型状态模式 ===");
// 类型状态模式：使用类型系统在编译时强制执行状态转换规则
// 状态标记
struct Pending;
struct Processing;
struct Completed;
struct Failed;
// 泛型结构体，状态由类型参数表示
struct Request<State> {
id: u32,
data: String,
state: std::marker::PhantomData<State>,
}
impl Request<Pending> {
fn new(id: u32, data: &str) -> Self {
Request {
id,
data: data.to_string(),
state: std::marker::PhantomData,
}
}
fn start_processing(self) -> Request<Processing> {
println!("请求 {} 开始处理", self.id);
Request {
id: self.id,
data: self.data,
state: std::marker::PhantomData,
}
}
}
impl Request<Processing> {
fn complete(self) -> Request<Completed> {
println!("请求 {} 处理完成", self.id);
Request {
id: self.id,
data: self.data,
state: std::marker::PhantomData,
}
}
fn fail(self) -> Request<Failed> {
println!("请求 {} 处理失败", self.id);
Request {
id: self.id,
data: self.data,
state: std::marker::PhantomData,
}
}
}
impl Request<Completed> {
fn get_result(&self) -> &str {
&self.data
}
}
impl Request<Failed> {
fn get_error(&self) -> &str {
&self.data
}
}
// 使用类型状态模式
let request = Request::<Pending>::new(1, "请求数据");
let processing = request.start_processing();
let completed = processing.complete();
println!("完成的结果: {}", completed.get_result());
// 编译时防止非法状态转换
// let pending = Request::<Pending>::new(2, "另一个请求");
// pending.complete(); // 错误！Pending状态不能直接完成
}
fn advanced_newtype_pattern() {
println!("\n=== 进阶新类型模式 ===");
use std::ops::{Add, Deref};
// 1. 新类型包装数值类型
#[derive(Debug, Clone, Copy)]
struct Meters(f64);
impl Meters {
fn new(value: f64) -> Self {
Meters(value)
}
}
// 实现Deref以便自动解引用
impl Deref for Meters {
type Target = f64;
fn deref(&self) -> &Self::Target {
&self.0
}
}
// 实现Add trait支持加法
impl Add for Meters {
type Output = Meters;
fn add(self, other: Meters) -> Meters {
Meters(self.0 + other.0)
}
}
let distance1 = Meters::new(5.5);
let distance2 = Meters::new(3.2);
let total = distance1 + distance2;
println!("距离1: {}米", *distance1);
println!("距离2: {}米", *distance2);
println!("总距离: {}米", *total);
// 2. 新类型包装字符串
struct Username(String);
impl Username {
fn new(username: &str) -> Result<Self, String> {
if username.len() < 3 {
Err("用户名太短".to_string())
} else if username.len() > 20 {
Err("用户名太长".to_string())
} else if !username.chars().all(|c| c.is_alphanumeric()) {
Err("用户名只能包含字母和数字".to_string())
} else {
Ok(Username(username.to_string()))
}
}
}
impl Deref for Username {
type Target = str;
fn deref(&self) -> &Self::Target {
&self.0
}
}
match Username::new("user123") {
Ok(username) => println!("有效用户名: {}", &*username),
Err(e) => println!("无效用户名: {}", e),
}
match Username::new("ab") {
Ok(username) => println!("有效用户名: {}", &*username),
Err(e) => println!("无效用户名: {}", e),
}
// 3. 新类型实现自定义trait
trait Validatable {
fn is_valid(&self) -> bool;
}
impl Validatable for Username {
fn is_valid(&self) -> bool {
self.len() >= 3 && self.len() <= 20 &&
self.chars().all(|c| c.is_alphanumeric())
}
}
let username = Username::new("validuser").unwrap();
println!("用户名有效: {}", username.is_valid());
}6.2 方法语法
6.2.1 基本方法定义
方法是与结构体实例关联的函数，让我们深入理解方法的定义和使用。
rust
fn basic_method_syntax() {
println!("=== 基本方法语法 ===");
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
// 为Rectangle实现方法
impl Rectangle {
// 关联函数（静态方法）
fn new(width: u32, height: u32) -> Self {
Rectangle { width, height }
}
// 实例方法 - 不可变借用self
fn area(&self) -> u32 {
self.width * self.height
}
// 实例方法 - 可变借用self
fn resize(&mut self, width: u32, height: u32) {
self.width = width;
self.height = height;
}
// 实例方法 - 获取所有权self
fn into_tuple(self) -> (u32, u32) {
(self.width, self.height)
}
// 方法可以接受额外参数
fn can_hold(&self, other: &Rectangle) -> bool {
self.width > other.width && self.height > other.height
}
}
// 使用关联函数创建实例
let mut rect = Rectangle::new(30, 50);
println!("矩形: {:?}", rect);
// 调用实例方法
println!("面积: {}", rect.area());
// 调用可变方法
rect.resize(40, 60);
println!("调整后: {:?}", rect);
println!("新面积: {}", rect.area());
// 测试can_hold方法
let small = Rectangle::new(10, 20);
let large = Rectangle::new(50, 50);
println!("大矩形能容纳小矩形: {}", large.can_hold(&small));
println!("小矩形能容纳大矩形: {}", small.can_hold(&large));
// 调用消耗self的方法
let tuple = rect.into_tuple();
println!("转换为元组: {:?}", tuple);
// println!("{:?}", rect); // 错误！rect已被消耗
}
fn method_receiver_types() {
println!("\n=== 方法接收器类型 ===");
#[derive(Debug)]
struct Counter {
value: i32,
}
impl Counter {
// 1. &self - 不可变借用
fn get_value(&self) -> i32 {
self.value
}
// 2. &mut self - 可变借用
fn increment(&mut self) {
self.value += 1;
}
fn decrement(&mut self) {
self.value -= 1;
}
// 3. self - 获取所有权
fn consume(self) -> i32 {
self.value
}
// 4. 没有self - 关联函数
fn default() -> Self {
Counter { value: 0 }
}
// 5. 返回Self的关联函数
fn with_value(value: i32) -> Self {
Counter { value }
}
}
let mut counter = Counter::default();
println!("初始值: {}", counter.get_value());
counter.increment();
counter.increment();
println!("增加两次后: {}", counter.get_value());
counter.decrement();
println!("减少一次后: {}", counter.get_value());
let value = counter.consume();
println!("消耗后获取的值: {}", value);
// println!("{:?}", counter); // 错误！counter已被消耗
// 使用关联函数创建新实例
let new_counter = Counter::with_value(100);
println!("新计数器值: {}", new_counter.get_value());
// 方法链调用
let result = Counter::with_value(10)
.increment() // 返回&mut Self以便链式调用
.get_value();
println!("链式调用结果: {}", result);
}
// 为Counter实现链式调用的方法
impl Counter {
fn increment_chain(&mut self) -> &mut Self {
self.value += 1;
self
}
fn decrement_chain(&mut self) -> &mut Self {
self.value -= 1;
self
}
fn set_value(&mut self, value: i32) -> &mut Self {
self.value = value;
self
}
}
fn method_visibility() {
println!("\n=== 方法可见性 ===");
// Rust使用pub关键字控制可见性
pub struct BankAccount {
balance: i32, // 私有字段
account_number: String, // 私有字段
}
impl BankAccount {
// 公开的关联函数
pub fn new(account_number: &str, initial_balance: i32) -> Self {
BankAccount {
balance: initial_balance,
account_number: account_number.to_string(),
}
}
// 公开的方法
pub fn get_balance(&self) -> i32 {
self.balance
}
pub fn deposit(&mut self, amount: i32) -> Result<(), String> {
if amount <= 0 {
return Err("存款金额必须为正数".to_string());
}
self.balance += amount;
Ok(())
}
pub fn withdraw(&mut self, amount: i32) -> Result<(), String> {
if amount <= 0 {
return Err("取款金额必须为正数".to_string());
}
if amount > self.balance {
return Err("余额不足".to_string());
}
self.balance -= amount;
Ok(())
}
// 私有方法 - 只能在模块内部调用
fn validate_account(&self) -> bool {
!self.account_number.is_empty() && self.balance >= 0
}
// 公开方法可以调用私有方法
pub fn is_valid(&self) -> bool {
self.validate_account()
}
}
let mut account = BankAccount::new("123456", 1000);
println!("初始余额: {}", account.get_balance());
match account.deposit(500) {
Ok(()) => println!("存款成功"),
Err(e) => println!("存款失败: {}", e),
}
match account.withdraw(2000) {
Ok(()) => println!("取款成功"),
Err(e) => println!("取款失败: {}", e),
}
println!("最终余额: {}", account.get_balance());
println!("账户有效: {}", account.is_valid());
// 无法直接访问私有字段
// println!("{}", account.balance); // 错误！
// account.validate_account(); // 错误！
}6.2.2 高级方法特性
探索方法的一些高级特性和使用模式。
rust
fn advanced_method_features() {
println!("=== 高级方法特性 ===");
// 1. 泛型方法
generic_methods();
// 2. 方法重载模拟
method_overloading_simulation();
// 3. 方法中的模式匹配
pattern_matching_in_methods();
// 4. 方法与生命周期
methods_and_lifetimes();
}
fn generic_methods() {
println!("\n=== 泛型方法 ===");
struct Container<T> {
value: T,
}
impl<T> Container<T> {
// 泛型方法 - 使用结构体的泛型参数
fn get_value(&self) -> &T {
&self.value
}
// 泛型方法 - 有自己的泛型参数
fn map<U, F>(self, f: F) -> Container<U>
where
F: FnOnce(T) -> U,
{
Container { value: f(self.value) }
}
// 泛型方法 - 多个泛型参数
fn combine<U, V, F>(self, other: Container<U>, f: F) -> Container<V>
where
F: FnOnce(T, U) -> V,
{
Container { value: f(self.value, other.value) }
}
}
// 为特定类型实现方法
impl Container<i32> {
fn square(&self) -> i32 {
self.value * self.value
}
}
// 使用泛型方法
let container = Container { value: 42 };
println!("值: {}", container.get_value());
let squared = Container { value: 5 }.square();
println!("平方: {}", squared);
// 使用map方法
let string_container = Container { value: 42 }.map(|x| x.to_string());
println!("映射后: {}", string_container.get_value());
// 使用combine方法
let container1 = Container { value: 10 };
let container2 = Container { value: 20 };
let combined = container1.combine(container2, |a, b| a + b);
println!("合并后: {}", combined.get_value());
// 更复杂的泛型方法示例
advanced_generic_methods();
}
fn advanced_generic_methods() {
println!("\n=== 进阶泛型方法 ===");
use std::ops::Add;
use std::fmt::Display;
struct Calculator;
impl Calculator {
// 泛型方法 with trait bounds
fn add<T: Add<Output = T> + Copy>(&self, a: T, b: T) -> T {
a + b
}
// 使用where子句
fn multiply<T>(&self, a: T, b: T) -> T
where
T: std::ops::Mul<Output = T> + Copy,
{
a * b
}
// 返回impl Trait
fn process<T>(&self, value: T) -> impl Display
where
T: Display + Clone,
{
format!("处理后的: {}", value)
}
}
let calc = Calculator;
let sum = calc.add(5, 3);
println!("5 + 3 = {}", sum);
let product = calc.multiply(4.5, 2.0);
println!("4.5 * 2.0 = {}", product);
let processed = calc.process("hello");
println!("{}", processed);
}
fn method_overloading_simulation() {
println!("\n=== 方法重载模拟 ===");
// Rust不支持传统的方法重载，但可以使用泛型或不同的方法名模拟
struct MathUtils;
impl MathUtils {
// 方法1: 使用不同的方法名
fn add_i32(&self, a: i32, b: i32) -> i32 {
a + b
}
fn add_f64(&self, a: f64, b: f64) -> f64 {
a + b
}
// 方法2: 使用泛型
fn add<T>(&self, a: T, b: T) -> T
where
T: std::ops::Add<Output = T>,
{
a + b
}
// 方法3: 使用trait对象
fn display_value(&self, value: &dyn std::fmt::Display) -> String {
format!("值: {}", value)
}
}
let math = MathUtils;
// 使用不同方法名
println!("i32加法: {}", math.add_i32(5, 3));
println!("f64加法: {}", math.add_f64(5.5, 3.2));
// 使用泛型方法
println!("泛型i32加法: {}", math.add(10, 20));
println!("泛型f64加法: {}", math.add(10.5, 20.3));
// 使用trait对象
println!("{}", math.display_value(&42));
println!("{}", math.display_value(&"hello"));
// 更复杂的重载模拟
advanced_overloading_simulation();
}
fn advanced_overloading_simulation() {
println!("\n=== 进阶重载模拟 ===");
use std::fmt::Display;
struct Printer;
impl Printer {
// 模拟可变参数 - 使用切片
fn print_values<T: Display>(&self, values: &[T]) {
for (i, value) in values.iter().enumerate() {
println!("参数{}: {}", i + 1, value);
}
}
// 模拟可选参数 - 使用Option
fn print_with_prefix<T: Display>(&self, value: T, prefix: Option<&str>) {
match prefix {
Some(p) => println!("{}: {}", p, value),
None => println!("{}", value),
}
}
// 模拟默认参数 - 使用默认值
fn print_with_default<T: Display>(&self, value: T, separator: &str) {
println!("{}{}", value, separator);
}
}
let printer = Printer;
// 可变参数模拟
printer.print_values(&[1, 2, 3, 4, 5]);
printer.print_values(&["a", "b", "c"]);
// 可选参数模拟
printer.print_with_prefix("hello", Some("消息"));
printer.print_with_prefix("world", None);
// 默认参数模拟
printer.print_with_default("hello", "!");
printer.print_with_default("world", ".");
}
fn pattern_matching_in_methods() {
println!("\n=== 方法中的模式匹配 ===");
#[derive(Debug)]
enum Status {
Success(String),
Error(String),
Loading(f32),
}
struct ResponseHandler;
impl ResponseHandler {
// 在方法中使用match
fn handle_status(&self, status: Status) {
match status {
Status::Success(message) => {
println!("成功: {}", message);
},
Status::Error(error) => {
println!("错误: {}", error);
},
Status::Loading(progress) => {
println!("加载中: {:.1}%", progress * 100.0);
},
}
}
// 使用if let简化匹配
fn check_success(&self, status: &Status) -> bool {
if let Status::Success(_) = status {
true
} else {
false
}
}
// 在方法参数中使用模式
fn process_result(&self, (code, message): (u32, &str)) {
println!("代码: {}, 消息: {}", code, message);
}
// 复杂的模式匹配
fn analyze_data(&self, data: &[Option<i32>]) {
for (i, item) in data.iter().enumerate() {
match item {
Some(value @ 1..=100) => {
println!("位置{}: 有效值 {}", i, value);
},
Some(value) if *value < 0 => {
println!("位置{}: 负值 {}", i, value);
},
Some(value) => {
println!("位置{}: 大值 {}", i, value);
},
None => {
println!("位置{}: 无数据", i);
},
}
}
}
}
let handler = ResponseHandler;
// 测试状态处理
handler.handle_status(Status::Success("操作完成".to_string()));
handler.handle_status(Status::Error("网络错误".to_string()));
handler.handle_status(Status::Loading(0.75));
// 测试成功检查
let success_status = Status::Success("测试".to_string());
println!("是否是成功状态: {}", handler.check_success(&success_status));
// 测试元组处理
handler.process_result((200, "OK"));
// 测试数据分析
let data = vec![Some(50), None, Some(-5), Some(200)];
handler.analyze_data(&data);
}
fn methods_and_lifetimes() {
println!("\n=== 方法与生命周期 ===");
// 1. 结构体包含引用需要生命周期注解
struct TextProcessor<'a> {
text: &'a str,
processed: bool,
}
impl<'a> TextProcessor<'a> {
// 方法通常不需要显式生命周期注解，编译器可以推断
fn new(text: &'a str) -> Self {
TextProcessor {
text,
processed: false,
}
}
fn get_text(&self) -> &'a str {
self.text
}
// 返回的引用生命周期与self相同
fn get_first_word(&self) -> &'a str {
self.text.split_whitespace().next().unwrap_or("")
}
// 多个生命周期参数
fn combine_texts<'b>(&self, other: &'b str) -> String
where
'a: 'b, // 生命周期约束：'a 至少和 'b 一样长
{
format!("{} {}", self.text, other)
}
}
let text = "Hello World";
let processor = TextProcessor::new(text);
println!("文本: {}", processor.get_text());
println!("第一个单词: {}", processor.get_first_word());
let other_text = "Rust Programming";
let combined = processor.combine_texts(other_text);
println!("合并文本: {}", combined);
// 2. 复杂的生命周期场景
complex_lifetime_scenarios();
}
fn complex_lifetime_scenarios() {
println!("\n=== 复杂生命周期场景 ===");
struct StringSplitter<'a, 'b> {
text: &'a str,
delimiter: &'b str,
}
impl<'a, 'b> StringSplitter<'a, 'b> {
fn new(text: &'a str, delimiter: &'b str) -> Self {
StringSplitter { text, delimiter }
}
// 返回的迭代器需要生命周期注解
fn split(&self) -> impl Iterator<Item = &'a str> {
self.text.split(self.delimiter)
}
// 高级生命周期模式
fn find_longest<'c>(&self, other: &'c str) -> &'c str
where
'a: 'c,
{
if self.text.len() > other.len() {
self.text
} else {
other
}
}
}
let text = "apple,banana,cherry";
let splitter = StringSplitter::new(text, ",");
println!("分割结果:");
for part in splitter.split() {
println!(" {}", part);
}
let other_text = "date";
let longest = splitter.find_longest(other_text);
println!("较长的文本: {}", longest);
// 3. 生命周期省略规则在方法中的应用
lifetime_elision_in_methods();
}
fn lifetime_elision_in_methods() {
println!("\n=== 方法中的生命周期省略 ===");
// Rust有三条生命周期省略规则，在方法中经常应用
struct StringWrapper<'a> {
data: &'a str,
}
impl<'a> StringWrapper<'a> {
// 规则1: 每个引用参数都有自己的生命周期
// 规则2: 如果只有一个输入生命周期参数，它被赋予所有输出生命周期参数
fn get_data(&self) -> &str { // 等价于 &'a str
self.data
}
// 规则3: 如果有多个输入生命周期参数，但其中一个是&self或&mut self，
// 那么self的生命周期被赋予所有输出生命周期参数
fn combine(&self, other: &str) -> &str { // 等价于 &'a str
if self.data.len() > other.len() {
self.data
} else {
other
}
}
}
let wrapper = StringWrapper { data: "hello" };
println!("数据: {}", wrapper.get_data());
let other = "world";
println!("组合结果: {}", wrapper.combine(other));
// 无法应用省略规则的情况
struct DualWrapper<'a, 'b> {
first: &'a str,
second: &'b str,
}
impl<'a, 'b> DualWrapper<'a, 'b> {
// 需要显式生命周期注解
fn get_longest(&self) -> &str
where
'a: 'b,
{
if self.first.len() > self.second.len() {
self.first
} else {
self.second
}
}
}
let dual = DualWrapper {
first: "long string",
second: "short",
};
println!("较长的字符串: {}", dual.get_longest());
}6.3 关联函数
6.3.1 关联函数基础
关联函数是不以self作为参数的函数，通常用于构造器或其他与类型相关的功能。
rust
fn associated_functions_basics() {
println!("=== 关联函数基础 ===");
#[derive(Debug)]
struct Circle {
radius: f64,
}
impl Circle {
// 关联函数 - 没有self参数
fn new(radius: f64) -> Self {
Circle { radius }
}
// 另一个关联函数
fn unit() -> Self {
Circle { radius: 1.0 }
}
// 带验证的关联函数
fn try_new(radius: f64) -> Result<Self, String> {
if radius >= 0.0 {
Ok(Circle { radius })
} else {
Err("半径不能为负".to_string())
}
}
// 实例方法 - 有self参数
fn area(&self) -> f64 {
std::f64::consts::PI * self.radius * self.radius
}
}
// 使用关联函数创建实例
let circle1 = Circle::new(5.0);
let circle2 = Circle::unit();
println!("圆1: {:?}, 面积: {:.2}", circle1, circle1.area());
println!("单位圆: {:?}, 面积: {:.2}", circle2, circle2.area());
// 使用带验证的关联函数
match Circle::try_new(3.0) {
Ok(circle) => println!("创建成功: {:?}", circle),
Err(e) => println!("创建失败: {}", e),
}
match Circle::try_new(-1.0) {
Ok(circle) => println!("创建成功: {:?}", circle),
Err(e) => println!("创建失败: {}", e),
}
// 关联函数的其他用途
other_uses_of_associated_functions();
}
fn other_uses_of_associated_functions() {
println!("\n=== 关联函数的其他用途 ===");
// 1. 工厂方法模式
factory_method_pattern();
// 2. 工具函数
utility_functions();
// 3. 常量关联函数
constant_associated_functions();
}
fn factory_method_pattern() {
println!("\n=== 工厂方法模式 ===");
#[derive(Debug)]
enum ShapeType {
Circle,
Rectangle,
Triangle,
}
#[derive(Debug)]
struct Shape {
shape_type: ShapeType,
area: f64,
}
impl Shape {
// 工厂方法 - 根据类型创建不同的形状
fn create_circle(radius: f64) -> Self {
Shape {
shape_type: ShapeType::Circle,
area: std::f64::consts::PI * radius * radius,
}
}
fn create_rectangle(width: f64, height: f64) -> Self {
Shape {
shape_type: ShapeType::Rectangle,
area: width * height,
}
}
fn create_triangle(base: f64, height: f64) -> Self {
Shape {
shape_type: ShapeType::Triangle,
area: 0.5 * base * height,
}
}
// 通用工厂方法
fn create(shape_type: ShapeType, dimensions: &[f64]) -> Result<Self, String> {
match shape_type {
ShapeType::Circle => {
if dimensions.len() != 1 {
return Err("圆形需要1个参数(半径)".to_string());
}
Ok(Self::create_circle(dimensions[0]))
},
ShapeType::Rectangle => {
if dimensions.len() != 2 {
return Err("矩形需要2个参数(宽,高)".to_string());
}
Ok(Self::create_rectangle(dimensions[0], dimensions[1]))
},
ShapeType::Triangle => {
if dimensions.len() != 2 {
return Err("三角形需要2个参数(底,高)".to_string());
}
Ok(Self::create_triangle(dimensions[0], dimensions[1]))
},
}
}
}
// 使用工厂方法
let circle = Shape::create_circle(5.0);
let rectangle = Shape::create_rectangle(4.0, 6.0);
let triangle = Shape::create_triangle(3.0, 4.0);
println!("圆形: {:?}", circle);
println!("矩形: {:?}", rectangle);
println!("三角形: {:?}", triangle);
// 使用通用工厂方法
match Shape::create(ShapeType::Circle, &[5.0]) {
Ok(shape) => println!("创建的圆形: {:?}", shape),
Err(e) => println!("创建失败: {}", e),
}
}
fn utility_functions() {
println!("\n=== 工具函数 ===");
struct MathUtils;
impl MathUtils {
// 数学工具函数
fn factorial(n: u64) -> u64 {
if n <= 1 { 1 } else { n * Self::factorial(n - 1) }
}
fn gcd(mut a: u64, mut b: u64) -> u64 {
while b != 0 {
let temp = b;
b = a % b;
a = temp;
}
a
}
fn lcm(a: u64, b: u64) -> u64 {
if a == 0 || b == 0 {
0
} else {
(a * b) / Self::gcd(a, b)
}
}
// 配置相关的工具函数
fn default_config() -> Config {
Config {
timeout: 30,
retries: 3,
debug: false,
}
}
fn production_config() -> Config {
Config {
timeout: 60,
retries: 5,
debug: false,
}
}
}
#[derive(Debug)]
struct Config {
timeout: u32,
retries: u32,
debug: bool,
}
// 使用工具函数
println!("5的阶乘: {}", MathUtils::factorial(5));
println!("GCD(54, 24): {}", MathUtils::gcd(54, 24));
println!("LCM(12, 18): {}", MathUtils::lcm(12, 18));
println!("默认配置: {:?}", MathUtils::default_config());
println!("生产配置: {:?}", MathUtils::production_config());
}
fn constant_associated_functions() {
println!("\n=== 常量关联函数 ===");
// 关联函数可以在编译时求值
struct Constants;
impl Constants {
// 常量函数 - 在编译时求值
const fn pi() -> f64 {
3.141592653589793
}
const fn e() -> f64 {
2.718281828459045
}
const fn golden_ratio() -> f64 {
1.618033988749895
}
// 计算常量表达式
const fn circle_area(radius: f64) -> f64 {
Self::pi() * radius * radius
}
}
// 在常量上下文中使用
const PI: f64 = Constants::pi();
const E: f64 = Constants::e();
const UNIT_CIRCLE_AREA: f64 = Constants::circle_area(1.0);
println!("π = {:.6}", PI);
println!("e = {:.6}", E);
println!("黄金比例 = {:.6}", Constants::golden_ratio());
println!("单位圆面积 = {:.6}", UNIT_CIRCLE_AREA);
// 在运行时使用
let radius = 5.0;
let area = Constants::circle_area(radius);
println!("半径为{}的圆面积 = {:.2}", radius, area);
}6.3.2 高级关联函数模式
探索关联函数的一些高级使用模式和技巧。
rust
fn advanced_associated_function_patterns() {
println!("=== 高级关联函数模式 ===");
// 1. 单例模式
singleton_pattern();
// 2. 注册表模式
registry_pattern();
// 3. 类型转换模式
conversion_patterns();
// 4. 构造器模式进阶
advanced_builder_pattern();
}
fn singleton_pattern() {
println!("\n=== 单例模式 ===");
use std::sync::Mutex;
use std::sync::Once;
struct AppConfig {
database_url: String,
cache_size: usize,
debug_mode: bool,
}
impl AppConfig {
// 单例实例
fn global() -> &'static Mutex<AppConfig> {
static mut CONFIG: Option<Mutex<AppConfig>> = None;
static ONCE: Once = Once::new();
unsafe {
ONCE.call_once(|| {
CONFIG = Some(Mutex::new(AppConfig {
database_url: "postgres://localhost:5432/mydb".to_string(),
cache_size: 1000,
debug_mode: cfg!(debug_assertions),
}));
});
CONFIG.as_ref().unwrap()
}
}
// 获取配置值的方法
fn get_database_url(&self) -> &str {
&self.database_url
}
fn get_cache_size(&self) -> usize {
self.cache_size
}
fn is_debug_mode(&self) -> bool {
self.debug_mode
}
}
// 使用单例
let config = AppConfig::global().lock().unwrap();
println!("数据库URL: {}", config.get_database_url());
println!("缓存大小: {}", config.get_cache_size());
println!("调试模式: {}", config.is_debug_mode());
// 更安全的单例实现
thread_safe_singleton();
}
fn thread_safe_singleton() {
println!("\n=== 线程安全单例 ===");
use std::sync::{Arc, RwLock};
use std::sync::Once;
#[derive(Debug)]
struct Logger {
log_level: String,
}
impl Logger {
fn new(level: &str) -> Self {
Logger {
log_level: level.to_string(),
}
}
fn log(&self, message: &str) {
println!("[{}] {}", self.log_level, message);
}
}
// 线程安全的单例
struct LoggerSingleton;
impl LoggerSingleton {
fn instance() -> Arc<RwLock<Logger>> {
static mut INSTANCE: Option<Arc<RwLock<Logger>>> = None;
static ONCE: Once = Once::new();
unsafe {
ONCE.call_once(|| {
let logger = Logger::new("INFO");
INSTANCE = Some(Arc::new(RwLock::new(logger)));
});
INSTANCE.as_ref().unwrap().clone()
}
}
}
// 在多线程环境中安全使用
let logger = LoggerSingleton::instance();
{
let log = logger.read().unwrap();
log.log("应用程序启动");
}
{
let mut log = logger.write().unwrap();
log.log_level = "DEBUG".to_string();
}
{
let log = logger.read().unwrap();
log.log("调试信息");
}
}
fn registry_pattern() {
println!("\n=== 注册表模式 ===");
use std::collections::HashMap;
// 插件系统示例
trait Plugin {
fn execute(&self);
fn name(&self) -> &str;
}
struct PluginRegistry {
plugins: HashMap<String, Box<dyn Plugin>>,
}
impl PluginRegistry {
// 全局注册表实例
fn global() -> &'static Mutex<PluginRegistry> {
static mut REGISTRY: Option<Mutex<PluginRegistry>> = None;
static ONCE: Once = Once::new();
unsafe {
ONCE.call_once(|| {
REGISTRY = Some(Mutex::new(PluginRegistry {
plugins: HashMap::new(),
}));
});
REGISTRY.as_ref().unwrap()
}
}
// 注册插件
fn register_plugin(&mut self, name: String, plugin: Box<dyn Plugin>) {
self.plugins.insert(name, plugin);
}
// 执行插件
fn execute_plugin(&self, name: &str) -> Result<(), String> {
if let Some(plugin) = self.plugins.get(name) {
plugin.execute();
Ok(())
} else {
Err(format!("插件 '{}' 未找到", name))
}
}
// 列出所有插件
fn list_plugins(&self) -> Vec<&str> {
self.plugins.keys().map(|s| s.as_str()).collect()
}
}
// 示例插件
struct HelloPlugin;
impl Plugin for HelloPlugin {
fn execute(&self) {
println!("Hello from HelloPlugin!");
}
fn name(&self) -> &str {
"hello"
}
}
struct GoodbyePlugin;
impl Plugin for GoodbyePlugin {
fn execute(&self) {
println!("Goodbye from GoodbyePlugin!");
}
fn name(&self) -> &str {
"goodbye"
}
}
// 注册和使用插件
{
let mut registry = PluginRegistry::global().lock().unwrap();
registry.register_plugin("hello".to_string(), Box::new(HelloPlugin));
registry.register_plugin("goodbye".to_string(), Box::new(GoodbyePlugin));
}
// 执行插件
let registry = PluginRegistry::global().lock().unwrap();
println!("可用插件: {:?}", registry.list_plugins());
registry.execute_plugin("hello").unwrap();
registry.execute_plugin("goodbye").unwrap();
match registry.execute_plugin("unknown") {
Ok(()) => println!("执行成功"),
Err(e) => println!("执行失败: {}", e),
}
}
fn conversion_patterns() {
println!("\n=== 类型转换模式 ===");
// 1. From 和 Into trait 实现
from_and_into_implementations();
// 2. 自定义转换方法
custom_conversion_methods();
// 3. 解析方法
parsing_methods();
}
fn from_and_into_implementations() {
println!("\n=== From 和 Into 实现 ===");
#[derive(Debug)]
struct Point2D {
x: i32,
y: i32,
}
#[derive(Debug)]
struct Point3D {
x: i32,
y: i32,
z: i32,
}
// 实现 From trait
impl From<(i32, i32)> for Point2D {
fn from(tuple: (i32, i32)) -> Self {
Point2D {
x: tuple.0,
y: tuple.1,
}
}
}
impl From<Point2D> for Point3D {
fn from(point: Point2D) -> Self {
Point3D {
x: point.x,
y: point.y,
z: 0,
}
}
}
// 使用 From trait
let point2d = Point2D::from((10, 20));
let point3d = Point3D::from(point2d);
println!("2D点: {:?}", point2d);
println!("3D点: {:?}", point3d);
// 使用 Into trait (自动实现)
let tuple = (30, 40);
let point2d: Point2D = tuple.into();
let point3d: Point3D = point2d.into();
println!("从元组转换的2D点: {:?}", point2d);
println!("从2D点转换的3D点: {:?}", point3d);
// 实现 TryFrom for fallible conversions
use std::convert::TryFrom;
impl TryFrom<Point3D> for Point2D {
type Error = String;
fn try_from(point: Point3D) -> Result<Self, Self::Error> {
if point.z == 0 {
Ok(Point2D {
x: point.x,
y: point.y,
})
} else {
Err("无法转换：Z坐标不为零".to_string())
}
}
}
let point3d_zero = Point3D { x: 1, y: 2, z: 0 };
let point3d_nonzero = Point3D { x: 1, y: 2, z: 3 };
match Point2D::try_from(point3d_zero) {
Ok(point) => println!("成功转换: {:?}", point),
Err(e) => println!("转换失败: {}", e),
}
match Point2D::try_from(point3d_nonzero) {
Ok(point) => println!("成功转换: {:?}", point),
Err(e) => println!("转换失败: {}", e),
}
}
fn custom_conversion_methods() {
println!("\n=== 自定义转换方法 ===");
#[derive(Debug)]
struct Celsius(f64);
#[derive(Debug)]
struct Fahrenheit(f64);
impl Celsius {
// 转换为华氏温度
fn to_fahrenheit(&self) -> Fahrenheit {
Fahrenheit(self.0 * 9.0 / 5.0 + 32.0)
}
// 从华氏温度创建
fn from_fahrenheit(f: Fahrenheit) -> Self {
Celsius((f.0 - 32.0) * 5.0 / 9.0)
}
}
impl Fahrenheit {
// 转换为摄氏温度
fn to_celsius(&self) -> Celsius {
Celsius::from_fahrenheit(*self)
}
// 从摄氏温度创建
fn from_celsius(c: Celsius) -> Self {
c.to_fahrenheit()
}
}
let celsius = Celsius(25.0);
let fahrenheit = celsius.to_fahrenheit();
println!("{}°C = {}°F", celsius.0, fahrenheit.0);
let back_to_celsius = fahrenheit.to_celsius();
println!("{}°F = {}°C", fahrenheit.0, back_to_celsius.0);
// 验证转换的正确性
let boiling_c = Celsius(100.0);
let boiling_f = boiling_c.to_fahrenheit();
println!("水的沸点: {}°C = {}°F", boiling_c.0, boiling_f.0);
let freezing_f = Fahrenheit(32.0);
let freezing_c = freezing_f.to_celsius();
println!("水的冰点: {}°F = {}°C", freezing_f.0, freezing_c.0);
}
fn parsing_methods() {
println!("\n=== 解析方法 ===");
#[derive(Debug, PartialEq)]
struct RGB {
red: u8,
green: u8,
blue: u8,
}
impl RGB {
// 从十六进制字符串解析
fn from_hex(hex: &str) -> Result<Self, String> {
if !hex.starts_with('#') || hex.len() != 7 {
return Err("格式错误：必须是#RRGGBB格式".to_string());
}
let r = u8::from_str_radix(&hex[1..3], 16)
.map_err(|e| format!("红色分量解析错误: {}", e))?;
let g = u8::from_str_radix(&hex[3..5], 16)
.map_err(|e| format!("绿色分量解析错误: {}", e))?;
let b = u8::from_str_radix(&hex[5..7], 16)
.map_err(|e| format!("蓝色分量解析错误: {}", e))?;
Ok(RGB { red: r, green: g, blue: b })
}
// 从CSS颜色名称解析
fn from_name(name: &str) -> Option<Self> {
match name.to_lowercase().as_str() {
"red" => Some(RGB { red: 255, green: 0, blue: 0 }),
"green" => Some(RGB { red: 0, green: 255, blue: 0 }),
"blue" => Some(RGB { red: 0, green: 0, blue: 255 }),
"white" => Some(RGB { red: 255, green: 255, blue: 255 }),
"black" => Some(RGB { red: 0, green: 0, blue: 0 }),
_ => None,
}
}
// 转换为十六进制字符串
fn to_hex(&self) -> String {
format!("#{:02X}{:02X}{:02X}", self.red, self.green, self.blue)
}
// 转换为CSS rgb() 格式
fn to_css_rgb(&self) -> String {
format!("rgb({}, {}, {})", self.red, self.green, self.blue)
}
}
// 测试解析方法
match RGB::from_hex("#FF5733") {
Ok(color) => {
println!("解析的颜色: {:?}", color);
println!("十六进制: {}", color.to_hex());
println!("CSS格式: {}", color.to_css_rgb());
},
Err(e) => println!("解析错误: {}", e),
}
match RGB::from_name("red") {
Some(color) => println!("红色: {:?}", color),
None => println!("未知颜色名称"),
}
match RGB::from_hex("invalid") {
Ok(color) => println!("颜色: {:?}", color),
Err(e) => println!("解析错误: {}", e),
}
}
fn advanced_builder_pattern() {
println!("\n=== 进阶建造者模式 ===");
#[derive(Debug)]
struct DatabaseConfig {
host: String,
port: u16,
username: String,
password: String,
database: String,
pool_size: u32,
timeout: u32,
ssl: bool,
}
// 建造者结构体
struct DatabaseConfigBuilder {
host: Option<String>,
port: Option<u16>,
username: Option<String>,
password: Option<String>,
database: Option<String>,
pool_size: Option<u32>,
timeout: Option<u32>,
ssl: Option<bool>,
}
// 默认配置
impl Default for DatabaseConfigBuilder {
fn default() -> Self {
DatabaseConfigBuilder {
host: Some("localhost".to_string()),
port: Some(5432),
username: Some("postgres".to_string()),
password: Some("".to_string()),
database: Some("mydb".to_string()),
pool_size: Some(10),
timeout: Some(30),
ssl: Some(false),
}
}
}
impl DatabaseConfigBuilder {
fn new() -> Self {
Self::default()
}
fn host(mut self, host: &str) -> Self {
self.host = Some(host.to_string());
self
}
fn port(mut self, port: u16) -> Self {
self.port = Some(port);
self
}
fn username(mut self, username: &str) -> Self {
self.username = Some(username.to_string());
self
}
fn password(mut self, password: &str) -> Self {
self.password = Some(password.to_string());
self
}
fn database(mut self, database: &str) -> Self {
self.database = Some(database.to_string());
self
}
fn pool_size(mut self, pool_size: u32) -> Self {
self.pool_size = Some(pool_size);
self
}
fn timeout(mut self, timeout: u32) -> Self {
self.timeout = Some(timeout);
self
}
fn ssl(mut self, ssl: bool) -> Self {
self.ssl = Some(ssl);
self
}
fn build(self) -> Result<DatabaseConfig, String> {
Ok(DatabaseConfig {
host: self.host.ok_or("主机名必须设置")?,
port: self.port.ok_or("端口必须设置")?,
username: self.username.ok_or("用户名必须设置")?,
password: self.password.ok_or("密码必须设置")?,
database: self.database.ok_or("数据库名必须设置")?,
pool_size: self.pool_size.unwrap_or(10),
timeout: self.timeout.unwrap_or(30),
ssl: self.ssl.unwrap_or(false),
})
}
}
// 使用建造者模式
let config = DatabaseConfigBuilder::new()
.host("db.example.com")
.port(5432)
.username("admin")
.password("secret")
.database("production")
.pool_size(20)
.timeout(60)
.ssl(true)
.build()
.unwrap();
println!("数据库配置: {:?}", config);
// 使用默认值
let default_config = DatabaseConfigBuilder::new().build().unwrap();
println!("默认配置: {:?}", default_config);
}6.4 元组结构体进阶
6.4.1 元组结构体的高级用法
深入探索元组结构体的高级特性和使用模式。
rust
fn advanced_tuple_structs() {
println!("=== 元组结构体进阶 ===");
// 1. 泛型元组结构体
generic_tuple_structs();
// 2. 元组结构体与模式匹配
tuple_struct_pattern_matching();
// 3. 元组结构体的方法实现
tuple_struct_methods();
// 4. 元组结构体的实际应用
practical_tuple_struct_applications();
}
fn generic_tuple_structs() {
println!("\n=== 泛型元组结构体 ===");
// 1. 基本泛型元组结构体
struct Pair<T>(T, T);
struct Triple<T, U, V>(T, U, V);
let int_pair = Pair(1, 2);
let string_pair = Pair("hello", "world");
let mixed_triple = Triple(1, "hello", 3.14);
println!("整数对: ({}, {})", int_pair.0, int_pair.1);
println!("字符串对: ({}, {})", string_pair.0, string_pair.1);
println!("混合三元组: ({}, {}, {})", mixed_triple.0, mixed_triple.1, mixed_triple.2);
// 2. 泛型元组结构体方法实现
impl<T> Pair<T> {
fn new(first: T, second: T) -> Self {
Pair(first, second)
}
fn first(&self) -> &T {
&self.0
}
fn second(&self) -> &T {
&self.1
}
fn into_tuple(self) -> (T, T) {
(self.0, self.1)
}
}
// 3. 特定类型的实现
impl Pair<f64> {
fn distance(&self) -> f64 {
(self.0.powi(2) + self.1.powi(2)).sqrt()
}
}
let pair = Pair::new(3.0, 4.0);
println!("点({}, {})到原点的距离: {}", pair.first(), pair.second(), pair.distance());
// 4. 复杂的泛型约束
use std::fmt::Display;
use std::ops::Add;
struct DisplayablePair<T: Display, U: Display>(T, U);
impl<T: Display, U: Display> DisplayablePair<T, U> {
fn display(&self) {
println!("显示对: ({}, {})", self.0, self.1);
}
}
let display_pair = DisplayablePair(42, "answer");
display_pair.display();
// 5. 关联类型与元组结构体
trait Container {
type Item;
fn get_item(&self) -> &Self::Item;
}
struct Single<T>(T);
impl<T> Container for Single<T> {
type Item = T;
fn get_item(&self) -> &Self::Item {
&self.0
}
}
let single = Single(42);
println!("单个容器: {}", single.get_item());
}
fn tuple_struct_pattern_matching() {
println!("\n=== 元组结构体与模式匹配 ===");
// 1. 基本元组结构体
struct Point(i32, i32, i32);
struct Color(u8, u8, u8);
let point = Point(10, 20, 30);
let color = Color(255, 0, 0);
// 2. 元组结构体解构
let Point(x, y, z) = point;
println!("解构点: x={}, y={}, z={}", x, y, z);
// 3. 模式匹配中的元组结构体
match point {
Point(0, 0, 0) => println!("原点"),
Point(x, 0, 0) => println!("在X轴上: {}", x),
Point(0, y, 0) => println!("在Y轴上: {}", y),
Point(0, 0, z) => println!("在Z轴上: {}", z),
Point(x, y, z) => println!("在空间点: ({}, {}, {})", x, y, z),
}
// 4. 匹配特定值
match color {
Color(255, 0, 0) => println!("红色"),
Color(0, 255, 0) => println!("绿色"),
Color(0, 0, 255) => println!("蓝色"),
Color(r, g, b) => println!("其他颜色: ({}, {}, {})", r, g, b),
}
// 5. 使用守卫条件
match point {
Point(x, y, z) if x == y && y == z => println!("在空间对角线上"),
Point(x, y, z) if x > 0 && y > 0 && z > 0 => println!("在第一卦限"),
Point(x, y, z) if x < 0 && y < 0 && z < 0 => println!("在第七卦限"),
_ => println!("在其他位置"),
}
// 6. 嵌套模式匹配
struct Line(Point, Point);
let line = Line(Point(0, 0, 0), Point(1, 1, 1));
match line {
Line(Point(0, 0, 0), Point(1, 1, 1)) => println!("从原点到(1,1,1)的直线"),
Line(Point(x1, y1, z1), Point(x2, y2, z2)) => {
println!("从({},{},{})到({},{},{})的直线", x1, y1, z1, x2, y2, z2);
}
}
}
fn tuple_struct_methods() {
println!("\n=== 元组结构体方法实现 ===");
// 1. 基本元组结构体
struct Vector2D(f64, f64);
struct Vector3D(f64, f64, f64);
impl Vector2D {
// 关联函数
fn new(x: f64, y: f64) -> Self {
Vector2D(x, y)
}
fn zero() -> Self {
Vector2D(0.0, 0.0)
}
// 实例方法
fn magnitude(&self) -> f64 {
(self.0 * self.0 + self.1 * self.1).sqrt()
}
fn dot(&self, other: &Vector2D) -> f64 {
self.0 * other.0 + self.1 * other.1
}
fn scale(&self, factor: f64) -> Vector2D {
Vector2D(self.0 * factor, self.1 * factor)
}
// 消耗self的方法
fn into_3d(self, z: f64) -> Vector3D {
Vector3D(self.0, self.1, z)
}
}
impl Vector3D {
fn new(x: f64, y: f64, z: f64) -> Self {
Vector3D(x, y, z)
}
fn magnitude(&self) -> f64 {
(self.0 * self.0 + self.1 * self.1 + self.2 * self.2).sqrt()
}
fn cross(&self, other: &Vector3D) -> Vector3D {
Vector3D(
self.1 * other.2 - self.2 * other.1,
self.2 * other.0 - self.0 * other.2,
self.0 * other.1 - self.1 * other.0,
)
}
}
// 使用向量方法
let v1 = Vector2D::new(3.0, 4.0);
let v2 = Vector2D::new(1.0, 2.0);
println!("向量1: ({}, {})", v1.0, v1.1);
println!("向量1的模: {}", v1.magnitude());
println!("向量1和向量2的点积: {}", v1.dot(&v2));
println!("向量1缩放2倍: ({}, {})", v1.scale(2.0).0, v1.scale(2.0).1);
let v3d = v1.into_3d(5.0);
println!("转换为3D向量: ({}, {}, {})", v3d.0, v3d.1, v3d.2);
// 3D向量运算
let v3 = Vector3D::new(1.0, 0.0, 0.0);
let v4 = Vector3D::new(0.0, 1.0, 0.0);
let cross = v3.cross(&v4);
println!("向量叉积: ({}, {}, {})", cross.0, cross.1, cross.2);
}
fn practical_tuple_struct_applications() {
println!("\n=== 元组结构体实际应用 ===");
// 1. 错误处理中的元组结构体
error_handling_with_tuple_structs();
// 2. 状态机中的元组结构体
state_machines_with_tuple_structs();
// 3. 解析器中的元组结构体
parsers_with_tuple_structs();
}
fn error_handling_with_tuple_structs() {
println!("\n=== 错误处理中的元组结构体 ===");
// 使用元组结构体创建有意义的错误类型
struct ParseError(String);
struct ValidationError(String);
struct NetworkError(String);
enum AppError {
Parse(ParseError),
Validation(ValidationError),
Network(NetworkError),
}
impl std::fmt::Display for AppError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
AppError::Parse(ParseError(msg)) => write!(f, "解析错误: {}", msg),
AppError::Validation(ValidationError(msg)) => write!(f, "验证错误: {}", msg),
AppError::Network(NetworkError(msg)) => write!(f, "网络错误: {}", msg),
}
}
}
// 使用元组结构体错误
fn parse_number(s: &str) -> Result<i32, ParseError> {
s.parse().map_err(|_| ParseError(format!("无法解析 '{}' 为数字", s)))
}
fn validate_age(age: i32) -> Result<(), ValidationError> {
if age < 0 {
Err(ValidationError("年龄不能为负".to_string()))
} else if age > 150 {
Err(ValidationError("年龄不能超过150".to_string()))
} else {
Ok(())
}
}
// 测试错误处理
match parse_number("42") {
Ok(num) => println!("解析成功: {}", num),
Err(ParseError(msg)) => println!("解析失败: {}", msg),
}
match parse_number("abc") {
Ok(num) => println!("解析成功: {}", num),
Err(ParseError(msg)) => println!("解析失败: {}", msg),
}
match validate_age(25) {
Ok(()) => println!("验证成功"),
Err(ValidationError(msg)) => println!("验证失败: {}", msg),
}
match validate_age(200) {
Ok(()) => println!("验证成功"),
Err(ValidationError(msg)) => println!("验证失败: {}", msg),
}
}
fn state_machines_with_tuple_structs() {
println!("\n=== 状态机中的元组结构体 ===");
// 使用元组结构体表示状态机的不同状态
// 状态标记
struct Idle;
struct Running;
struct Paused;
struct Finished;
// 状态机
struct Stopwatch<State> {
start_time: std::time::Instant,
elapsed: std::time::Duration,
state: std::marker::PhantomData<State>,
}
impl Stopwatch<Idle> {
fn new() -> Self {
Stopwatch {
start_time: std::time::Instant::now(),
elapsed: std::time::Duration::default(),
state: std::marker::PhantomData,
}
}
fn start(self) -> Stopwatch<Running> {
Stopwatch {
start_time: std::time::Instant::now(),
elapsed: self.elapsed,
state: std::marker::PhantomData,
}
}
}
impl Stopwatch<Running> {
fn pause(self) -> Stopwatch<Paused> {
let elapsed = self.elapsed + self.start_time.elapsed();
Stopwatch {
start_time: std::time::Instant::now(),
elapsed,
state: std::marker::PhantomData,
}
}
fn stop(self) -> Stopwatch<Finished> {
let elapsed = self.elapsed + self.start_time.elapsed();
Stopwatch {
start_time: std::time::Instant::now(),
elapsed,
state: std::marker::PhantomData,
}
}
fn get_elapsed(&self) -> std::time::Duration {
self.elapsed + self.start_time.elapsed()
}
}
impl Stopwatch<Paused> {
fn resume(self) -> Stopwatch<Running> {
Stopwatch {
start_time: std::time::Instant::now(),
elapsed: self.elapsed,
state: std::marker::PhantomData,
}
}
fn stop(self) -> Stopwatch<Finished> {
Stopwatch {
start_time: std::time::Instant::now(),
elapsed: self.elapsed,
state: std::marker::PhantomData,
}
}
fn get_elapsed(&self) -> std::time::Duration {
self.elapsed
}
}
impl Stopwatch<Finished> {
fn get_elapsed(&self) -> std::time::Duration {
self.elapsed
}
fn reset(self) -> Stopwatch<Idle> {
Stopwatch::new()
}
}
// 使用状态机
let stopwatch = Stopwatch::<Idle>::new();
let running = stopwatch.start();
// 模拟一些工作
std::thread::sleep(std::time::Duration::from_millis(100));
let paused = running.pause();
println!("经过时间: {:?}", paused.get_elapsed());
let running_again = paused.resume();
std::thread::sleep(std::time::Duration::from_millis(50));
let finished = running_again.stop();
println!("总时间: {:?}", finished.get_elapsed());
let idle_again = finished.reset();
// 现在可以重新开始
}
fn parsers_with_tuple_structs() {
println!("\n=== 解析器中的元组结构体 ===");
// 使用元组结构体构建解析器组合子
struct Parser<I, O>(Box<dyn Fn(I) -> Result<(O, I), String>>);
impl<I, O> Parser<I, O>
where
I: Clone,
{
fn new<F>(parser: F) -> Self
where
F: Fn(I) -> Result<(O, I), String> + 'static,
{
Parser(Box::new(parser))
}
fn parse(&self, input: I) -> Result<(O, I), String> {
(self.0)(input)
}
// 映射解析结果
fn map<U, F>(self, f: F) -> Parser<I, U>
where
F: Fn(O) -> U + 'static,
{
Parser::new(move |input| {
self.parse(input).map(|(result, remaining)| (f(result), remaining))
})
}
// 组合两个解析器
fn and_then<U, F>(self, f: F) -> Parser<I, U>
where
F: Fn(O) -> Parser<I, U> + 'static,
{
Parser::new(move |input| {
let (result1, remaining1) = self.parse(input)?;
f(result1).parse(remaining1)
})
}
}
// 创建一些基本解析器
fn char_parser(c: char) -> Parser<&str, char> {
Parser::new(move |input: &str| {
if input.starts_with(c) {
Ok((c, &input[1..]))
} else {
Err(format!("期望 '{}', 找到 '{}'", c, input.chars().next().unwrap_or(' ')))
}
})
}
fn digit_parser() -> Parser<&str, u32> {
Parser::new(|input: &str| {
if let Some(c) = input.chars().next() {
if let Some(digit) = c.to_digit(10) {
return Ok((digit, &input[1..]));
}
}
Err("期望数字".to_string())
})
}
fn string_parser(s: &str) -> Parser<&str, String> {
let expected = s.to_string();
Parser::new(move |input: &str| {
if input.starts_with(s) {
Ok((expected.clone(), &input[s.len()..]))
} else {
Err(format!("期望 '{}'", s))
}
})
}
// 使用解析器
let hello_parser = string_parser("Hello");
let world_parser = string_parser("World");
match hello_parser.parse("Hello World") {
Ok((result, remaining)) => {
println!("解析结果: '{}', 剩余: '{}'", result, remaining);
match world_parser.parse(remaining.trim_start()) {
Ok((result2, remaining2)) => {
println!("第二次解析结果: '{}', 剩余: '{}'", result2, remaining2);
},
Err(e) => println!("第二次解析失败: {}", e),
}
},
Err(e) => println!("解析失败: {}", e),
}
// 测试数字解析器
match digit_parser().parse("123abc") {
Ok((digit, remaining)) => {
println!("解析的数字: {}, 剩余: '{}'", digit, remaining);
},
Err(e) => println!("数字解析失败: {}", e),
}
// 组合解析器
let hello_world_parser = string_parser("Hello")
.and_then(|_| string_parser(" World"));
match hello_world_parser.parse("Hello World") {
Ok((result, remaining)) => {
println!("组合解析结果: '{}', 剩余: '{}'", result, remaining);
},
Err(e) => println!("组合解析失败: {}", e),
}
}通过本章的全面学习，你已经深入掌握了Rust中结构体和方法的各个方面。从基础的结构体定义到高级的关联函数模式，从简单的方法语法到复杂的设计模式应用，你现在应该能够熟练地使用结构体和方法来组织数据和行为了。在下一章中，我们将探讨枚举与模式匹配，这是Rust中另一个强大的特性。