Rust編程語言入門之Rust的面向對象編程特性

来源:https://www.cnblogs.com/QiaoPengjun/archive/2023/04/20/17338539.html
-Advertisement-
Play Games

Rust 的面向對象編程特性 一、面向對象語言的特性 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


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • JS中的for in和for of
    在JavaScript中， for...in 和 for...of 都是用於迭代迴圈的結構： 1. for...in 迴圈： for...in 迴圈主要用於遍歷對象的可枚舉屬性。這種迴圈不僅遍歷對象自身的屬性，還會遍歷原型鏈上的可枚舉屬性。它的語法如下： for (variable in objec ...
  • 【備忘錄設計模式詳解】C/Java/JS/Go/Python/TS不同語言實現
    簡介 備忘錄模式（Memento Pattern）是一種結構型設計模式。這種模式就是在不破壞封裝的條件下，將一個對象的狀態捕捉(Capture)住，並放在外部存儲起來，從而可以在將來合適的時候把這個對象還原到存儲起來的狀態。備忘錄模式常常與命令模式和迭代子模式一同使用。 備忘錄模式的角色有三個：備忘 ...
  • 一種面向後端的微服務低代碼平臺架構設計
    結合京東業務研發實際情況，針對後端研發人員，設計一個微服務低代碼平臺，助力更高效低交付業務需求。現已結業，將我在本次項目中沉澱設計出的設計文檔整理成文，期待與大家有進一步的碰撞溝通 ...
  • Opencv在VS2022中的配置（Python)
    下載Opencv 先去官網https://opencv.org/opencv-4-7-0/下載， 找到適合你設備的版本下載Windows就是Win pack,完成後進行安裝即可，一路同意預設就行，可以更改安裝位置，但路徑上儘可能以英文，以防止後面不必要的問題。 2.下載Python 首先是版本 發文 ...
  • 【Visual Leak Detector】源碼下載
    說明 使用 VLD 記憶體泄漏檢測工具輔助開發時整理的學習筆記。本篇介紹 VLD 源碼的下載。同系列文章目錄可見 《記憶體泄漏檢測工具》目錄 1. 下載途徑 以 v2.5.1 版本為例，可以到 Github-KindDragon-vld 頁面下載 master 的 zip 源碼包，如下所示： 也可以到 ...
  • 原來這就是所謂的 JSR！
    相信大家在學習 Java 的過程中，或多或少都見過 JSR 這個詞。本篇文章就科普下什麼是 JSR。 什麼是 JSR ？ JSR（Java Specification Requests），是指 Java 規範請求（或者活規範提案）。這個請求（提案）是提給 JCP 的（Java Community P ...
  • hackathon 復盤：niche 海外軟體工具正確的方法 6 個步驟
    上周末，去參加了北京思否 hackathon，兩天時間內從腦暴 & 挖掘軟體 IDEA -> Demo 研發路演，這次經歷讓我難忘。這裡我的看法是每個開發者圈友，都應該去參加一次 hackathon ~ 做 niche 軟體正確的方法 這邊先說結論，如圖。我認為 做 niche 軟體正確的方法 或 ...
  • JVM中的編譯器
    JVM中集成了兩種編譯器，Client Compiler和Server Compiler，它們的作用也不同。Client Compiler註重啟動速度和局部的優化，Server Compiler則更加關註全局的優化，性能會更好，但由於會進行更多的全局分析，所以啟動速度會變慢。兩種編譯器有著不同的應用 ...
一周排行
    -Advertisement-
    Play Games
  • WPF 已知問題 監聽 WMI 事件導致觸摸失效
    示例項目結構 在 Visual Studio 中創建一個 WinForms 應用程式後，項目結構如下所示： MyWinFormsApp/ │ ├───Properties/ │ └───Settings.settings │ ├───bin/ │ ├───Debug/ │ └───Release/ ...
  • [STAThread]特性
    [STAThread] 特性用於需要與 COM 組件交互的應用程式，尤其是依賴單線程模型（如 Windows Forms 應用程式）的組件。在 STA 模式下，線程擁有自己的消息迴圈，這對於處理用戶界面和某些 COM 組件是必要的。 [STAThread] static void Main(stri ...
  • UWP WinUI3 傳入 AddHandler 的 RoutedEventHandler 類型與事件所需不匹配將拋出參數異常
    在WinForm中使用全局異常捕獲處理 在WinForm應用程式中，全局異常捕獲是確保程式穩定性的關鍵。通過在Program類的Main方法中設置全局異常處理，可以有效地捕獲並處理未預見的異常，從而避免程式崩潰。 註冊全局異常事件 [STAThread] static void Main() { / ...
  • .NET 多版本 WinForm 開源控制項庫 SunnyUI
    前言 給大家推薦一款開源的 Winform 控制項庫，可以幫助我們開發更加美觀、漂亮的 WinForm 界面。 項目介紹 SunnyUI.NET 是一個基於 .NET Framework 4.0+、.NET 6、.NET 7 和 .NET 8 的 WinForm 開源控制項庫，同時也提供了工具類庫、擴展 ...
  • .net core8 使用Swagger（附當前源碼）
    說明 該文章是屬於OverallAuth2.0系列文章，每周更新一篇該系列文章（從0到1完成系統開發）。 該系統文章，我會儘量說的非常詳細，做到不管新手、老手都能看懂。 說明：OverallAuth2.0 是一個簡單、易懂、功能強大的許可權+可視化流程管理系統。 有興趣的朋友，請關註我吧(*^▽^*) ...
  • WPF 什麼時候 VisualTreeHelper.GetDescendantBounds 將返回無窮大
    一、下載安裝 1.下載git 必須先下載並安裝git，再TortoiseGit下載安裝 git安裝參考教程：https://blog.csdn.net/mukes/article/details/115693833 2.TortoiseGit下載與安裝 TortoiseGit，Git客戶端，32/6 ...
  • C# 開源教程帶你輕鬆掌握數據結構與演算法
    前言 在項目開發過程中，理解數據結構和演算法如同掌握蓋房子的秘訣。演算法不僅能幫助我們編寫高效、優質的代碼，還能解決項目中遇到的各種難題。 給大家推薦一個支持C#的開源免費、新手友好的數據結構與演算法入門教程：Hello演算法。 項目介紹 《Hello Algo》是一本開源免費、新手友好的數據結構與演算法入門 ...
  • 第22篇 生成proto文件bat腳本
    1.生成單個Proto.bat內容 @rem Copyright 2016, Google Inc. @rem All rights reserved. @rem @rem Redistribution and use in source and binary forms, with or with ...
  • 記一次 .NET某上位機視覺程式 卡死分析
    一：背景 1. 講故事 前段時間有位朋友找到我，說他的窗體程式在客戶這邊出現了卡死，讓我幫忙看下怎麼回事？dump也生成了，既然有dump了那就上 windbg 分析吧。 二：WinDbg 分析 1. 為什麼會卡死 窗體程式的卡死，入口門檻很低，後續往下分析就不一定了，不管怎麼說先用 !clrsta ...
  • 醫學DICOM文件與PACS系統進行數據傳輸
    前言 人工智慧時代，人臉識別技術已成為安全驗證、身份識別和用戶交互的關鍵工具。 給大家推薦一款.NET 開源提供了強大的人臉識別 API，工具不僅易於集成，還具備高效處理能力。 本文將介紹一款如何利用這些API，為我們的項目添加智能識別的亮點。 項目介紹 GitHub 上擁有 1.2k 星標的 C# ...
所有分類