Rust编程语言入门之Rust的面向对象编程特性
Posted 小乔的博客
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Rust编程语言入门之Rust的面向对象编程特性相关的知识，希望对你有一定的参考价值。
Rust 的面向对象编程特性
一、面向对象语言的特性
Rust是面向对象编程语言吗？
- Rust 受到多种编程范式的影响，包括面向对象
- 面向对象通常包含以下特性：命名对象、封装、继承
对象包含数据和行为
- “设计模式四人帮”在《设计模型》中给面向对象的定义：
- 面向对象的程序由对象组成
- 对象包装了数据和操作这些数据的过程，这些过程通常被称作方法或操作
- 基于此定义：Rust是面向对象的
- struct、enum 包含数据
- impl 块为之提供了方法
- 但带有方法的 struct、enum 并没有被称为对象
封装
- 封装：调用对象外部的代码无法直接访问对象内部的实现细节，唯一可以与对象进行交互的方法就是通过它公开的 API
- Rust：pub 关键字
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;
继承
- 继承：使对象可以沿用另外一个对象的数据和行为，且无需重复定义相关代码
- Rust：没有继承
- 使用继承的原因：
- 代码复用
- Rust：默认 trait 方法来进行代码共享
- 多态
- Rust：泛型和 trait 约束（限定参数化多态 bounded parametric）
- 代码复用
- 很多新语言都不使用继承作为内置的程序设计方案了。
二、使用 trait 对象来存储不同类型的值
有这样一个需求
- 创建一个 GUI 工具：
- 它会遍历某个元素的列表，依次调用元素的 draw 方法进行绘制
- 例如：Button、TextField 等元素
- 在面向对象语言里：
- 定义一个 Component 父类，里面定义了 draw 方法
- 定义 Button、TextField 等类，继承与 Component 类
为共有行为定义一个 trait
- Rust 避免将 struct 或 enum 称为对象，因为他们与 impl 块是分开的
- trait 对象有些类似于其它语言中的对象：
- 它们某种程度上组合了数据与行为
- trait 对象与传统对象不同的地方：
- 无法为 trait 对象添加数据
- trait 对象被专门用于抽象某些共有行为，它没其它语言中的对象那么通用
Trait 动态 lib.rs 文件
pub trait Draw
fn draw(&self);
pub struct Screen
pub components: Vec<Boc<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)
// 绘制一个按钮
泛型的实现 一次只能实现一个类型
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()
main.rs 文件
use oo::Draw;
use oo::Button, Screen;
struct SelectBox
width: u32,
height: u32,
options: Vec<String>,
impl Draw for SelectBox
fn draw(&self)
// 绘制一个选择框
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();
Trait 对象执行的是动态派发
- 将 trait 约束作用于泛型时，Rust编译器会执行单态化：
- 编译器会为我们用来替换泛型参数的每一个具体类型生成对应函数和方法的非泛型实现。
- 通过单态化生成的代码会执行静态派发（static dispatch），在编译过程中确定调用的具体方法
- 动态派发（dynamic dispatch）：
- 无法在编译过程中确定你调用的究竟是哪一种方法
- 编译器会产生额外的代码以便在运行时找出希望调用的方法
- 使用 trait 对象，会执行动态派发：
- 产生运行时开销
- 阻止编译器内联方法代码，使得部分优化操作无法进行
Trait 对象必须保证对象安全
- 只能把满足对象安全（object-safe）的 trait 转化为 trait 对象
- Rust采用一系列规则来判定某个对象是否安全，只需记住两条：
- 方法的返回类型不是 Self
- 方法中不包含任何泛型类型参数
lib.rs 文件
pub trait Draw
fn draw(&self);
pub trait Clone
fn clone(&self) -> Self;
pub struct Screen
pub components: Vec<Box<dyn Clone>>, // 报错
三、实现面向对象的设计模式
状态模式
- 状态模式（state pattern）是一种面向对象设计模式：
- 一个值拥有的内部状态由数个状态对象（state object）表达而成，而值的行为则随着内部状态的改变而改变
- 使用状态模式意味着：
- 业务需求变化时，不需要修改持有状态的值的代码，或者使用这个值的代码
- 只需要更新状态对象内部的代码，以便改变其规则，或者增加一些新的状态对象
例子：发布博客的工作流程 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());
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
""
pub fn request_review(&mut self)
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
fn request_review(self: Box<Self>) -> Box<dyn State>;
fn approve(self: Box<Self>) -> Box<dyn State>;
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 PendingRevew
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
修改之后：
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
self.state.as_ref().unwrap().content(&self)
pub fn request_review(&mut self)
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
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 PendingRevew
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
状态模式的取舍权衡
- 缺点：
- 某些状态之间是相互耦合的
- 需要重复实现一些逻辑代码
将状态和行为编码为类型
- 将状态编码为不同的类型：
- Rust 类型检查系统会通过编译时错误来阻止用户使用无效的状态
lib.rs 代码：
pub struct Post
content: String,
pub struct DraftPost
content: String,
impl Post
pub fn new() -> DraftPost
DraftPost
content: String::new(),
pub fn content(&self) -> &str
&self.content
impl DraftPost
pub fn add_text(&mut self, text: &str)
self.content.push_str(text);
pub fn request_review(self) -> PendingReviewPost
PendingReviewPost
content: self.content,
pub struct PendingReviewPost
content: String,
impl PendingReviewPost
pub fn approve(self) -> Post
Post
content: self.content,
main.rs 代码：
use blog::Post;
fn main()
let mut post = Post::new();
post.add_text("I ate a salad for lunch today");
let post = post.request_review();
let post = post.approve();
assert_eq!("I ate a salad for lunch today", post.content());
总结
- Rust 不仅能够实现面向对象的设计模式，还可以支持更多的模式
- 例如：将状态和行为编码为类型
- 面向对象的经典模式并不总是 Rust 编程实践中的最佳选择，因为 Rust具有所有权等其它面向对象语言没有的特性！
本文来自博客园，作者：QIAOPENGJUN，转载请注明原文链接：https://www.cnblogs.com/QiaoPengjun/p/17338539.html
Rust编程语言入门之编写自动化测试
编写自动化测试
一、编写和运行测试
测试（函数）
- 测试：
- 函数
- 验证非测试代码的功能是否和预期一致
- 测试函数体（通常）执行的3个操作：
- 准备数据/状态
- 运行被测试的代码
- 断言（Assert）结果
解剖测试函数
- 测试函数需要使用 test 属性（attribute）进行标注
- Attribute就是一段Rust代码的元数据
- 在函数上加 #[test]，可把函数变成测试函数
运行测试
-
使用 cargo test 命令运行所有测试函数
- Rust会构建一个 Test Runner 可执行文件
- 它会运行标注了 test 的函数，并报告其运行是否成功
-
当使用 cargo 创建 library 项目的时候，会生成一个 test module，里面有一个test 函数
- 你可以添加任意数量的 test module 或 函数
~/rust
➜ cargo new adder --lib
Created library `adder` package
~/rust
➜ cd adder
adder on master [?] via 以上是关于Rust编程语言入门之Rust的面向对象编程特性的主要内容，如果未能解决你的问题，请参考以下文章