不要用 boxed trait objects

淡淡的烟草味﹌ 2022-09-12 13:49 106阅读 0赞

### 文章目录 ###

*  起步
 *  什么是 boxed trait 对象 ?
 *  \`Box\` 有什么问题吗？
 *  结构体泛型
 *  总结
 *  感谢

# 起步 #

此文基本算是 [《Don’t use boxed trait objects》][Don_t use boxed trait objects] 的中译，但又不全是 [《Don’t use boxed trait objects》][Don_t use boxed trait objects] 的中译。

# 什么是 boxed trait 对象 ? #

通常来说，rust 中的 trait 类似于 go 里的 interface —— 一个存放 n(n>=0 ) 个方法的集合，而 go 借助 interface 这一概念，很容易实现“多态”的效果。

看一个 golang 版本的“小鸟飞”示例：

package main
    
    import (
    	"flag"
    	"fmt"
    )
    
    type Bird interface { 
    	fly()
    }
    
    // Woodpecker 啄木鸟
    type Woodpecker struct { }
    
    func (Woodpecker) fly()  { 
    	fmt.Println("啄木鸟 在飞...")
    }
    
    
    // Cuckoo 杜鹃鸟
    type Cuckoo struct { }
    
    func (Cuckoo) fly()  { 
    	fmt.Println("杜鹃鸟 在飞...")
    }
    
    func GetOneKindBirdByName(name string) Bird {   // 这里返回的是 Bird interface
    	switch name { 
    	case "woodpecker":
    		return Woodpecker{ }
    	case "cuckoo":
    		return Cuckoo{ }
    	default:
    		panic("IncompleteError") // 尚未实现
    	}
    }
    
    var name = flag.String("name", "woodpecker/cuckoo", "输入鸟的名字")
    
    func main() { 
    	flag.Parse()
    	bird := GetOneKindBirdByName(*name)
    	bird.fly()
    }

运行效果如下：

PS D:\code\go-test> .\go-test.exe -h
    Usage of D:\code\go-test\go-test.exe:
      -name string
            输入鸟的名字 (default "woodpecker/cuckoo")
    PS D:\code\go-test> .\go-test.exe -name=woodpecker
    啄木鸟 在飞...  # 此时 bird 的具体类型是 Woodpecker
    PS D:\code\go-test> .\go-test.exe -name=cuckoo
    杜鹃鸟 在飞...  # 此时 bird 的具体类型是 Cuckoo
    PS D:\code\go-test>

也就是说，不到执行完 `GetOneKindBirdByName` 函数，我们总是不知道 main 函数中变量 bird 的具体类型。

--------------------

既然 trait ≈ interface，是不是也可以照葫芦画瓢一个 rust 版的“小鸟飞”呢？像下面这样：

use clap::{App, Arg};
    
    trait Bird {
        fn fly(&self);
    }
    
    struct Woodpecker {}
    
    impl Bird for Woodpecker {
        fn fly(&self) {
            println!("啄木鸟 在飞...")
        }
    }
    
    struct Cuckoo {}
    
    impl Bird for Cuckoo {
        fn fly(&self) {
            println!("杜鹃鸟 在飞...")
        }
    }
    
    // ！！！不可正常运行的代码
    fn get_one_kind_bird_by_name(name: String) -> Bird {
        match name.as_str() {
            "cuckoo" => Cuckoo {},
            "woodpecker" => Woodpecker {},
            _ => panic!("IncompleteError"),
        }
    }
    
    fn main() {
        // 解析命令行参数
        let opts = App::new("choose one kind bird")
            .arg(
                Arg::with_name("name")
                    .short("name")
                    .long("name")
                    .value_name("woodpecker/cuckoo")
                    .help("输入鸟的名字")
                    .takes_value(true),
            )
            .get_matches();
        
        let name = opts.value_of("name").unwrap().into();
        let bird = get_one_kind_bird_by_name(name);
        bird.fly();
    }

上述的写法跟 go 版的如出一辙，看起来很合理的样子。可编译会报错，报错信息里反复强调 `doesn't have a size known at compile-time`：

49 | fn get_one_kind_bird_by_name(name: String) -> Bird {
       |                                               ^^^^ doesn't have a size known at compile-time
       ...
    70 |     let bird = get_one_kind_bird_by_name(name);
       |         ^^^^ doesn't have a size known at compile-time
       ...
    70 |     let bird = get_one_kind_bird_by_name(name);
       |                ^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time

这是 rust 的特点，**它无法忍受栈上面有个不知道大小的变量** —— 其他语言也不能忍受，只是 rust 不会帮你做隐式处理。我们只需要**把未知大小的变量放到堆上**，再**用栈上的已知大小的指针**指过去就可以了。有请 Box。

// 可正常运行的代码
    fn get_one_kind_bird_by_name(name: String) -> Box<dyn Bird> {
        match name.as_str() {
            "cuckoo" => Box::new(Cuckoo {}),
            "woodpecker" => Box::new(Woodpecker {}),
            _ => panic!("IncompleteError"),
        }
    }

运行效果如下：

$ ./rust-code -h
    choose one kind bird 
    
    USAGE:
        rust-code [OPTIONS]
    
    FLAGS:
        -h, --help       Prints help information
        -V, --version    Prints version information
    
    OPTIONS:
        -n, --name <woodpecker/cuckoo>    输入鸟的名字
    $ ./rust-code --name=woodpecker
    啄木鸟 在飞...
    $ ./rust-code --name=cuckoo
    杜鹃鸟 在飞...

--------------------

简单总结一下。当需要用接口变量接收一个实例时，go 只需要声明这个变量是什么接口类型即可：

// go
    var bird Bird = Woodpecker{ }

而 rust 不但需要明确是什么接口（trait），还需要明确这个实例要在堆上：

// rust
    let bird: Box<dyn Bird> = Box::new(Woodpecker{});

这就是 boxed trait 对象，你大可将其类比为 go 中的接口实例。

# `Box<dyn Trait>` 有什么问题吗？ #

如果你对 go 的接口有一定了解你就知道，interface 的存在还有一个意义：**隔离**，“屏蔽”掉这个实例与接口无关的那部分内容。无可厚非，这样做好像没错。可如果我们需要原来的具体类型呢？这好办，用**类型断言**：

// Woodpecker 啄木鸟
    type Woodpecker struct { 
    	name string
    }
    
    func main() { 
    	var bird Bird = Woodpecker{ name: "啄木鸟"}
    	if woodpecker, ok := bird.(Woodpecker); ok { 
    		fmt.Println(woodpecker.name)
    	}
    	// 你不能 fmt.Println(bird.name)
    }

rust 不支持类型断言，但可以用 downcast 还原类型。这需要在 trait 中添加 `fn as_any(&self) -> &dyn Any`：

use std::any::Any;
    
    trait Bird {
        fn fly(&self);
        fn as_any(&self) -> &dyn Any;
    }
    
    struct Woodpecker {
        name: String,
    }
    
    impl Bird for Woodpecker {
        fn fly(&self) {
            println!("啄木鸟 在飞...")
        }
        // 实现 as_any 方法
        fn as_any(&self) -> &dyn Any {
            self
        }
    }
    
    fn main() {
        let bird: Box<dyn Bird> = Box::new(Woodpecker{name: "啄木鸟".into()});
        // 还原类型
        let woodpecker = bird.as_any().downcast_ref::<Woodpecker>().unwrap();
        println!("{}", woodpecker.name);
        // 你不能 println!("{}", bird.name)
    }

你会觉得莫名其妙吗？Bird trait 与 as\_any 之间本来毫无关系，我们对鸟的定义是通过能不能“飞（fly）”判断的，as\_any 插足进来破坏了 Bird trait 在设计上的纯粹。

倒也不是不能跑……但我们还可以寻求其他方法。

# 结构体泛型 #

我们试试 “wrapper + 结构体泛型” 这种解决方案。

struct Woodpecker {
        name: String,
    }
    
    struct Cuckoo {
        nick: String,
    }
    
    // ...  省略掉接口的定义与实现
    
    struct BirdWrapper<B: Bird> {
        bird: B
    }
    
    fn main() {
        let woodpecker = BirdWrapper{bird: Woodpecker{name: "啄木鸟".into()}};
        woodpecker.bird.fly();
        println!("{}", woodpecker.bird.name);  // 调用 name
        
        let cuckoo = BirdWrapper{bird: Cuckoo{nick: "杜鹃鸟".into()}};
        cuckoo.bird.fly();
        println!("{}", cuckoo.bird.nick);      // 调用 nick
    }

既能达到“多态”效果，又确保了原类型（Woodpecker / Cuckoo）不会丢失，仿佛很不错哦！从易用性的角度，还可以为 BirdWrapper 实现 Bird trait。

impl<B: Bird> Bird for BirdWrapper<B> {
        fn fly(&self) {
            self.bird.fly();
        }
    }
    
    fn main() {
        let woodpecker = BirdWrapper{bird: Woodpecker{name: "啄木鸟".into()}};
        woodpecker.fly();
        
        let cuckoo = BirdWrapper{bird: Cuckoo{nick: "杜鹃鸟".into()}};
        cuckoo.fly();
    }

--------------------

所有实现了 Bird trait 的 struct 都可以被 BirdWrapper 包装，如果你不想这样 —— 如果你要的是“只允许 Woodpecker、Cuckoo 被包装”，可以用 rust enum 限制：

// ... 省略 Woodpecker，Cuckoo 定义与接口实现
    
    enum BirdWrapper {
        Woodpecker(Woodpecker),
        Cuckoo(Cuckoo),
    }
    
    impl Bird for BirdWrapper {
        fn fly(&self) {
            match self {
                BirdWrapper::Woodpecker(woodpecker) => woodpecker.fly(),
                BirdWrapper::Cuckoo(cuckoo) => cuckoo.fly(),
            }
        }
    }
    
    fn get_one_kind_bird_by_name(name: String) -> BirdWrapper {
        match name.as_str() {
            "cuckoo" => BirdWrapper::Cuckoo(Cuckoo{nick: "啄木鸟".into()}),
            "woodpecker" => BirdWrapper::Woodpecker(Woodpecker{name: "啄木鸟".into()}),
            _ => panic!("IncompleteError"),
        }
    }
    
    fn main() {
        let bird = get_one_kind_bird_by_name("cuckoo".into());
        bird.fly();
    }

# 总结 #

尽管本文的题目叫 “不要用 boxed trait objects”，但本文并不想表达这种观点。只是内容大量参考了 [《Don’t use boxed trait objects》][Don_t use boxed trait objects]，延用标题是致敬原作者的一种表现。

所以我没有在这里强调 boxed trait 运行时会带来一定的开销，以及 “wrapper + 结构体泛型” 可以在编译时计算大小的优势。等等之类，这些都不重要。本文的存在仅出于一个目的：就是告诉 go --转–> rust 者 —— 或出于喜爱也好，或出于好奇也好 —— 在 “泛型” 的世界里，我们还有其他选择。

那就期待 go 1.18 吧！

# 感谢 #

*  参考[《Don’t use boxed trait objects》][Don_t use boxed trait objects]
 *  参考 [《Downcast Trait Object》][Downcast Trait Object]

[Don_t use boxed trait objects]: https://bennetthardwick.com/dont-use-boxed-trait-objects-for-struct-internals/
[Downcast Trait Object]: https://bennetthardwick.com/rust/downcast-trait-object/