Generics 在泛型变量中存储嵌套的trait实例

如果我有一个具有统一泛型类型的“外部”特征（

Collection

，如下），那么我可以创建一个具有“内部”特征类型的实例（

Collection

）。然后，我可以对该实例使用任何值，只要这些值实现嵌套特征（

Stringable

）：

代码：

fn main（）{
设mut-vs:&mut-Collection=&mut-StaticCollection{}；
对于v in vs.get_all（）{
println！（“{}”，v.string（））；
}
}
结构静态集合{}
StaticCollection的impl集合{
fn add（&mutself，v:i8）{}
fn获取所有（自我）->向量{
&vec！[1,2,3]
}
}

---

例如，是否可以编写类似于

impl Collection for StaticCollection

，以便

StaticCollection

可以存储在通用

Collection

变量中？

这取决于

StaticCollection

的实现方式，但在技术上是可行的：

impl<'a> Collection<&'a dyn Stringable> for StaticCollection {
    fn add(&mut self, v: &'a dyn Stringable) {
        
    }
    fn get_all(&self) -> &Vec<&'a dyn Stringable> { 
        panic!()
    }
}

请注意，我们在

'a

生命周期内是通用的，这是针对

Vec

的项目的，但由于特征（定义）要求

get_all

返回借用自

self

的

&Vec

，因此无法“转换”

Vec

。因此，如果您定义

StaticCollection{v:Vec}

（或

Vec

，

get_all

无法实现（如果不“泄漏”一个新的

Vec

，这可能不是您想要的）

get\u all

的完整生命周期实际上是：

fn get_all<'s>(&'s self) -> &'s Vec<&'a ...>

---

fn获取所有和的向量
&vec！[1,2,3]
part无法编译，因为它试图返回对临时对象的引用。我假设您可以解决这一问题，但在返回
Vec
时也会遇到类似的问题，因为您必须创建一个新的Vec以将其作为trait对象返回。实现
Collection
和
Collection
并没有一般问题>对于
StaticCollection
，仅您选择的界面可能会导致问题。
fn main() {
    let mut vs: &mut Collection<&dyn Stringable> = &mut StaticCollection{};
    for v in vs.get_all() {
        println!("{}", v.string());
    }
}

struct StaticCollection {}

impl Collection<i8> for StaticCollection {
    fn add(&mut self, v: i8) {}
    fn get_all(&self) -> &Vec<i8> {
        &vec![1, 2, 3]
    }
}

impl<'a> Collection<&'a dyn Stringable> for StaticCollection {
    fn add(&mut self, v: &'a dyn Stringable) {
        
    }
    fn get_all(&self) -> &Vec<&'a dyn Stringable> { 
        panic!()
    }
}

fn main() {
    let mut vs: &mut Collection<&dyn Stringable> = &mut StaticCollection { 
        v: vec![&0,&1,&2]
    };
    for v in vs.get_all() {
        println!("{}", v.string());
    }
}

struct StaticCollection {
    v: Vec<&'static dyn Stringable>,
}

impl<'a> Collection<&'a dyn Stringable> for StaticCollection {
    fn add(&mut self, v: &'a dyn Stringable) {
        
    }
    fn get_all(&self) -> &Vec<&'a dyn Stringable> { 
        &self.v
    }
}

fn get_all<'s>(&'s self) -> &'s Vec<&'a ...>