rust ABC （二）生命周期和泛型

rust 由于通过内存管理保证了内存安全，因此对于变量引入了生命周期机制的机制。同时虽然rust不是面向对象的语言，通过Trait机制保证了封装与继承的实现方式，可以说是和其他语言有一定区别，但是又进一步通过更先进的实现方式，达到了更好的实现效果。

生命周期和泛型

Rust 生命周期的设计目的是为了保证内存安全，其具体学习的方式可以完全类比泛型

生命周期的声明和泛型完全相同，函数如下声明如下

fn any_to_string<'a,'b,T>(some_string: &'a T) -> &'b T
where
    'a:'b,
    'a:'static,
    T: ToString + ?Sized,
{
    some_string.to_string();
    let s = some_string;
    s
}

类比如下

	泛型	生命周期
声明方式	在<> 内部声明	在<> 内部声明
作用关系	在where 中声明	在where 中声明
作用	T: ToString 表示 T 都是 String类型，都有 ToString 的 Trait ，类比继承也就是 String 是 T 的父类	‘a:’b 表示 b 的生命周期比a长，可以类比成 b 是 a 的父类
any	最大的父类	`'static` 表示内存保存在永久区中，拥有最长的生命周期，也可以理解成最大的父类

同时生命周期可以缩写，以下两种生命的是相同的

fn do_something_2<'a,'b>(some_string: &'a mut str) -> &'b str 
    where
    'a:'b,
{
    let s = some_string.trim();
    s
}

fn do_something_3<'a:'b,'b>(some_string: &'a mut str) -> &'b str {
    let s = some_string.trim();
    s
}

特性（Trait）

特性是一种类似于继承的的语言能力，和继承的区别就是他是一种组合方式，简单来说就是 A is a B 和 A has a B 的区别

特性的使用方式，一下一个例子说明，汽车有轮子就能够驾驭

#[derive(Debug)]
struct Car {
    driver: i32,
}

trait Drive {
    fn wheel(&self);
}

impl Drive for Car {
    fn wheel(&self) {
        println!("{}", self.driver);
    }
}

Box 和 dyn

如果想要获取到特性对象，就使用智能指针和 dyn 关键字获取，例如 Box<dyn Animal>。

struct Sheep {}
struct Cow {}

trait Animal {
    // 实例方法签名
    fn noise(&self) -> &'static str;
}

// 实现 `Sheep` 的 `Animal` trait。
impl Animal for Sheep {
    fn noise(&self) -> &'static str {
        "baaaaah!"
    }
}

// 实现 `Cow` 的 `Animal` trait。
impl Animal for Cow {
    fn noise(&self) -> &'static str {
        "moooooo!"
    }
}

// 返回一些实现 Animal 的结构体，但是在编译时我们不知道哪个结构体。
fn random_animal(random_number: f64) -> Box<dyn Animal> {
    if random_number < 0.5 {
        Box::new(Sheep {})
    } else {
        Box::new(Cow {})
    }
}