rust笔记

1. 引用的生命周期不能长于引用的对象，不能出现野指针。有借有还
2. 生命周期注释分三步,声明，定义，使用。

pub fn parse_uri(uri: &str) -> Result<(&str, &str), int> {
    match uri.find_str("://") {
        Some(pos) => {
            let protocol = uri.slice_to(pos);
            let address = uri.slice_from(pos + 3);
            if protocol.len() == 0 || address.len() == 0 {
                Err(consts::EINVAL)
            } else {
                Ok((protocol, address))
            }
        },
        None => Err(consts::EINVAL),
    }
}

3. 只有从参数派生来的引用才能用生命周期注释，下面就不行。

fn test_ref<'r>(input: &'r str) -> &'r int {
    let num = ~123;
    &*num
}

4. 同一作用域内，只能有一个可变引用，或者无数不可变引用。
5. 长生命变量不能引用短生命变量，否则可能无法读取数据，即借用者生命周期短于持有者生命周期。
6. =给予所有权
7. .是隐式借用，因此可以实现链式调用。&是显式调用

// 调用一个自由函数需要用&运算符显式借用
let s1 = point_to_string(&p);
// 调用一个方法, 隐式借用所以不需要&运算符
let s2 = p.to_string();

8. 所有无法确定大小的数据类型都要放到堆里，也就是Box<>里，否则rustc编译器不给通过

#[derive(Clone,Debug)]
struct StackNode<T> {
    val: T,
    next: Option<Box<StackNode<T>>>,
}

option是个抽象类型，在节点指向栈尾时用到，定义如下：

pub enum Option<T> {
    None,
    Some(T),
}

9. <T:Debug+Display>(t:&T)意思是T由特性Debug和Display限定，即，T的类型必须实现Debug和Didplay的特性。为了保证函数使用特定的功能时，能找得到。

use std::fmt::{Debug, Display};
fn compare_prints<T: Debug + Display>(t: &T) {//同种类型用+
    println!("Debug: `{:?}`", t);
    println!("Display: `{}`", t);
}

fn compare_types<T: Debug, U: Debug>(t: &T, u: &U) {//不同类型用，
    println!("t: `{:?}", t);
    println!("u: `{:?}", u);
}

fn main() {
    let string = "words";
    let array = [1, 2, 3];
    let vec = vec![1, 2, 3];

    compare_prints(&string);
    //compare_prints(&array);
    // 试一试 ^ 将此行注释去掉。

    compare_types(&array, &vec);
}

其中函数print_area()中的泛型参数T被添加了一个名为HasArea的特性约束 (trait constraint)， 用以确保任何实现了HasArea的类型将拥有一个.area()方法。

fn print_area<T: HasArea>(shape: T) {
    println!("This shape has an area of {}", shape.area());
}

10. trait 特性，类似于其他语言的接口，定义某种数据类型的方法的具体行为，即某种数据类型具备了某种特性。

struct Circle {
    x: f64,
    y: f64,
    radius: f64,
}

impl HasArea for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * (self.radius * self.radius)
    }
}

fn main() {
    let c = Circle {
        x: 0.0f64,
        y: 0.0f64,
        radius: 1.0f64,
    };
    println!("circle c has an area of {}", c.area());
}

这里可以说，Circle结构具备了HasArea的特性，具有特性内定义的某些功能。使用特性中的功能时，相当于使用Circle结构的方法，直接.加上特性中的功能即可。不需要像接口那样显式赋值。
能给标准库中已有的数据类型定制方法，比如：

trait Show {
    fn show(&self) -> String;
}

impl Show for i32 {
    fn show(&self) -> String {
        format!("four-byte signed {}", self)
    }
}

impl Show for f64 {
    fn show(&self) -> String {
        format!("eight-byte float {}", self)
    }
}

fn main() {
    let answer = 42;
    let maybe_pi = 3.14;
    let v: Vec<&Show> = vec![&answer,&maybe_pi];
    for d in v.iter() {
        println!("show {}",d.show());
    }
}

11. 特性有继承，默认继承父特性内的功能写法如下：
    trait ShowTell: Show + Location {}