Rust中的异构集合
在某些情况下，当编写软件时，开发人员会遇到异构集合的需求——也就是说，可以存储不同类型对象的集合。在Rust中，开发人员可以通过不同的方式实现这一目标，并进行不同的权衡。
使用枚举
Rust枚举是实现这一目标的好方法，如果要存储的对象的所有实现在开发时都是已知的，那么开发人员可以创建一个枚举来封装每种可能的类型，然后为这些枚举创建一个集合。
enum ComponentType {
FirstComponent(MyFirstComponent),
SecondComponent(MySecondComponent),
}
struct MyFirstComponent {
}
impl MyFirstComponent {
fn do_first_component_thing(&self) {
println!("First Component");
}
}
struct MySecondComponent {
}
impl MySecondComponent {
fn do_second_component_thing(&self) {
println!("Second Component");
}
}
fn main() {
// 创建一个枚举集合
let mut components: Vec<ComponentType> = Vec::new();
// 将枚举添加到集合中，封装目标类型
components.push(ComponentType::FirstComponent(MyFirstComponent {}));
components.push(ComponentType::SecondComponent(MySecondComponent {}));
// 使用匹配表达式从枚举中检索对象，并访问方法和属性
if let ComponentType::FirstComponent(component) = &components[0] {
component.do_first_component_thing();
}
}
使用Trait
另一种方法是使用特征作为替代解决方案，其中：
组件的通用方法定义在Component trait中。
每个相关组件结构体实现了组件特征。
由于添加到集合中的对象的大小是未知的，因此需要将对象包装在Box中。
trait Component {
fn do_component_thing(&self);
}
struct MyFirstComponent {}
impl Component for MyFirstComponent {
fn do_component_thing(&self) {
println!("First Component");
}
}
struct MySecondComponent {}
impl Component for MySecondComponent {
fn do_component_thing(&self) {
println!("Second Component");
}
}
fn main() {
let mut components: Vec<Box<dyn Component>> = Vec::new();
components.push(Box::new(MyFirstComponent { }));
components.push(Box::new(MySecondComponent { }));
components[0].do_component_thing();
components[1].do_component_thing();
}
使用Any Trait
use std::any::Any;
struct MyFirstComponent {
}
impl MyFirstComponent {
fn do_first_component_thing(&self) {
println!("First Component");
}
}
struct MySecondComponent {
}
impl MySecondComponent {
fn do_second_component_thing(&self) {
println!("Second Component");
}
}
fn main() {
let mut components: Vec<Box<dyn Any>> = Vec::new();
components.push(Box::new(MyFirstComponent {}));
components.push(Box::new(MySecondComponent {}));
if let Some(component) =
components[0].downcast_ref::<MyFirstComponent>() {
component.do_first_component_thing();
}
if let Some(component) =
components[1].downcast_ref::<MySecondComponent>() {
component.do_second_component_thing();
}
}
虽然这仍然会始终在堆上分配对象，但现在可以在数据结构中使用不同的组件类型，将它们转换为原始类型并访问组件特定的属性和方法。
混合Any和Trait
use std::any::Any;
trait Component {
fn as_any(&self) -> &dyn Any;
}
struct MyFirstComponent {
}
impl MyFirstComponent {
fn do_first_component_thing(&self) {
println!("First Component");
}
}
impl Component for MyFirstComponent {
fn as_any(&self) -> &dyn Any {
self
}
}
struct MySecondComponent {
}
impl MySecondComponent {
fn do_second_component_thing(&self) {
println!("Second Component");
}
}
impl Component for MySecondComponent {
fn as_any(&self) -> &dyn Any {
self
}
}
fn main() {
let mut components: Vec<Box<dyn Component>> = Vec::new();
components.push(Box::new(MyFirstComponent {}));
components.push(Box::new(MySecondComponent {}));
if let Some(component) =
components[0].as_any().downcast_ref::<MyFirstComponent>() {
component.do_first_component_thing();
}
if let Some(component) =
components[1].as_any().downcast_ref::<MySecondComponent>() {
component.do_second_component_thing();
}
}
使用过程宏来减少样板代码
// 派生宏需要驻留在自己的crate中
#[proc_macro_derive(Component)]
pub fn component_macro_derive(input: TokenStream) -> TokenStream {
let ast: DeriveInput = syn::parse(input).unwrap();
let name = &ast.ident;
let gen = quote! {
impl Component for #name {
fn as_any(&self) -> &dyn Any {
self
}
}
};
gen.into()
}
// Component仍然存在于项目文件中.
#[derive(Component)]
struct MyFirstComponent {
}
impl MyFirstComponent {
fn do_first_component_thing(&self) {
println!("First Component");
}
}
总结