Rust进阶(11)-对象

对象

1. 概述

对象、封装、继承
对象：数据和操作数据的过程
Rust里面，结构体、枚举类型加上impl块

Rust中没有继承概念，可以通过tait来进行行为共享

struct Dog {
    name: String,
}

impl Dog{
    fn print_name(&self){
        println!("Dog name = {}", self.name);
    }
}

fn main() {
    let d = Dog{name: String::from("wangcai")};
    d.print_name()
}

2. 封装

默认是私有的，标记pub后才是对外开放公有的
通过以下代码体验封装过程：

项目根目录：

[workspace]
members = [
    "getaver",
    "main",
]

创建main子项目和getaverlib

cargo new main
cargo new getaver --lib

在getaver的libs中：

pub struct AverCollect {
    list: Vec<i32>,
    aver: f64,
}

impl AverCollect {
    pub fn new() -> AverCollect {
        AverCollect {
            list: vec![],
            aver: 0.0,
        }
    }
    pub fn add(&mut self, value: i32) {
        self.list.push(value);
        self.update_average();
    }

    pub fn average(&self) -> f64 {
        self.aver
    }

    pub fn remove(&mut self) -> Option<i32> {
        let result = self.list.pop();
        match result {
            Some(value) => {
                self.update_average();
                Some(value)
            }
            None => None,
        }
    }

    fn update_average(&mut self) {
        let total: i32 = self.list.iter().sum();
        self.aver = total as f64 / self.list.len() as f64;
    }
}

在main中：

use getaver;
fn main() {
    let mut a = getaver::AverCollect::new();
    a.add(1);
    println!("average = {}", a.average());

    a.add(2);
    println!("average = {}", a.average());

    a.add(3);
    println!("average = {}", a.average());

    a.remove();
    println!("average = {}", a.average());
}

3. trait 对象

1. trait对象动态分发：
   1. 对泛型类型使用trait bound编译器进行的方式是单态化处理，单态化的代码进行的是静态分发（就是说编译器在编译的时候就知道调用了什么方法）
   2. 使用trait对象时，Rust必须使用动态分发。编译器无法知晓所有可能用于trait对象代码的类型，所以它也不知道应该调用哪个类型的哪个方法实现。为此，Rust在运行时使用trait对象中的指针来知晓需要调用哪个方法。
2. trait对象要求对象安全
   1. 只有对象安全(object safe)的trait才可以组成trait对象。trait的方法满足以下两条要求才是对象安全的：
      1. 返回值类型不为self
      2. 方法没有任何泛型类型参数

3.1 trait对象动态分发

备注，下方lib代码需要注意：泛型是单态化，一次性只能识别一种类型。如果components中多种类型，则编译会异常
lib中：

pub trait Draw {
    fn draw(&self);
}

//泛型是单态化，一次性只能识别一种类型。如果components中多种类型，则编译会异常
//因此这里不能使用泛型trait
pub struct Screen {
    pub components: Vec<Box<dyn Draw>>,   //trait对象，使用dyn关键字。这里指传入的类型要实现draw
}

impl Screen {
    pub fn run(&self) {
        for comp in self.components.iter() {
            comp.draw();
        }
    }
}

pub struct Button {
    pub width: u32,
    pub height: u32,
    pub label: String,
}

impl Draw for Button {
    fn draw(&self) {
        println!("draw button, width = {}, height = {}, label = {}", self.width, self.height, self.label);
    }
}

pub struct SelectBox {
    pub width: u32,
    pub height: u32,
    pub option: Vec<String>,
}

impl Draw for SelectBox {
    fn draw(&self) {
        println!("draw select, width = {}, height = {}, option = {:?}", self.width, self.height, self.option);
    }
}

main中：

use gui::{Screen, Button, SelectBox};

fn main() {
    let s = Screen {
        components: vec![
            Box::new(Button {
                width: 50,
                height: 10,
                label: String::from("ok"),
            }),
            Box::new(SelectBox {
                width: 60,
                height: 40,
                option: vec![
                    String::from("Yes"),
                    String::from("No"),
                    String::from("MayBe"),
                ],
            }),
        ],
    };
   s.run();
}

3.2 trait对象要求对象安全

对象安全的trait才能组成对象dyn xxx
以下代码会异常，因为Clone对象不安全，具体看前面综述：

pub struct Screen{
    pub com:Vec<Box<dyn Clone>>,
}

总结

本文编辑完毕

参考

[1] Rust 程序设计语言