文章目录
- 封装
- 基于特征对象vs基于泛型
- 基于特征对象
- 静态派遣和动态派遣
- 静态派遣（Static Dispatch）
- 动态派遣（Dynamic Dispatch）
- 基于泛型
- 状态设计模式
- 面向对象的思想
- rust思想：将状态和行为编码为类型（将状态编码成类型系统）
- pub fn approve(self) 和 pub fn approve(&self)区别
- pub fn approve(&self) 的含义
- 参考
封装
pub struct AveragedCollection {
// 结构体内部的成员缺省是私有的
list: Vec<i32>,
average: f64,
}
impl AveragedCollection {
pub fn add(&mut self, value: i32) {
self.list.push(value);
self.update_average();
}
pub fn remove(&mut self) -> Option<i32> {
let result = self.list.pop();
match result {
Some(value) => {
self.update_average();
Some(value)
},
None => None,
}
}
pub fn average(&self) -> f64 {
self.average
}
fn update_average(&mut self) {
let total: i32 = self.list.iter().sum();
self.average = total as f64 / self.list.len() as f64;
}
}
基于特征对象vs基于泛型
pub trait Draw {
fn draw(&self);
}
// 基于特征对象的实现，灵活的存储实现了某一个特征的类型的对象，有一些额外的开销
pub struct Screen {
pub components: Vec<Box<dyn Draw>>,
}
impl Screen {
pub fn run(&self) {
for component in self.components.iter() {
component.draw();
}
}
}
// 基于泛型的实现，components存放的类型是同质的，没有额外的运行时的开销
pub struct Screen<T: Draw> {
pub components: Vec<T>,
}
impl<T> Screen<T>
where
T: Draw,
{
pub fn run(&self) {
for component in self.components.iter() {
component.draw();
}
}
}
基于特征对象
lib.rs
pub trait Draw {
fn draw(&self);
}
pub struct Screen {
pub components: Vec<Box<dyn Draw>>,
}
impl Screen {
pub fn run(&self) {
for component in self.components.iter() {
component.draw();
}
}
}
pub struct Button {
pub width: u32,
pub height: u32,
pub label: String,
}
impl Draw for Button {
fn draw(&self) {
// 实际绘制按钮的代码
}
}
main.rs
use gui::Draw;
use gui::{Button, Screen};
struct SelectBox {
width: u32,
height: u32,
options: Vec<String>,
}
impl Draw for SelectBox {
fn draw(&self) {
// code to actually draw a select box
}
}
fn main() {
let screen = Screen {
components: vec![
Box::new(SelectBox {
width: 75,
height: 10,
options: vec![
String::from("Yes"),
String::from("Maybe"),
String::from("No"),
],
}),
Box::new(Button {
width: 50,
height: 10,
label: String::from("OK"),
}),
],
};
screen.run();
}
静态派遣和动态派遣
在 Rust 中，静态派遣（Static Dispatch）和动态派遣（Dynamic Dispatch）是两种不同的调用方法，用于处理类型不确定的情况，尤其是在使用泛型和 trait 时。它们的主要区别在于如何确定函数调用时的具体类型，以及这一过程是在编译时还是运行时进行的。
静态派遣（Static Dispatch）
静态派遣是指在编译时就确定了函数调用的具体类型。Rust 会根据泛型的具体类型或 trait 对象的实现，生成直接调用相应方法的代码。所有这些决策都在编译时完成，因此效率较高。
如何实现：
- 泛型（Generics）：当你使用泛型时，Rust 会在编译时为每个使用的类型生成代码。
- Trait Bound：通过在泛型中指定 trait 限定（比如 T: Trait），编译器可以为每种类型生成特定的代码，从而避免运行时的开销。
trait Speak {
fn speak(&self);
}
struct Dog;
struct Cat;
impl Speak for Dog {
fn speak(&self) {
println!("Woof!");
}
}
impl Speak for Cat {
fn speak(&self) {
println!("Meow!");
}
}
fn greet<T: Speak>(animal: T) {
animal.speak();
}
fn main() {
let dog = Dog;
let cat = Cat;
greet(dog); // 静态派遣
greet(cat); // 静态派遣
}
在这个例子中，greet 函数是泛型的，它接收任何实现了 Speak trait 的类型。Rust 会在编译时为 Dog 和 Cat 生成不同的代码，这就是静态派遣。
动态派遣（Dynamic Dispatch）
动态派遣是指函数调用的具体类型在运行时才决定。Rust 通过 trait 对象（即 dyn Trait）来实现动态派遣。当你使用 trait 对象时，Rust 会在运行时查找并调用合适的方法。
如何实现：
- Trait 对象（Trait Object）：使用 dyn Trait 来创建 trait 对象，这时会使用虚拟函数表（vtable）来实现方法的调用。这个 vtable 会在运行时生成，并根据实际类型查找合适的方法。
trait Speak {
fn speak(&self);
}
struct Dog;
struct Cat;
impl Speak for Dog {
fn speak(&self) {
println!("Woof!");
}
}
impl Speak for Cat {
fn speak(&self) {
println!("Meow!");
}
}
fn greet(animal: &dyn Speak) {
animal.speak();
}
fn main() {
let dog = Dog;
let cat = Cat;
greet(&dog); // 动态派遣
greet(&cat); // 动态派遣
}
在这个例子中，greet 函数接受一个 trait 对象 &dyn Speak。这意味着它在运行时会决定调用哪个类型的 speak 方法，而不是在编译时确定。
基于泛型
要基于泛型的方式改造代码，目标是避免使用 trait 对象（Box<dyn Draw>），而是直接使用泛型类型来提供类型安全和更高效的静态派遣。
通过这种方式，Screen 的 components 不再需要使用 Box<dyn Draw>，而是直接使用泛型参数 T，这样可以在编译时确定具体类型，避免了动态分发的开销。
lib.rs
// lib.rs
pub trait Draw {
fn draw(&self);
}
pub struct Screen<T: Draw> {
pub components: Vec<T>,
}
impl<T: Draw> Screen<T> {
pub fn run(&self) {
for component in self.components.iter() {
component.draw();
}
}
}
pub struct Button {
pub width: u32,
pub height: u32,
pub label: String,
}
impl Draw for Button {
fn draw(&self) {
// 实际绘制按钮的代码
println!("Drawing Button: {}", self.label);
}
}
main.rs
// main.rs
use gui::{Button, Draw, Screen};
struct SelectBox {
width: u32,
height: u32,
options: Vec<String>,
}
impl Draw for SelectBox {
fn draw(&self) {
// 实际绘制选择框的代码
println!("Drawing SelectBox with options: {:?}", self.options);
}
}
fn main() {
// 只能放一种类型
let screen = Screen {
components: vec![SelectBox {
width: 75,
height: 10,
options: vec![
String::from("Yes"),
String::from("Maybe"),
String::from("No"),
],
}],
};
screen.run();
}
状态设计模式
状态模式（state pattern）是一个面向对象设计模式。该模式的关键在于一个值有某些内部状态，体现为一系列的 状态对象，同时值的行为随着其内部状态而改变。状态对象共享功能：当然，在 Rust 中使用结构体和 trait 而不是对象和继承。每一个状态对象负责其自身的行为，以及该状态何时应当转移至另一个状态。持有一个状态对象的值对于不同状态的行为以及何时状态转移毫不知情。
使用状态模式意味着当程序的业务需求改变时，无需修改保存状态值的代码或使用值的代码。
我们只需更新某个状态对象内部的代码，即可改变其规则，也可以增加更多的状态对象。
面向对象的思想
lib.rs
pub struct Post {
state: Option<Box<dyn State>>,
content: String,
}
impl Post {
pub fn new() -> Post {
Post {
state: Some(Box::new(Draft {})),
content: String::new(),
}
}
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
pub fn content(&self) -> &str {
// as_ref()获取的是Option<&Box<dyn State>>
// unwrap()返回的是&Box<dyn State>
// 由于dref的自动转型，所以可以直接调用content()方法
self.state.as_ref().unwrap().content(self)
}
pub fn request_review(&mut self) {
// self.state.take取出状态（移走value）结构体中state还剩下None成员
if let Some(s) = self.state.take() {
self.state = Some(s.request_review()) //获取一个新的状态
}
}
pub fn approve(&mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.approve())
}
}
}
trait State {
// 获取Self的所有权，返回State的特征对象
fn request_review(self: Box<Self>) -> Box<dyn State>;
fn approve(self: Box<Self>) -> Box<dyn State>;
fn content<'a>(&self, post: &'a Post) -> &'a str {
""
}
}
struct Draft {}
impl State for Draft {
fn request_review(self: Box<Self>) -> Box<dyn State> {
Box::new(PendingReview {})
}
fn approve(self: Box<Self>) -> Box<dyn State> {
self
}
}
struct PendingReview {}
impl State for PendingReview {
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
fn approve(self: Box<Self>) -> Box<dyn State> {
Box::new(Published {})
}
}
struct Published {}
impl State for Published {
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
fn approve(self: Box<Self>) -> Box<dyn State> {
self
}
// 入参有多个引用，输出参数也是引用，需要标注生命周期注解
fn content<'a>(&self, post: &'a Post) -> &'a str {
&post.content
}
}
main.rs
use blog::Post;
fn main() {
let mut post = Post::new();
post.add_text("I ate a salad for lunch today");
assert_eq!("", post.content());
post.request_review();
assert_eq!("", post.content());
post.approve();
assert_eq!("I ate a salad for lunch today", post.content());